Merge branch 'mezuro-dev' into mezuro

Conflicts: plugins/mezuro/public/javascripts/project_content.js

Merge branch 'mezuro-dev' into mezuro
Conflicts: plugins/mezuro/public/javascripts/project_content.js
Paulo Meireles
2 parents f241c072 6df08cce
Showing 192 changed files with 3654 additions and 3072 deletions Show diff stats
features/step_definitions/mezuro_steps.rb
features/step_definitions/noosfero_steps.rb
features/support/hooks.rb
plugins/mezuro/controllers/myprofile/mezuro_plugin_base_tool_controller.rb
plugins/mezuro/controllers/myprofile/mezuro_plugin_metric_configuration_controller.rb
plugins/mezuro/controllers/myprofile/mezuro_plugin_myprofile_controller.rb
plugins/mezuro/controllers/myprofile/mezuro_plugin_range_controller.rb
plugins/mezuro/controllers/myprofile/mezuro_plugin_reading_controller.rb
plugins/mezuro/controllers/profile/mezuro_plugin_module_controller.rb
plugins/mezuro/controllers/profile/mezuro_plugin_module_result_controller.rb
plugins/mezuro/controllers/profile/mezuro_plugin_processing_controller.rb
plugins/mezuro/controllers/profile/mezuro_plugin_profile_controller.rb
plugins/mezuro/controllers/profile/mezuro_plugin_project_controller.rb
plugins/mezuro/controllers/profile/mezuro_plugin_repository_controller.rb
plugins/mezuro/features/adding_metric_configuration.feature
plugins/mezuro/features/adding_ranges.feature
plugins/mezuro/features/creating_configuration.feature
plugins/mezuro/features/creating_project.feature
plugins/mezuro/features/editing_configuration.feature
plugins/mezuro/features/initialize_monkey_server.sh
@@ -32,3 +32,17 @@ Then /^I should see &quot;([^\&quot;]*)&quot; inside an alert$/ do |message|
 	selenium.get_alert.should eql(message)
 	selenium.chooseOkOnNextConfirmation();
 end
+
+When /^I have a Mezuro project with the following data$/ do |fields|
+  item = {}
+  fields.rows_hash.each do |name, value|
+    if(name=="community")
+      item.merge!(:profile=>Profile[value])
+    else
+      item.merge!(name => value)
+    end
+  end
+  result = MezuroPlugin::ProjectContent.new(item)
+  result.save!
+end
+
@@ -761,3 +761,9 @@ Given /^there are no pending jobs$/ do
     Delayed::Worker.new.work_off
   end
 end
+
+When /^I confirm the "(.*)" dialog$/ do |confirmation|
+  a = page.driver.browser.switch_to.alert
+  assert_equal confirmation, a.text
+  a.accept
+end
@@ -1,4 +0,0 @@
-Before('@mezuro') do |scenario|
-  command = "#{RAILS_ROOT}/plugins/mezuro/features/initialize_monkey_server.sh \"#{scenario.name}\""
-  system command
-end
@@ -1,10 +0,0 @@
-class MezuroPluginBaseToolController < MezuroPluginMyprofileController
-
-  append_view_path File.join(File.dirname(__FILE__) + '/../../views')
-
-  def choose_metric
-    @configuration_content = profile.articles.find(params[:id])
-    @base_tools = Kalibro::BaseTool.all
-  end
-
-end
@@ -2,96 +2,108 @@ class MezuroPluginMetricConfigurationController &lt; MezuroPluginMyprofileControlle
  
   append_view_path File.join(File.dirname(__FILE__) + '/../../views')
  
-  def new_metric_configuration
+  def choose_metric
     @configuration_content = profile.articles.find(params[:id])
-    @metric = Kalibro::BaseTool.find_by_name(params[:base_tool]).metric params[:metric_name]
+    @base_tools = Kalibro::BaseTool.all
   end
  
-  def new_compound_metric_configuration
+  def new_native
     @configuration_content = profile.articles.find(params[:id])
-    @metric_configurations = @configuration_content.metric_configurations
-    if configuration_content_has_errors?
-      redirect_to_error_page @configuration_content.errors[:base]
-    end
+    @reading_group_names_and_ids = reading_group_names_and_ids
+    @metric = Kalibro::BaseTool.find_by_name(params[:base_tool_name]).metric params[:metric_name]
+    @metric_configuration = Kalibro::MetricConfiguration.new :base_tool_name => params[:base_tool_name], :metric => @metric
   end
  
-  def edit_metric_configuration
-    @configuration_content = profile.articles.find(params[:id])
-    @metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, params[:metric_name])
-    @metric = @metric_configuration.metric
+  def edit_native
+    params_to_edit_view
   end
  
-  def edit_compound_metric_configuration
+  def new_compound
     @configuration_content = profile.articles.find(params[:id])
-    @metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, params[:metric_name])
     @metric_configurations = @configuration_content.metric_configurations
-    @metric = @metric_configuration.metric
-  end
-
-  def create_metric_configuration
-    id = params[:id]
-    metric_name = params[:metric_configuration][:metric][:name]
-    metric_configuration = Kalibro::MetricConfiguration.new(params[:metric_configuration])
-    metric_configuration.save
-    if metric_configuration_has_errors? metric_configuration
-      redirect_to_error_page metric_configuration.errors[0].message
-    else
-      redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/metric_configuration/edit_metric_configuration?id=#{id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
+    @reading_group_names_and_ids = reading_group_names_and_ids
+    metric = Kalibro::Metric.new :compound => true
+    @metric_configuration = Kalibro::MetricConfiguration.new :metric => metric
+    if configuration_content_has_errors?
+      redirect_to_error_page @configuration_content.errors[:base]
     end
   end
  
-  def create_compound_metric_configuration
-    id = params[:id]
-    metric_name = params[:metric_configuration][:metric][:name]
-    metric_configuration = Kalibro::MetricConfiguration.new(params[:metric_configuration])
-    metric_configuration.save
-    if metric_configuration_has_errors? metric_configuration
-      redirect_to_error_page metric_configuration.errors[0].message
-    else
-      redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/metric_configuration/edit_compound_metric_configuration?id=#{id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
-    end
+  def edit_compound    
+    params_to_edit_view
   end
  
-  def update_metric_configuration
-    @configuration_content = profile.articles.find(params[:id])
-    metric_name = params[:metric_configuration][:metric][:name]
-    metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
-    metric_configuration.update_attributes params[:metric_configuration]
+  def create
+    configuration_content = profile.articles.find(params[:id])
+    metric_configuration = Kalibro::MetricConfiguration.create(params[:metric_configuration])
+    
     if metric_configuration_has_errors? metric_configuration
       redirect_to_error_page metric_configuration.errors[0].message
     else
-      redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
+      redirect_to(metric_configuration_url(configuration_content, metric_configuration.id))
     end
   end
  
-  def update_compound_metric_configuration
+  def update
     @configuration_content = profile.articles.find(params[:id])
-    metric_name = params[:metric_configuration][:metric][:name]
-    metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
+    metric_configurations = @configuration_content.metric_configurations
+    metric_configuration = find_metric_configuration(metric_configurations, params[:metric_configuration][:id].to_i)
     metric_configuration.update_attributes params[:metric_configuration]
     if metric_configuration_has_errors? metric_configuration
       redirect_to_error_page metric_configuration.errors[0].message
     else
-      redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
+      redirect_to @configuration_content.view_url
     end
   end
  
-  def remove_metric_configuration
+  def remove
     configuration_content = profile.articles.find(params[:id])
-    metric_name = params[:metric_name]
-    metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
+    configuration_id = configuration_content.configuration_id
+    metric_configuration = Kalibro::MetricConfiguration.new({:id => params[:metric_configuration_id].to_i})
     metric_configuration.destroy
     if metric_configuration_has_errors? metric_configuration
       redirect_to_error_page metric_configuration.errors[0].message
     else
-      redirect_to "/#{profile.identifier}/#{configuration_content.slug}"
+      redirect_to configuration_content.view_url
     end
   end
-  
+
   private
-  
+
+  def find_metric_configuration (metric_configurations, metric_configuration_id)
+    metric_configurations.select {|metric_configuration| metric_configuration.id == metric_configuration_id }.first
+  end
+
+  def reading_group_names_and_ids
+    array = Kalibro::ReadingGroup.all.map { |reading_group| [reading_group.name, reading_group.id] }
+    array.sort { |x,y| x.first.downcase <=> y.first.downcase }
+  end
+
+  def metric_configuration_has_errors? metric_configuration
+    not metric_configuration.errors.empty?
+  end
+
   def configuration_content_has_errors?
     not @configuration_content.errors[:base].nil?
   end
-  
+
+  def metric_configuration_url(configuration_content, metric_configuration_id)
+    url = configuration_content.view_url
+    url[:controller] = controller_name
+    url[:id] = configuration_content.id
+    url[:metric_configuration_id] = metric_configuration_id
+    url[:action] = (params[:metric_configuration][:metric][:compound] == "true" ? "edit_compound" : "edit_native")
+    url
+  end
+
+  def params_to_edit_view
+    @configuration_content = profile.articles.find(params[:id])
+    @metric_configurations = @configuration_content.metric_configurations
+    @metric_configuration = find_metric_configuration(@metric_configurations, params[:metric_configuration_id].to_i)
+    @metric = @metric_configuration.metric
+    @reading_group_names_and_ids = reading_group_names_and_ids
+    @ranges = Kalibro::Range.ranges_of(@metric_configuration.id)
+  end
+
 end
+
@@ -2,27 +2,15 @@ class MezuroPluginMyprofileController &lt; ProfileController #MyprofileController?
  
   append_view_path File.join(File.dirname(__FILE__) + '/../../views')
  
-  rescue_from Exception do |exception|
-    @message = process_error_message exception.message
-    render :partial => "error_page"
-  end
+#  rescue_from Exception do |exception|
+#    @message = process_error_message exception.message
+#    render :partial => "error_page"
+#  end
  
   def error_page
     @message = params[:message]
   end
  
-  def choose_base_tool
-    @configuration_content = profile.articles.find(params[:id])
-    @base_tools = Kalibro::BaseTool.all_names
-  end
-
-  def choose_metric
-    @configuration_content = profile.articles.find(params[:id])
-    @base_tool = params[:base_tool]
-    base_tool = Kalibro::BaseTool.find_by_name(@base_tool)
-    @supported_metrics = base_tool.nil? ? [] : base_tool.supported_metrics 
-  end
-
   protected
  
   def redirect_to_error_page(message)
@@ -30,11 +18,7 @@ class MezuroPluginMyprofileController &lt; ProfileController #MyprofileController?
     redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/error_page?message=#{message}"
   end
  
-  def metric_configuration_has_errors? metric_configuration
-    not metric_configuration.errors.empty?
-  end
-
-  def process_error_message message
+  def process_error_message message #FIXME
     if message =~ /bla/
       message
     else
@@ -2,65 +2,65 @@ class MezuroPluginRangeController &lt; MezuroPluginMyprofileController
  
   append_view_path File.join(File.dirname(__FILE__) + '/../../views')
  
-  def new_range
-    @content_id = params[:id]
-    @metric_name = params[:metric_name]
-    @range = Kalibro::Range.new
-    @range_color = "#000000"
+  def new
+    params_to_range_form
+    params_to_redirect
   end
  
-  def edit_range
-    @beginning_id = params[:beginning_id]
-    @content_id = params[:id]
-    configuration_name = profile.articles.find(@content_id).name
-    @metric_name = params[:metric_name]
-    metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_name, @metric_name)
-    @range = metric_configuration.ranges.find{|range| range.beginning == @beginning_id.to_f || @beginning_id =="-INF" }
-    @range_color = "#" + @range.color.to_s.gsub(/^ff/, "")
+  def edit
+    params_to_range_form
+    ranges = Kalibro::Range.ranges_of params[:metric_configuration_id].to_i
+    @range = (ranges.select { |range| range.id == params[:range_id].to_i }).first
   end
  
-  def create_range
-    @configuration_content = profile.articles.find(params[:id])
-    @range = Kalibro::Range.new params[:range]
-    metric_name = params[:metric_name]
-    metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
-    metric_configuration.add_range(@range)
-    metric_configuration.save
-    if metric_configuration_has_errors? metric_configuration
-      @error = metric_configuration.errors[0].message
-    end
+  def create
+    params_to_redirect
+    save_range
   end
  
-  def update_range
-    configuration_content = profile.articles.find(params[:id])
-    metric_name = params[:metric_name]
-    beginning_id = params[:beginning_id]
-    metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
-    index = metric_configuration.ranges.index{ |range| range.beginning == beginning_id.to_f || beginning_id == "-INF" }
-    metric_configuration.ranges[index] = Kalibro::Range.new params[:range]
-    metric_configuration.save
-    if metric_configuration_has_errors? metric_configuration
-      @error = metric_configuration.errors[0].message
-    end
+  def update
+    save_range
   end
  
-  def remove_range
+  def remove
     configuration_content = profile.articles.find(params[:id])
-    metric_name = params[:metric_name]
-    beginning_id = params[:beginning_id]
-    metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
-    metric_configuration.ranges.delete_if { |range| range.beginning == beginning_id.to_f || beginning_id == "-INF" }
-    metric_configuration.save
-    if metric_configuration_has_errors? metric_configuration
-      redirect_to_error_page metric_configuration.errors[0].message
-    else
-      formatted_metric_name = metric_name.gsub(/\s/, '+')
-      if metric_configuration.metric.class == Kalibro::CompoundMetric
-        redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/metric_configuration/edit_compound_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
-      else
-        redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/metric_configuration/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
-      end
+    Kalibro::Range.new({:id => params[:range_id].to_i}).destroy
+    redirect_to(metric_configuration_url(configuration_content))
+  end
+
+  private
+
+  def metric_configuration_url configuration_content
+    url = configuration_content.view_url
+    url[:controller] = "mezuro_plugin_metric_configuration"
+    url[:id] = configuration_content.id
+    url[:metric_configuration_id] = params[:metric_configuration_id].to_i
+    url[:action] = (params[:compound] ? "edit_compound" : "edit_native")
+    url
+  end
+
+  def reading_labels_and_ids
+    Kalibro::Reading.readings_of(params[:reading_group_id].to_i).map { |reading| [reading.label, reading.id] }
+  end
+
+  def save_range
+    metric_configuration_id = params[:metric_configuration_id].to_i
+    @range = Kalibro::Range.new params[:range]
+    @range.save metric_configuration_id
+    if !@range.errors.empty?
+      @error = @range.errors[0].message
     end
   end
  
+  def params_to_range_form
+    @content_id = params[:id].to_i
+    @metric_configuration_id = params[:metric_configuration_id].to_i
+    @reading_labels_and_ids = reading_labels_and_ids
+  end
+
+  def params_to_redirect
+    @reading_group_id = params[:reading_group_id].to_i
+    @compound = params[:compound]
+  end
+
 end
@@ -0,0 +1,36 @@
+class MezuroPluginReadingController < MezuroPluginMyprofileController
+
+  append_view_path File.join(File.dirname(__FILE__) + '/../../views')
+
+  def new
+    @reading_group_content = profile.articles.find(params[:id])
+  end
+
+  def save
+    reading_group_content = profile.articles.find(params[:id])
+    reading = Kalibro::Reading.new params[:reading]
+
+    if( reading.save(reading_group_content.reading_group_id) )
+      redirect_to reading_group_content.view_url
+    else
+      redirect_to_error_page reading.errors[0].message
+    end
+  end
+
+  def edit
+    @reading_group_content = profile.articles.find(params[:id])
+    @reading = Kalibro::Reading.find params[:reading_id]
+  end
+
+  def destroy
+    reading_group_content = profile.articles.find(params[:id])
+    reading = Kalibro::Reading.find params[:reading_id]
+    reading.destroy
+    if( reading.errors.empty? )
+      redirect_to reading_group_content.view_url
+    else
+      redirect_to_error_page reading.errors[0].message
+    end
+  end
+
+end
@@ -1,62 +0,0 @@
-class MezuroPluginModuleController < MezuroPluginProfileController
-
-  append_view_path File.join(File.dirname(__FILE__) + '/../../views')
-
-  def module_result
-    @content = profile.articles.find(params[:id])
-    @module_result = @content.module_result(params)
-    @module = @module_result.module
-    @module_label = "#{@module.name} (#{@module.granularity})"
-    if project_content_has_errors?
-      redirect_to_error_page(@content.errors[:base])
-    else
-      render :partial => 'module_result'
-    end
-  end
- 
-  def module_metrics_history
-    metric_name = params[:metric_name]
-    @content = profile.articles.find(params[:id])
-    module_history = @content.result_history(params[:module_name])
-    if project_content_has_errors?
-      redirect_to_error_page(@content.errors[:base])
-    else
-      @score_history = filtering_metric_history(metric_name, module_history)
-      render :partial => 'score_history'
-    end
-  end
-
-  def module_grade_history
-    @content = profile.articles.find(params[:id])
-    modules_results = @content.result_history(params[:module_name])
-    if project_content_has_errors?
-      redirect_to_error_page(@content.errors[:base])
-    else
-      @score_history = modules_results.map do |module_result|
-        [module_result.grade, format_date_to_simple_form(module_result.date)]
-      end
-      render :partial => 'score_history'
-    end
-  end
-
-  private
-
-  def filtering_metric_history(metric_name, module_history)
-    metrics_history = module_history.map do |module_result|
-      [module_result.metric_results, format_date_to_simple_form(module_result.date)]
-    end
-    metric_history =  metrics_history.map do |metric_results_with_date|
-      [(metric_results_with_date.first.select do |metric_result|
-        metric_result.metric.name.delete("() ") == metric_name
-      end).first, metric_results_with_date.last]
-    end
-    metric_history.map do |metric_result_with_date|
-      [metric_result_with_date.first.value, metric_result_with_date.last]
-    end
-  end
-
-  def format_date_to_simple_form date
-    date.to_s[0..9]
-  end
-
-end
@@ -0,0 +1,21 @@
+class MezuroPluginModuleResultController < MezuroPluginProfileController
+
+  append_view_path File.join(File.dirname(__FILE__) + '/../../views')
+
+  def module_result
+    @module_result = Kalibro::ModuleResult.find(params[:module_result_id].to_i)
+    @metric_results = Kalibro::MetricResult.metric_results_of(@module_result.id)
+    render :partial => 'module_result'
+  end
+
+  def metric_result_history
+    @history = Kalibro::MetricResult.history_of(params[:metric_name], params[:module_result_id].to_i)
+    render :partial => 'score_history'
+  end
+
+  def module_result_history
+    @history = Kalibro::ModuleResult.history_of(params[:module_result_id].to_i)
+    render :partial => 'score_history'
+  end
+
+end
@@ -0,0 +1,34 @@
+class MezuroPluginProcessingController < MezuroPluginProfileController
+
+  append_view_path File.join(File.dirname(__FILE__) + '/../../views')
+
+  def state
+    processing = processing_for_date(params[:repository_id].to_i, params[:date])
+    if processing.error.nil?
+      render :text => processing.state
+    else
+      render :text => 'ERROR'
+    end
+  end
+
+  def processing
+    @processing = processing_for_date(params[:repository_id].to_i, params[:date])
+    if @processing.error.nil?
+      render :partial => 'processing'
+    else
+      render :partial => 'processing_error'
+    end
+  end
+
+  private
+
+  def processing_for_date(repository_id, date = nil)
+    processing_class = Kalibro::Processing
+    if date.nil?
+      processing_class.processing_of(repository_id)
+    else
+      processing_class.processing_with_date_of(repository_id, date)
+    end
+  end
+
+end
+#TODO Ver quais metodos precisam estar aqui e fazer os testes
 class MezuroPluginProfileController < ProfileController
  
   append_view_path File.join(File.dirname(__FILE__) + '/../../views')
  
+=begin
   rescue_from Exception do |exception|
     @message = process_error_message exception.message
     render :partial => "error_page"
@@ -10,7 +12,7 @@ class MezuroPluginProfileController &lt; ProfileController
   def error_page
     @message = params[:message]
   end
-
+=end
   protected
  
   def process_error_message message
@@ -24,6 +26,11 @@ class MezuroPluginProfileController &lt; ProfileController
   def project_content_has_errors?
     not @content.errors[:base].nil?
   end
+  
+  def redirect_to_error_page(message)
+    message = URI.escape(CGI.escape(process_error_message(message)),'.')
+    redirect_to "/profile/#{profile.identifier}/plugin/mezuro/error_page?message=#{message}"
+  end
  
 end
  
@@ -1,50 +0,0 @@
-class MezuroPluginProjectController < MezuroPluginProfileController
-
-  append_view_path File.join(File.dirname(__FILE__) + '/../../views')
-
-  def project_state
-    @content = profile.articles.find(params[:id])
-    project = @content.project
-    if project_content_has_errors?
-      redirect_to_error_page(@content.errors[:base])
-    else
-      state = project.kalibro_error.nil? ? project.state : "ERROR"
-      render :text => state
-    end
-  end
-
-  def project_error
-    @content = profile.articles.find(params[:id])
-    @project = @content.project
-    if project_content_has_errors?
-      redirect_to_error_page(@content.errors[:base])
-    else
-      render :partial => 'project_error'
-    end
-  end
-
-  def project_result
-    @content = profile.articles.find(params[:id])
-    date = params[:date]
-    @project_result = date.nil? ? @content.project_result : @content.project_result_with_date(date)
-    if project_content_has_errors?
-      redirect_to_error_page(@content.errors[:base])
-    else
-      render :partial => 'project_result'
-    end
-  end
-
-  def project_tree
-    @content = profile.articles.find(params[:id])
-    date = params[:date]
-    project_result = date.nil? ? @content.project_result : @content.project_result_with_date(date)
-    @project_name = @content.project.name if not @content.project.nil?
-    if project_content_has_errors?
-      redirect_to_error_page(@content.errors[:base])
-    else
-      @source_tree = project_result.node(params[:module_name])
-      render :partial =>'source_tree'
-    end
-  end
-
-end
@@ -0,0 +1,67 @@
+class MezuroPluginRepositoryController < MezuroPluginProfileController
+
+  append_view_path File.join(File.dirname(__FILE__) + '/../../views')
+
+  def new
+    params_repository_form
+  end
+
+  def edit
+    params_repository_form
+    @repository = @project_content.repositories.select{ |repository| repository.id.to_s == params[:repository_id] }.first
+  end
+
+  def save
+    project_content = profile.articles.find(params[:id])
+
+    repository = Kalibro::Repository.new( params[:repository] )
+    repository.save(project_content.project_id)
+
+    if( repository.errors.empty? )
+      repository.process
+      redirect_to(repository_url(project_content, repository.id))
+    else
+      redirect_to_error_page repository.errors[0].message
+    end
+  end
+
+  def show 
+    @project_content = profile.articles.find(params[:id])
+    @repository = @project_content.repositories.select{ |repository| repository.id == params[:repository_id].to_i }.first
+    @configuration_name = Kalibro::Configuration.configuration_of(@repository.id).name
+  end
+
+  def destroy
+    project_content = profile.articles.find(params[:id])
+    repository = Kalibro::Repository.new :id => params[:repository_id] 
+    repository.destroy
+    if( repository.errors.empty? )
+      redirect_to project_content.view_url
+    else
+      redirect_to_error_page repository.errors[0].message
+    end
+  end
+
+  private
+  
+  def repository_url(project_content, repository_id)
+    url = project_content.view_url
+    url[:controller] = controller_name
+    url[:id] = project_content.id
+    url[:repository_id] = repository_id
+    url[:action] = "show"
+    url
+  end
+
+  def params_repository_form
+    @project_content = profile.articles.find(params[:id])
+    @repository_types = Kalibro::Repository.repository_types
+    
+    configurations = Kalibro::Configuration.all
+    configurations = [] if (configurations.nil?)
+    @configuration_select = configurations.map do |configuration|
+      [configuration.name,configuration.id] 
+    end
+  end
+
+end
-@mezuro
 Feature: Add metric configuration to a configuration 
   As a mezuro user
   I want to add metric configurations to a Kalibro configuration
-@mezuro
 Feature: Add range to a metric configuration 
   As a mezuro user
   I want to add ranges to a Kalibro metric configuration
-@mezuro
 Feature: Create configuration 
   As a mezuro user
   I want to create a Mezuro configuration
@@ -1,54 +0,0 @@
-@mezuro
-Feature: Create project
-  As a mezuro user
-  I want to create a Mezuro project
-
-  Background:
-    Given the following users
-      | login     | name       |
-      | joaosilva | Joao Silva |
-    And I am logged in as "joaosilva"
-    And "Mezuro" plugin is enabled
-    And the following community
-      | identifier  | name         |
-      | mycommunity | My Community |
-    And "Joao Silva" is admin of "My Community"
-
-  Scenario: I see Mezuro project's input form
-    Given I am on My Community's control panel
-    When I follow "Mezuro Project"
-    Then I should see "Title"
-    And I should see "License"
-    And I should see "Repository type"
-    And I should see "GIT"
-    And I should see "REMOTE_ZIP"
-    And I should see "REMOTE_TARBALL"
-    And I should see "SUBVERSION"
-    And I should see "Repository url"
-    And I should see "Configuration"
-    And I should see "Kalibro for Java"
-
-  Scenario: I create a Mezuro project with valid attributes
-    Given I am on My Community's control panel
-    When I create a Mezuro project with the following data
-      | Title           | Sample Project      |
-      | License         | GNU General Public License version 2.0 (GPL-2.0)                |
-      | Repository type | SUBVERSION          |
-      | Repository url  | https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator |
-      | Configuration   | Kalibro for Java    |
-    Then I should see "Sample Project"
-    And I should see "GNU General Public License version 2.0 (GPL-2.0)"
-    And I should see "SUBVERSION"
-    And I should see "https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator"
-    And I should see "Kalibro for Java"
-   
-  Scenario: I can't create a Mezuro project with invalid attributes
-    Given I am on My Community's control panel
-    When I create a Mezuro project with the following data
-      | Title           |                     |
-      | License         | GNU General Public License version 2.0 (GPL-2.0)                |
-      | Repository type | SUBVERSION          |
-      | Repository url  |                     |
-      | Configuration   | Kalibro for Java    |
-   Then I should see "The highlighted fields are mandatory."
-   And I should see "Repository URL is mandatory"
-@mezuro
 Feature: editing a configuration 
   As a mezuro user
   I want to edit a Mezuro configuration
@@ -1,9 +0,0 @@
-#!/bin/bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-MEZURO_HOME="$DIR/.."
-
-# Ignore errors from all commands
-trap "" ERR
-
-
@@ -0,0 +1,68 @@
+Feature: Project
+  As a mezuro user
+  I want to create, edit and remove a Mezuro project
+
+  Background:
+    Given the following users
+      | login     | name       |
+      | joaosilva | Joao Silva |
+    And I am logged in as "joaosilva"
+    And "Mezuro" plugin is enabled
+    And the following community
+      | identifier  | name         |
+      | mycommunity | My Community |
+    And "Joao Silva" is admin of "My Community"
+
+  Scenario: I see Mezuro project's input form
+    Given I am on mycommunity's control panel
+    When I follow "Mezuro project"
+    Then I should see "Title"
+    And I should see "Description"
+
+  Scenario: I create a Mezuro project with valid attributes
+    Given I am on mycommunity's control panel
+    When I create a Mezuro project with the following data
+      | Title           | Sample Project      |
+      | Description     | Sample Description  |
+    Then I should see "Sample Project"
+    And I should see "Sample Description"
+    And I should see "Add Repository"
+
+	@selenium 
+	Scenario: I edit a Mezuro project
+		When I have a Mezuro project with the following data
+      | name        | Sample Project     |
+      | description | Sample Description |
+      | community   | mycommunity        |
+		And I am on article "Sample Project"
+		And I should be on /mycommunity/sample-project
+		Then I should see "Sample Project"
+    And I should see "Sample Description"
+    And I should see "Add Repository"
+		When I follow "Edit"
+    # Not complete
+		
+#	@selenium
+#	Scenario: I delete a Mezuro project that belongs to me
+#		Given the following Mezuro project
+#      | name               | description         | owner    |
+#      | Sample Project     | Sample Description  | joaosilva |
+#		And I am on article "Sample Project"
+#		And I should be on /joaosilva/sample-project
+#		When I follow "Delete"
+#		And I confirm the "Are you sure that you want to remove the item "Sample Project"?" dialog
+#		Then I go to /joaosilva/sample-project
+#		And I should see "There is no such page: /joaosilva/sample-project"
+#		
+#  @selenium
+#	Scenario: I cannot delete a Mezuro project that doesn't belong to me
+#		Given the following Mezuro project
+#      | name               | description         | owner    |
+#      | Sample Project     | Sample Description  | joaosilva |
+#		And I am on article "Sample Project"
+#		And I should be on /joaosilva/sample-project
+#		When I follow "Delete"
+#		And I confirm the "Are you sure that you want to remove the item "Sample Project"?" dialog
+#		Then I go to /joaosilva/sample-project
+#		And I should see "There is no such page: /joaosilva/sample-project"
+		
-@mezuro
 Feature: Remove a metric configuration from a configuration 
   As a mezuro user
   I want to remove metric configurations from a configuration
 class Kalibro::BaseTool < Kalibro::Model
  
-  attr_accessor :name, :description, :supported_metric
-
-  def self.all_names
-    request("BaseTool", :get_base_tool_names)[:base_tool_name].to_a
-  end
+  attr_accessor :name, :description, :collector_class_name, :supported_metric
  
   def self.find_by_name(base_tool_name)
-    new request("BaseTool", :get_base_tool, {:base_tool_name => base_tool_name})[:base_tool]
+    new request(:get_base_tool, {:base_tool_name => base_tool_name})[:base_tool]
   end
  
   def self.all
     basetools = all_names
     basetools.map{ |name| find_by_name(name) }
-  end 
+  end
+
+  def self.all_names
+    request(:all_base_tool_names)[:base_tool_name].to_a
+  end
  
   def supported_metric=(value)
-    @supported_metric = Kalibro::NativeMetric.to_objects_array value
+    @supported_metric = Kalibro::Metric.to_objects_array value
   end
  
   def supported_metrics
@@ -1,5 +0,0 @@
-class Kalibro::CompoundMetric < Kalibro::Metric
-
-  attr_accessor :script
-
-end
@@ -1,13 +0,0 @@
-class Kalibro::CompoundMetricWithError < Kalibro::Model
-  
-  attr_accessor :metric, :error
-
-  def metric=(value)
-    @metric = Kalibro::CompoundMetric.to_object value
-  end
-  
-  def error=(value)
-    @error = Kalibro::Error.to_object value
-  end
-
-end
 class Kalibro::Configuration < Kalibro::Model
  
-  attr_accessor :name, :description, :metric_configuration
+  attr_accessor :id, :name, :description
  
-  def metric_configuration=(value)
-    @metric_configuration = Kalibro::MetricConfiguration.to_objects_array value
+  def id=(value)
+    @id = value.to_i
   end
  
-  def metric_configurations
-    @metric_configuration.nil? ? [] : @metric_configuration
+  def self.configuration_of(repository_id)
+    new request(:configuration_of, {:repository_id => repository_id})[:configuration]
   end
  
-  def metric_configurations=(metric_configurations)
-    @metric_configuration = metric_configurations
+  def self.all
+    response = request(:all_configurations)[:configuration]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map {|configuration| new configuration}
   end
  
-  def self.find_by_name(configuration_name)
-    new request("Configuration", :get_configuration, {:configuration_name => configuration_name})[:configuration]
-  end
-
-  def self.all_names
-    request("Configuration", :get_configuration_names)[:configuration_name]
-  end
-
-  def update_attributes(attributes={})
-    attributes.each { |field, value| send("#{field}=", value) if self.class.is_valid?(field) }
-    save
-  end
-
-  def metric_configurations_hash
-    self.to_hash[:metric_configuration]
-  end
 end
@@ -0,0 +1,16 @@
+class Kalibro::DateMetricResult < Kalibro::Model
+  
+  attr_accessor :date, :metric_result
+
+  def date=(value)
+    @date = value.is_a?(String) ? DateTime.parse(value) : value
+  end
+
+  def metric_result=(value)
+    @metric_result = Kalibro::MetricResult.to_object value
+  end
+
+  def result
+    @metric_result.value
+  end
+end
@@ -0,0 +1,17 @@
+class Kalibro::DateModuleResult < Kalibro::Model
+  
+  attr_accessor :date, :module_result
+
+  def date=(value)
+    @date = value.is_a?(String) ? DateTime.parse(value) : value
+  end
+
+  def module_result=(value)
+    @module_result = Kalibro::ModuleResult.to_object value
+  end
+  
+  def result
+    @module_result.grade
+  end
+  
+end
@@ -1,21 +0,0 @@
-class Kalibro::Error < Kalibro::Model
-  
-  attr_accessor :error_class, :message, :stack_trace_element, :cause
-
-  def stack_trace_element=(value)
-    @stack_trace_element = Kalibro::StackTraceElement.to_objects_array value
-  end
-  
-  def stack_trace
-    @stack_trace_element
-  end
-
-  def stack_trace=(stack_trace)
-    @stack_trace_element = stack_trace
-  end
-
-  def cause=(cause_value)
-    @cause = Kalibro::Error.to_object cause_value
-  end
-
-end
@@ -0,0 +1,2 @@
+class Kalibro::Errors::RecordNotFound < Kalibro::Errors::Standard
+end
 \ No newline at end of file
@@ -0,0 +1,4 @@
+#Inspired on:
+#https://github.com/rails/rails/blob/master/activerecord/lib/active_record/errors.rb
+class Kalibro::Errors::Standard < StandardError
+end
 \ No newline at end of file
 class Kalibro::Metric < Kalibro::Model
  
-  attr_accessor :name, :scope, :description
+  attr_accessor :name, :compound, :scope, :description, :script, :language
+
+  def languages
+    @language
+  end
+
+  def languages=(languages)
+    @language = languages
+  end
+
+  def language=(value)
+    @language = Kalibro::Model.to_objects_array value
+  end
  
 end
 class Kalibro::MetricConfiguration < Kalibro::Model
  
-  NATIVE_TYPE='native'
-  COMPOUND_TYPE='compound'
+  attr_accessor :id, :code, :metric, :base_tool_name, :weight, :aggregation_form, :reading_group_id, :configuration_id
+
+  def id=(value)
+    @id = value.to_i
+  end
  
-  attr_accessor :metric, :code, :weight, :aggregation_form, :range, :configuration_name
+  def reading_group_id=(value)
+    @reading_group_id = value.to_i
+  end
  
   def metric=(value)
-    if value.kind_of?(Hash)
-      @metric = native?(value) ? Kalibro::NativeMetric.to_object(value) : Kalibro::CompoundMetric.to_object(value) 
-    else
-      @metric = value
-    end
+    @metric = Kalibro::Metric.to_object(value)
   end
  
   def weight=(value)
     @weight = value.to_f
   end
  
-  def range=(value)
-    @range = Kalibro::Range.to_objects_array value
-  end
-
-  def add_range(new_range)
-    @range = [] if @range.nil?
-    @range << new_range
-  end
-
-  def ranges
-    @range
-  end
-
-  def ranges=(ranges)
-    @range = ranges
-  end
-
   def update_attributes(attributes={})
     attributes.each { |field, value| send("#{field}=", value) if self.class.is_valid?(field) }
     save
   end
  
-  def self.find_by_configuration_name_and_metric_name(configuration_name, metric_name)
-    metric_configuration = new request("MetricConfiguration", :get_metric_configuration, {
-        :configuration_name => configuration_name,
-        :metric_name => metric_name
-      })[:metric_configuration]
-    metric_configuration.configuration_name = configuration_name
-    metric_configuration
+  def to_hash
+    super :except => [:configuration_id]
   end
  
-  def destroy
-    begin
-      self.class.request("MetricConfiguration", :remove_metric_configuration, {
-        :configuration_name => configuration_name,
-        :metric_name=> metric.name
-      })
-    rescue Exception => exception
-      add_error exception
-    end
-  end
-  
-  def to_hash
-    super :except => [:configuration_name]
+  def self.metric_configurations_of(configuration_id)
+    response = request(:metric_configurations_of, {:configuration_id => configuration_id})[:metric_configuration]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map { |metric_configuration| new metric_configuration }
   end
  
   private
  
-  def native?(value)
-    value.has_key?(:origin) ? true : false
-  end
-  
   def save_params
-    {:metric_configuration => to_hash, :configuration_name => configuration_name}
+    {:metric_configuration => self.to_hash, :configuration_id => self.configuration_id}
   end
  
 end
@@ -0,0 +1,38 @@
+class Kalibro::MetricConfigurationSnapshot < Kalibro::Model
+
+  attr_accessor :code, :weight, :aggregation_form, :metric, :base_tool_name, :range
+
+  def weight=(value)
+    @weight = value.to_f
+  end
+
+  def metric=(value)
+    if value.kind_of?(Hash)
+      @metric = Kalibro::Metric.to_object(value)
+    else
+      @metric = value
+    end
+  end
+
+  def range=(value)
+    value.to_a
+    @range = []
+
+    value.each do |range_snapshot|
+      @range << Kalibro::RangeSnapshot.to_object(range_snapshot)
+    end
+
+  end
+
+  def range_snapshot
+    range
+  end
+
+  def to_hash
+    hash = super
+    hash[:attributes!][:range] = {'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+                    'xsi:type' => 'kalibro:rangeSnapshotXml'  }
+    hash
+  end
+
+end
 class Kalibro::MetricResult < Kalibro::Model
  
-  attr_accessor :metric, :value, :range, :descendent_result, :weight
-
-  def metric=(value)
-    if value.kind_of?(Hash)
-      @metric = native?(value) ? Kalibro::NativeMetric.to_object(value) : Kalibro::CompoundMetric.to_object(value) 
-    else
-      @metric = value
+  attr_accessor :id, :configuration, :value, :error
+
+  def initialize(attributes={})
+    value = attributes[:value]
+    @value = (value == "NaN") ? attributes[:aggregated_value].to_f : value.to_f
+    attributes.each do |field, value|
+      if field!= :value and field!= :aggregated_value and self.class.is_valid?(field)
+        send("#{field}=", value)
+      end
     end
+    @errors = []
   end
  
-  def value=(value)
-    @value = value.to_f
+  def id=(value)
+    @id = value.to_i
   end
  
-  def range=(value)
-    @range = Kalibro::Range.to_object value
+  def configuration=(value)
+    @configuration = Kalibro::MetricConfigurationSnapshot.to_object value
   end
  
-  def descendent_result=(value)
-    array = value.kind_of?(Array) ? value : [value]
-    @descendent_result = array.collect {|element| element.to_f}
+  def metric_configuration_snapshot
+    configuration
   end
  
-  def descendent_results
-    @descendent_result
+  def error=(value)
+    @error = Kalibro::Throwable.to_object value
+  end
+  
+  def descendant_results
+    self.class.request(:descendant_results_of, {:metric_result_id => self.id})[:descendant_result].to_a
   end
  
-  def descendent_results=(descendent_results)
-    @descendent_result = descendent_results
+  def self.metric_results_of(module_result_id)
+    response = request(:metric_results_of, {:module_result_id => module_result_id})[:metric_result]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map {|metric_result| new metric_result}
   end
-  
-  private
-  
-  def native?(value)
-    value.has_key?(:origin) ? true : false
+
+  def self.history_of(metric_name, module_result_id)
+    response = self.request(:history_of_metric, {:metric_name => metric_name, :module_result_id => module_result_id})[:date_metric_result]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map {|date_metric_result| Kalibro::DateMetricResult.new date_metric_result}
   end
  
 end
@@ -7,20 +7,21 @@ class Kalibro::Model
     @errors = []
   end
  
+
   def to_hash(options={})
     hash = Hash.new
-    excepts = !options[:except].nil? ? options[:except] : []
+    excepts = options[:except].nil? ? [] : options[:except]
     excepts << :errors
     fields.each do |field|
       if(!excepts.include?(field))
         field_value = send(field)
         if !field_value.nil?
-          hash[field] = convert_to_hash(field_value)
+            hash[field] = convert_to_hash(field_value)
           if field_value.is_a?(Kalibro::Model)
             hash = {:attributes! => {}}.merge(hash)
             hash[:attributes!][field.to_sym] = {
               'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-              'xsi:type' => 'kalibro:' + xml_class_name(field_value)  }
+              'xsi:type' => 'kalibro:' + xml_instance_class_name(field_value)  }
           end
         end
       end
@@ -28,7 +29,7 @@ class Kalibro::Model
     hash
   end
  
-  def self.request(endpoint, action, request_body = nil)
+  def self.request(action, request_body = nil)
     response = client(endpoint).request(:kalibro, action) { soap.body = request_body }
     response.to_hash["#{action}_response".to_sym] # response is a Savon::SOAP::Response, and to_hash is a Savon::SOAP::Response method
   end
@@ -40,17 +41,25 @@ class Kalibro::Model
  
   def self.to_object value
     value.kind_of?(Hash) ? new(value) : value
-  end 
-  
+  end
+
   def self.create(attributes={})
     new_model = new attributes
     new_model.save
     new_model
   end
  
+  def self.find(id)
+    if(exists?(id))
+      new request(find_action, id_params(id))["#{class_name.underscore}".to_sym]
+    else
+      raise Kalibro::Errors::RecordNotFound
+    end
+  end
+
   def save
     begin
-      self.class.request(save_endpoint, save_action, save_params)
+      self.id = self.class.request(save_action, save_params)["#{instance_class_name.underscore}_id".to_sym]
 	    true
 	  rescue Exception => exception
 	    add_error exception
@@ -60,12 +69,16 @@ class Kalibro::Model
  
   def destroy
     begin
-      self.class.request(destroy_endpoint, destroy_action, destroy_params)
+      self.class.request(destroy_action, destroy_params)
     rescue Exception => exception
 	    add_error exception
     end
   end
  
+  def self.exists?(id)
+    request(exists_action, id_params(id))[:exists]
+  end
+
   protected
  
   def fields
@@ -76,13 +89,13 @@ class Kalibro::Model
     return value if value.nil?
     return value.collect { |element| convert_to_hash(element) } if value.is_a?(Array)
     return value.to_hash if value.is_a?(Kalibro::Model)
-    return self.class.date_with_milliseconds(value) if value.is_a?(DateTime)    
+    return self.class.date_with_milliseconds(value) if value.is_a?(DateTime)
     return 'INF' if value.is_a?(Float) and value.infinite? == 1
     return '-INF' if value.is_a?(Float) and value.infinite? == -1
-    value
+    value.to_s
   end
  
-  def xml_class_name(object)
+  def xml_instance_class_name(object)
     xml_name = object.class.name
     xml_name["Kalibro::"] = ""
     xml_name[0..0] = xml_name[0..0].downcase
@@ -97,38 +110,50 @@ class Kalibro::Model
   def self.is_valid?(field)
     field.to_s[0] != '@' and field != :attributes! and (field.to_s =~ /xsi/).nil?
   end
-  
+
   def self.date_with_milliseconds(date)
     milliseconds = "." + (date.sec_fraction * 60 * 60 * 24 * 1000).to_s
     date.to_s[0..18] + milliseconds + date.to_s[19..-1]
   end
-  
-  def class_name
+
+  def instance_class_name
     self.class.name.gsub(/Kalibro::/,"")
   end
-  
-  def save_endpoint
+
+  def self.endpoint
     class_name
   end
-  
+
   def save_action
-    "save_#{class_name.underscore}".to_sym
+    "save_#{instance_class_name.underscore}".to_sym
   end
-  
+
   def save_params
-    {class_name.underscore.to_sym => self.to_hash}
+    {instance_class_name.underscore.to_sym => self.to_hash}
   end
-  
-  def destroy_endpoint
-    class_name
-  end
-  
+
   def destroy_action
-    "remove_#{class_name.underscore}".to_sym
+    "delete_#{instance_class_name.underscore}".to_sym
   end
-  
+
   def destroy_params
-    {"#{class_name.underscore}_name".to_sym => self.name}
+    {"#{instance_class_name.underscore}_id".to_sym => self.id}
+  end
+
+  def self.class_name
+    self.name.gsub(/Kalibro::/,"")
+  end
+
+  def self.exists_action
+    "#{class_name.underscore}_exists".to_sym
+  end
+
+  def self.id_params(id)
+    {"#{class_name.underscore}_id".to_sym => id}
+  end
+
+  def self.find_action
+    "get_#{class_name.underscore}".to_sym
   end
  
   def add_error(exception)
@@ -2,17 +2,4 @@ class Kalibro::Module &lt; Kalibro::Model
  
   attr_accessor :name, :granularity
  
-  def self.parent_names(name)
-    path = []
-    ancestors = []
-    name.split(".").each do |token|
-       path << token
-       ancestors << path.join(".")
-     end
-     ancestors
-  end
-
-  def ancestor_names
-    self.class.parent_names(@name)
-  end
 end
@@ -1,21 +0,0 @@
-class Kalibro::ModuleNode < Kalibro::Model
-
-  attr_accessor :module, :child
-
-  def module=(value)
-    @module = Kalibro::Module.to_object value
-  end
-
-  def child=(value)
-    @child = Kalibro::ModuleNode.to_objects_array value
-  end
-
-  def children
-    @child
-  end
-
-  def children=(children)
-    @child = children
-  end
-
-end
 class Kalibro::ModuleResult < Kalibro::Model
  
-  attr_accessor :module, :date, :grade, :metric_result, :compound_metric_with_error
+  attr_accessor :id, :module, :grade, :parent_id
  
-  def self.find_by_project_name_and_module_name_and_date(project_name, module_name, date)
-    new request(
-    'ModuleResult',
-    :get_module_result,
-      {
-        :project_name => project_name, 
-        :module_name => module_name,
-        :date => date_with_milliseconds(date)
-      })[:module_result]
+  def self.find(id)
+    new request(:get_module_result, { :module_result_id => id })[:module_result]
   end
-  
-  def self.all_by_project_name_and_module_name(project_name, module_name)
-    response = request(
-    'ModuleResult',
-    :get_result_history,
-      {
-        :project_name => project_name, 
-        :module_name => module_name
-      })[:module_result]
-    Kalibro::ModuleResult.to_objects_array(response)
+
+  def children
+    response = self.class.request(:children_of, {:module_result_id => id})[:module_result]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map {|module_result| Kalibro::ModuleResult.new module_result}
   end
  
-  def module=(value)
-    @module = Kalibro::Module.to_object value
+  def parents
+    if parent_id.nil?
+      []
+    else
+      parent = self.class.find(parent_id)
+      parent.parents << parent
+    end
   end
  
-  def date=(value)
-    @date = value.is_a?(String) ? DateTime.parse(value) : value
-  end
-
-  def grade=(value)
-    @grade = value.to_f
+  def id=(value)
+    @id = value.to_i
   end
  
-  def metric_result=(value)
-    @metric_result = Kalibro::MetricResult.to_objects_array value
-  end
-  
-  def metric_results
-    @metric_result
-  end
-  
-  def metric_results=(metric_results)
-    @metric_result = metric_results
+  def module=(value)
+    @module = Kalibro::Module.to_object value
   end
  
-  def compound_metric_with_error=(value)
-    @compound_metric_with_error = Kalibro::CompoundMetricWithError.to_objects_array value
+  def grade=(value)
+    @grade = value.to_f
   end
  
-  def compound_metrics_with_error
-    @compound_metric_with_error
+  def parent_id=(value)
+    @parent_id = value.to_i
   end
  
-  def compound_metrics_with_error=(compound_metrics_with_error)
-    @compound_metric_with_error = compound_metrics_with_error
+  def self.history_of(module_result_id)
+    response = self.request(:history_of_module, {:module_result_id => module_result_id})[:date_module_result]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map {|date_module_result| Kalibro::DateModuleResult.new date_module_result}
   end
  
 end
@@ -1,17 +0,0 @@
-class Kalibro::NativeMetric < Kalibro::Metric
-
-  attr_accessor :origin, :language
-
-  def languages
-    @language
-  end
-
-  def languages=(languages)
-    @language = languages
-  end
-
-  def language=(value)
-    @language = Kalibro::Model.to_objects_array value
-  end
-
-end
@@ -0,0 +1,9 @@
+class Kalibro::ProcessTime < Kalibro::Model
+  
+  attr_accessor :state, :time
+
+  def time=(time)
+    @time = time.to_i
+  end
+
+end
@@ -0,0 +1,94 @@
+class Kalibro::Processing < Kalibro::Model
+
+  attr_accessor :id, :date, :state, :error, :process_time, :results_root_id
+
+  def self.processing_of(repository_id)
+    if has_ready_processing(repository_id)
+      last_ready_processing_of(repository_id)
+    else #always exists a processing, we send a requisition to kalibro to process repository
+      last_processing_of(repository_id)
+    end
+  end
+
+  def self.processing_with_date_of(repository_id, date)
+    date = date.is_a?(String) ? DateTime.parse(date) : date
+    if has_processing_after(repository_id, date)
+      first_processing_after(repository_id, date)
+    elsif has_processing_before(repository_id, date)
+      last_processing_before(repository_id, date)
+    else
+      last_processing_of(repository_id)        
+    end
+  end
+
+  def id=(value)
+    @id = value.to_i
+  end
+
+  def date=(value)
+    @date = value.is_a?(String) ? DateTime.parse(value) : value
+  end
+
+  def process_times=(value)
+    process_time=value
+  end
+
+  def process_time=(value)
+    @process_time = Kalibro::ProcessTime.to_objects_array value
+  end
+
+  def process_times
+    process_time
+  end
+
+  def error=(value)
+    @error = Kalibro::Throwable.to_object value
+  end
+
+  def results_root_id=(value)
+    @results_root_id = value.to_i
+  end
+
+  private
+
+  def self.has_processing(repository_id)
+    request(:has_processing, {:repository_id => repository_id})[:exists]
+  end
+  
+  def self.has_ready_processing(repository_id)
+    request(:has_ready_processing, {:repository_id => repository_id})[:exists]
+  end
+  
+  def self.has_processing_after(repository_id, date)
+    request(:has_processing_after, {:repository_id => repository_id, :date => date})[:exists]
+  end
+
+  def self.has_processing_before(repository_id, date)
+    request(:has_processing_before, {:repository_id => repository_id, :date => date})[:exists]
+  end
+
+  def self.last_processing_state_of(repository_id)
+    request(:last_processing_state, {:repository_id => repository_id})[:process_state]
+  end
+  
+  def self.last_ready_processing_of(repository_id)
+    new request(:last_ready_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.first_processing_of(repository_id)
+    new request(:first_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.last_processing_of(repository_id)
+    new request(:last_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.first_processing_after(repository_id, date)
+    new request(:first_processing_after, {:repository_id => repository_id, :date => date})[:processing]
+  end
+
+  def self.last_processing_before(repository_id, date)
+    new request(:last_processing_before, {:repository_id => repository_id, :date => date})[:processing]
+  end
+
+end
 class Kalibro::Project < Kalibro::Model
  
-  attr_accessor :name, :license, :description, :repository, :configuration_name, :state, :kalibro_error
+  attr_accessor :id, :name, :description
  
-  def self.all_names
-    response = request("Project", :get_project_names)[:project_name]
-    response = [] if response.nil?
-    response
-  end
-
-  def self.find_by_name(project_name)
-    new request("Project", :get_project, :project_name => project_name)[:project]
-  end
-
-  def repository=(value)
-    @repository = Kalibro::Repository.to_object value
+  def id=(value)
+    @id = value.to_i
   end
  
-  def error=(value)
-    @kalibro_error = Kalibro::Error.to_object value
-  end
-
-  def process_project(days = '0')
-    begin
-      if days.to_i.zero?
-        self.class.request("Kalibro", :process_project, {:project_name => name})
-    	else
-        self.class.request("Kalibro", :process_periodically, {:project_name => name, :period_in_days => days})
-    	end
-    rescue Exception => exception
-      add_error exception
-    end
-  end
-
-	def process_period
-	  begin
-      self.class.request("Kalibro", :get_process_period, {:project_name => name})[:period]
-    rescue Exception => exception
-      add_error exception
-    end
+  def self.all
+    response = request(:all_projects)[:project]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map {|project| new project}
   end
  
-	def cancel_periodic_process
-	  begin
-      self.class.request("Kalibro", :cancel_periodic_process, {:project_name => name})
-    rescue Exception => exception
-      add_error exception
-    end
+  def self.project_of(repository_id)
+    new request(:project_of, :repository_id => repository_id)[:project]
   end
  
 end
@@ -1,100 +0,0 @@
-class Kalibro::ProjectResult < Kalibro::Model
-
-  attr_accessor :project, :date, :load_time, :analysis_time, :source_tree, :collect_time
-
-  def self.last_result(project_name)
-    new request('ProjectResult', :get_last_result_of, {:project_name => project_name})[:project_result]
-  end
-  
-  def self.first_result(project_name)
-    new request('ProjectResult', :get_first_result_of, {:project_name => project_name})[:project_result]
-  end
-
-  def self.first_result_after(project_name, date)
-    new request('ProjectResult', :get_first_result_after, {:project_name => project_name, :date => date})[:project_result]
-  end
-
-  def self.last_result_before(project_name, date)
-    new request('ProjectResult', :get_last_result_before, {:project_name => project_name, :date => date})[:project_result]
-  end
-
-  def self.has_results?(project_name)
-    request('ProjectResult', :has_results_for, {:project_name => project_name})[:has_results]
-  end
-  
-  def self.has_results_before?(project_name, date)
-    request('ProjectResult', :has_results_before, {:project_name => project_name, :date => date})[:has_results]
-  end
-
-  def self.has_results_after?(project_name, date)
-    request('ProjectResult', :has_results_after, {:project_name => project_name, :date => date})[:has_results]
-  end
-  
-  def project=(value)
-    @project = (value.kind_of?(Hash)) ? Kalibro::Project.new(value) : value
-  end
-  
-  def date=(value)
-    @date = value.is_a?(String) ? DateTime.parse(value) : value
-  end
-
-  def load_time=(value)
-    @load_time = value.to_i
-  end
-
-  def collect_time=(value)
-    @collect_time = value.to_i
-  end
-
-  def analysis_time=(value)
-    @analysis_time = value.to_i
-  end
-  
-  def source_tree=(value)
-    @source_tree = value.kind_of?(Hash) ? Kalibro::ModuleNode.new(value) : value
-  end
-  
-  def formatted_load_time
-    format_milliseconds(@load_time)
-  end
-
-  def formatted_analysis_time
-     format_milliseconds(@analysis_time)
-  end
-
-  def format_milliseconds(value)
-    seconds = value.to_i/1000
-    hours = seconds/3600
-    seconds -= hours * 3600
-    minutes = seconds/60
-    seconds -= minutes * 60
-    "#{format(hours)}:#{format(minutes)}:#{format(seconds)}"
-  end
-
-  def format(amount)
-    ('%2d' % amount).sub(/\s/, '0')
-  end
-  
-  def node(module_name)
-    if module_name.nil? or module_name == project.name
-      node = source_tree
-    else
-		path = Kalibro::Module.parent_names(module_name)
-		parent = @source_tree
-		path.each do |node_name|
-		  parent = get_leaf_from(parent, node_name)
-		end
-		parent
-	end
-  end
-  
-  private
-
-  def get_leaf_from(node, module_name) 
-    node.children.each do |child_node|
-      return child_node if child_node.module.name == module_name
-    end
-    nil
-  end
-
-end
 class Kalibro::Range < Kalibro::Model
  
-  attr_accessor :beginning, :end, :label, :grade, :color, :comments
+  attr_accessor :id, :beginning, :end, :reading_id, :comments
+
+  def id=(value)
+    @id = value.to_i
+  end
  
   def beginning=(value)
     @beginning = value.to_f
@@ -30,12 +34,45 @@ class Kalibro::Range &lt; Kalibro::Model
     end
   end
  
-  def grade=(value)
-    @grade = value.to_f
+  def reading_id=(value)
+    @reading_id = value.to_i
+  end
+
+  def label
+    reading.label
   end
  
-	def mezuro_color
-		@color.nil? ? "e4ca2d" : @color.gsub(/^ff/, "")
-	end
+  def grade
+    reading.grade
+  end
+
+  def color
+    reading.color
+  end
+
+	def self.ranges_of( metric_configuration_id )
+    response = request(:ranges_of, {:metric_configuration_id => metric_configuration_id} )[:range]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map { |range| new range }
+  end
+  
+  def save( metric_configuration_id )
+    begin
+      self.id = self.class.request(:save_range, {:range => self.to_hash, :metric_configuration_id => metric_configuration_id})[:range_id]
+	    true
+	  rescue Exception => exception
+	    add_error exception
+	    false
+	  end
+  end
+
+  private
+  
+  def reading
+    @reading ||= Kalibro::Reading.find(reading_id)
+    @reading
+  end
  
 end
+
@@ -0,0 +1,17 @@
+class Kalibro::RangeSnapshot < Kalibro::Model
+
+  attr_accessor :beginning, :end, :label, :grade, :color, :comments
+
+  def beginning=(value)
+    @beginning = ((value == "-INF") ? -1.0/0 : value.to_f)
+  end
+
+  def end=(value)
+    @end = ((value == "INF") ? 1.0/0 : value.to_f)
+  end
+
+  def grade=(value)
+    @grade = value.to_f
+  end
+
+end
@@ -0,0 +1,38 @@
+class Kalibro::Reading < Kalibro::Model
+
+  attr_accessor :id, :label, :grade, :color
+
+  def self.find(id)
+    new request(:get_reading, {:reading_id => id})[:reading]
+  end
+
+  def self.readings_of( group_id )
+    response = request(:readings_of, {:group_id => group_id})[:reading]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map { |reading| new reading }
+  end
+  
+  def self.reading_of( range_id )
+    new request(:reading_of, {:range_id => range_id} )[:reading]
+  end
+
+  def id=(value)
+    @id = value.to_i
+  end
+
+  def grade=(value)
+    @grade = value.to_f
+  end
+
+  def save(reading_group_id)
+    begin
+      self.id = self.class.request(:save_reading, {:reading => self.to_hash, :group_id => reading_group_id})[:reading_id]
+      true
+	  rescue Exception => exception
+	    add_error exception
+	    false
+    end
+  end
+
+end
@@ -0,0 +1,30 @@
+class Kalibro::ReadingGroup < Kalibro::Model
+
+  attr_accessor :id, :name, :description
+
+  def id=(value)
+    @id = value.to_i
+  end
+
+  def self.all
+    response = request(:all_reading_groups)[:reading_group]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map { |reading_group| new reading_group }
+  end
+  
+  def self.reading_group_of( metric_configuration_id )
+    new request(:reading_group_of, {:metric_configuration_id => metric_configuration_id} )[:reading_group]
+  end
+
+  private
+
+  def self.id_params(id)
+    {:group_id => id}
+  end
+  
+  def destroy_params
+    {:group_id => self.id}
+  end
+
+end
 class Kalibro::Repository < Kalibro::Model
  
-  attr_accessor :type, :address, :username, :password
+  attr_accessor :id, :name, :description, :license, :process_period, :type, :address, :configuration_id
  
   def self.repository_types
-    request("Kalibro", :get_supported_repository_types)[:repository_type].to_a
+    request(:supported_repository_types)[:supported_type].to_a
+  end
+
+  def self.repository_of(processing_id)
+    new request(:repository_of, {:processing_id => processing_id})[:repository]
+  end
+  
+  def self.repositories_of(project_id)
+    response = request(:repositories_of, {:project_id => project_id})[:repository]
+    response = [] if response.nil?
+    response = [response] if response.is_a?(Hash) 
+    response.map {|repository| new repository}
+  end
+
+  def id=(value)
+    @id = value.to_i
+  end
+
+  def process_period=(value)
+    @process_period = value.to_i
+  end
+
+  def configuration_id=(value)
+    @configuration_id = value.to_i
+  end
+
+  def process
+    self.class.request(:process_repository, {:repository_id => self.id})
+  end
+  
+  def cancel_processing_of_repository
+    self.class.request(:cancel_processing_of_repository, {:repository_id => self.id})
+  end
+
+  def save(project_id)
+    begin
+      self.id = self.class.request(:save_repository, {:repository => self.to_hash, :project_id => project_id})[:repository_id]
+      true
+	  rescue Exception => exception
+	    add_error exception
+	    false
+    end
   end
  
 end
@@ -0,0 +1,21 @@
+class Kalibro::Throwable < Kalibro::Model
+  
+  attr_accessor :target_string, :message, :cause, :stack_trace_element
+
+  def stack_trace_element=(value)
+    @stack_trace_element = Kalibro::StackTraceElement.to_objects_array value
+  end
+  
+  def stack_trace
+    @stack_trace_element
+  end
+
+  def stack_trace=(stack_trace)
+    @stack_trace_element = stack_trace
+  end
+
+  def cause=(cause_value)
+    @cause = Kalibro::Throwable.to_object cause_value
+  end
+
+end
@@ -18,7 +18,8 @@ class MezuroPlugin &lt; Noosfero::Plugin
     if context.profile.is_a?(Community)
       MezuroPlugin::ProjectContent
     else
-      MezuroPlugin::ConfigurationContent
+      [MezuroPlugin::ConfigurationContent,
+      MezuroPlugin::ReadingGroupContent]
     end
   end
  
@@ -26,7 +27,8 @@ class MezuroPlugin &lt; Noosfero::Plugin
     if context.profile.is_a?(Community)
       {:title => _('Mezuro project'), :url => {:controller =>  'cms', :action => 'new', :profile => context.profile.identifier, :type => 'MezuroPlugin::ProjectContent'}, :icon => 'mezuro' }
     else
-      {:title => _('Mezuro configuration'), :url => {:controller =>  'cms', :action => 'new', :profile => context.profile.identifier, :type => 'MezuroPlugin::ConfigurationContent'}, :icon => 'mezuro' }
+      [{:title => _('Mezuro configuration'), :url => {:controller =>  'cms', :action => 'new', :profile => context.profile.identifier, :type => 'MezuroPlugin::ConfigurationContent'}, :icon => 'mezuro' },
+      {:title => _('Mezuro Reading Group'), :url => {:controller =>  'cms', :action => 'new', :profile => context.profile.identifier, :type => 'MezuroPlugin::ReadingGroupContent'}, :icon => 'mezuro' }]
     end
   end
  
 class MezuroPlugin::ConfigurationContent < Article
-  validate_on_create :validate_kalibro_configuration_name
+  validate_on_create :validate_configuration_name
  
-  settings_items :description, :configuration_to_clone_name
+  settings_items :configuration_id
  
-  after_save :send_kalibro_configuration_to_service
-  after_destroy :remove_kalibro_configuration_from_service
+  before_save :send_configuration_to_service
+  after_destroy :remove_configuration_from_service
  
   def self.short_description
     'Mezuro configuration'
   end
  
   def self.description
-    'Sets of thresholds to interpret metrics'
+    'Set of metric configurations to interpret a Kalibro project'
   end
  
   include ActionView::Helpers::TagHelper
@@ -21,77 +21,118 @@ class MezuroPlugin::ConfigurationContent &lt; Article
     end
   end
  
-  def kalibro_configuration
+  def kalibro_configuration   #Can't be just "configuration", method name exists somewhere in noosfero
     begin
-      @kalibro_configuration ||= Kalibro::Configuration.find_by_name(self.name)
+      @configuration ||= Kalibro::Configuration.find(self.configuration_id)
     rescue Exception => exception 
       errors.add_to_base(exception.message)
+      @configuration = nil
     end
-    @kalibro_configuration
+    @configuration
   end
  
-  def metric_configurations
-    kalibro_configuration.metric_configurations
+  def configuration_names_and_ids
+    begin
+      all_configurations = Kalibro::Configuration.all
+      all_names_and_ids = all_configurations.map { |configuration| [configuration.name, configuration.id] }
+      [["None", -1]] + (all_names_and_ids.sort { |x,y| x.first.downcase <=> y.first.downcase })
+    rescue Exception => exception
+      errors.add_to_base(exception.message)
+      [["None", -1]]
+    end
+    
   end
  
-  def kalibro_configuration_names
+  def description=(value)
+    @description=value
+  end
+  
+  def description
     begin
-      all_configuration_names = Kalibro::Configuration.all_names
-      if all_configuration_names.nil?
-         ["None"]
-      else
-         ["None"] + all_configuration_names.sort
-      end
+      @description ||= kalibro_configuration.description
+    rescue
+      @description = ""
+    end
+    @description
+  end
+
+  def configuration_to_clone_id
+    begin
+      @configuration_to_clone_id
     rescue Exception => exception
-      errors.add_to_base(exception.message)
-      ["None"]
+      nil
+    end
+  end
+
+  def configuration_to_clone_id=(value)
+    @configuration_to_clone_id = (value == -1) ? nil : value
+  end
+
+  def metric_configurations
+    begin
+      @metric_configurations ||= Kalibro::MetricConfiguration.metric_configurations_of(configuration_id)
+    rescue Exception => error
+      errors.add_to_base(error.message)
+      @metric_configurations = []
     end
+    @metric_configurations
+  end
+  
+  def metric_configurations=(value)
+    @metric_configurations = value.kind_of?(Array) ? value : [value]
+    @metric_configurations = @metric_configurations.map { |element| to_metric_configuration(element) }
   end
  
   private
  
-  def validate_kalibro_configuration_name
-    existing = kalibro_configuration_names.map { |a| a.downcase}
+  def self.to_metric_configuration value
+    value.kind_of?(Hash) ? Kalibro::MetricConfiguration.new(value) : value
+  end
+
+  def validate_configuration_name
+    existing = configuration_names_and_ids.map { |a| a.first.downcase}
  
     if existing.include?(name.downcase)
       errors.add_to_base("Configuration name already exists in Kalibro")
     end
   end
  
-  def send_kalibro_configuration_to_service
-    if editing_kalibro_configuration?
-      kalibro_configuration.update_attributes({:description => description})
-    else
-      create_kalibro_configuration
-    end
-  end
-
-  def remove_kalibro_configuration_from_service
+  def remove_configuration_from_service
     kalibro_configuration.destroy unless kalibro_configuration.nil?
   end
  
-  def create_kalibro_configuration
-    attributes = {:name => name, :description => description}
-    if cloning_kalibro_configuration?
-      attributes[:metric_configuration] = configuration_to_clone.metric_configurations_hash
-    end
-    Kalibro::Configuration.create attributes
+  def send_configuration_to_service
+    attributes = {:id => configuration_id, :name => name, :description => description}
+    created_configuration = Kalibro::Configuration.create attributes
+    self.configuration_id = created_configuration.id
+    clone_configuration if cloning_configuration?
   end
-  
-  def editing_kalibro_configuration?
-    kalibro_configuration.present?
+
+  def cloning_configuration?
+    !configuration_to_clone_id.nil?
   end
-  
-  def configuration_to_clone
-    @configuration_to_clone ||= find_configuration_to_clone
+
+  def clone_configuration
+    metric_configurations_to_clone ||= Kalibro::MetricConfiguration.metric_configurations_of(configuration_to_clone_id)
+    clone_metric_configurations metric_configurations_to_clone
   end
-  
-  def find_configuration_to_clone
-    (configuration_to_clone_name == "None") ? nil : Kalibro::Configuration.find_by_name(configuration_to_clone_name)
+
+  def clone_metric_configurations metric_configurations_to_clone
+    metric_configurations_to_clone.each do |metric_configuration|
+      clonned_metric_configuration_id = metric_configuration.id
+      metric_configuration.id = nil
+      metric_configuration.configuration_id = self.configuration_id
+      metric_configuration.save
+      clone_ranges clonned_metric_configuration_id, metric_configuration.id
+    end
   end
-  
-  def cloning_kalibro_configuration?
-    configuration_to_clone.present?
+
+  def clone_ranges clonned_metric_configuration_id, new_metric_configuration_id
+    Kalibro::Range.ranges_of(clonned_metric_configuration_id).each do |range|
+      range.id = nil
+      range.save new_metric_configuration_id
+    end
   end
  
 end
+
@@ -6,24 +6,26 @@ class MezuroPlugin::Helpers::ContentViewerHelper
     sprintf("%.2f", grade.to_f)
   end
  
-  def self.create_periodicity_options
-   [["Not Periodically", 0], ["1 day", 1], ["2 days", 2], ["Weekly", 7], ["Biweeky", 15], ["Monthly", 30]]
+  def self.periodicity_options
+    [["Not Periodically", 0], ["1 day", 1], ["2 days", 2], ["Weekly", 7], ["Biweekly", 15], ["Monthly", 30]]
   end
  
-  def self.create_license_options
+  def self.periodicity_option(periodicity)
+    periodicity_options.select {|x| x.last == periodicity}.first.first
+  end
+
+  def self.license_options
    options = YAML.load_file("#{RAILS_ROOT}/plugins/mezuro/licenses.yml")
    options = options.split(";")
-   formated_options = []
-   options.each { |option| formated_options << [option, option] }
-   formated_options
+   options
   end
  
   def self.generate_chart(score_history)
     values = []
     labels = []
     score_history.each do |score_data|
-      values << score_data.first
-      labels << score_data.last
+      values << score_data.result
+      labels << score_data.date
     end
     labels = discretize_array labels
     Gchart.line(
@@ -39,20 +41,22 @@ class MezuroPlugin::Helpers::ContentViewerHelper
                 )
   end
  
-  def self.get_periodicity_option(index)
-    options = [["Not Periodically", 0], ["1 day", 1], ["2 days", 2], ["Weekly", 7], ["Biweeky", 15], ["Monthly", 30]]
-    selected_option = options.find { |option| option.last == index.to_i }
-    selected_option.first
+  def self.format_name(metric_configuration_snapshot)
+    metric_configuration_snapshot.metric.name.delete("() ")
+  end
+  
+  def self.format_time(miliseconds)
+    seconds = miliseconds/1000
+    MezuroPluginModuleResultController.helpers.distance_of_time_in_words(0, seconds, include_seconds = true)
   end
  
-  def self.format_name(metric_result)
-    metric_result.metric.name.delete("() ")
+  def self.aggregation_options
+    [["Average","AVERAGE"], ["Median", "MEDIAN"], ["Maximum", "MAXIMUM"], ["Minimum", "MINIMUM"],
+      ["Count", "COUNT"], ["Standard Deviation", "STANDARD_DEVIATION"]]
   end
  
-  def self.get_license_option(selected)
-    options = YAML.load_file("#{RAILS_ROOT}/plugins/mezuro/licenses.yml")
-    options.split(";")
-    selected_option = options.find { |license| license == selected }
+  def self.scope_options
+    [["Software", "SOFTWARE"], ["Package", "PACKAGE"], ["Class", "CLASS"], ["Method", "METHOD"]]
   end
  
   private
@@ -0,0 +1,7 @@
+class MezuroPlugin::Helpers::ModuleResultHelper
+
+  def self.module_name name
+    name.is_a?(Array) ? name.last : name
+  end
+
+end
 class MezuroPlugin::ProjectContent < Article
   include ActionView::Helpers::TagHelper
  
-  settings_items :project_license, :description, :repository_type, :repository_url, :configuration_name, :periodicity_in_days
+  settings_items :project_id
  
-  validate_on_create :validate_kalibro_project_name 
-  validate_on_create :validate_repository_url
+  before_save :send_project_to_service
+  after_destroy :destroy_project_from_service
  
   def self.short_description
     'Mezuro project'
@@ -22,90 +22,70 @@ class MezuroPlugin::ProjectContent &lt; Article
  
   def project
     begin
-      @project ||= Kalibro::Project.find_by_name(name)
+      @project ||= Kalibro::Project.find(project_id)
     rescue Exception => error
       errors.add_to_base(error.message)
     end
     @project
   end
  
-  def project_result
-    begin
-      @project_result ||= Kalibro::ProjectResult.last_result(name)
-    rescue Exception => error
-      errors.add_to_base(error.message)
-    end
-    @project_result
-  end
-  
-  def project_result_with_date(date)
+  def repositories
     begin
-      @project_result ||= Kalibro::ProjectResult.has_results_before?(name, date) ? Kalibro::ProjectResult.last_result_before(name, date) : 
-Kalibro::ProjectResult.first_result_after(name, date)
+      @repositories ||= Kalibro::Repository.repositories_of(project_id)
     rescue Exception => error
       errors.add_to_base(error.message)
+      @repositories = []
     end
-    @project_result
+    @repositories
   end
  
-  def module_result(attributes)
-    module_name = attributes[:module_name].nil? ? project.name : attributes[:module_name]
-    date = attributes[:date].nil? ? project_result.date : project_result_with_date(attributes[:date]).date
-    begin
-      @module_result ||= Kalibro::ModuleResult.find_by_project_name_and_module_name_and_date(name, module_name, date)
-    rescue Exception => error
-      errors.add_to_base(error.message)
-    end
-    @module_result
+  def description=(value)
+    @description=value
   end
-
-  def result_history(module_name)
+  
+  def description
     begin
-      @result_history ||= Kalibro::ModuleResult.all_by_project_name_and_module_name(name, module_name)
-    rescue Exception => error
-      errors.add_to_base(error.message)
+      @description ||= project.description
+    rescue
+      @description = ""
     end
+    @description
   end
  
-  after_save :send_project_to_service
-  after_destroy :destroy_project_from_service
+  def repositories=(value)
+    @repositories = value.kind_of?(Array) ? value : [value]
+    @repositories = @repositories.map { |element| to_repository(element) }
+  end
  
   private
-
-  def validate_kalibro_project_name
-    begin
-      existing = Kalibro::Project.all_names
-    rescue Exception => error
-      errors.add_to_base(error.message)
-      existing = []
-    end
-    
-    if existing.any?{|existing_name| existing_name.casecmp(name)==0} # existing.include?(name) + case insensitive
-      errors.add_to_base("Project name already exists in Kalibro")
-    end
-  end
  
-  def validate_repository_url
-    if(repository_url.nil? || repository_url == "")
-      errors.add_to_base("Repository URL is mandatory")
+  def self.to_repository value
+    value.kind_of?(Hash) ? Kalibro::Repository.new(value) : value
+  end
+
+  def validate_repository_address
+    repositories.each do |repository|
+      if (!repository.nil?)
+        address = repository.address
+        if(address.nil? || address == "")
+          errors.add_to_base("Repository Address is mandatory")
+        end
+      else
+        errors.add_to_base("Repository is mandatory")
+      end       
     end
   end
-  
+
   def send_project_to_service
     created_project = create_kalibro_project
-    created_project.process_project(periodicity_in_days)
+    self.project_id = created_project.id
   end
  
   def create_kalibro_project
    Kalibro::Project.create(
       :name => name,
-      :license => project_license,
       :description => description,
-      :repository => {
-        :type => repository_type,
-        :address => repository_url
-      },
-      :configuration_name => configuration_name
+      :id => self.project_id
     )
   end
  
@@ -0,0 +1,83 @@
+class MezuroPlugin::ReadingGroupContent < Article
+  include ActionView::Helpers::TagHelper
+
+  settings_items :reading_group_id
+
+  before_save :send_reading_group_to_service
+  after_destroy :destroy_reading_group_from_service
+
+  def self.short_description
+    'Mezuro reading group'
+  end
+
+  def self.description
+    'Set of thresholds to interpret metric results'
+  end
+
+  def to_html(options = {})
+    lambda do
+      render :file => 'content_viewer/show_reading_group.rhtml'
+    end
+  end
+
+  def reading_group
+    begin
+      @reading_group ||= Kalibro::ReadingGroup.find(reading_group_id)
+    rescue Exception => error
+      errors.add_to_base(error.message)
+    end
+    @reading_group
+  end
+
+  def readings
+    begin
+      @readings ||= Kalibro::Reading.readings_of(reading_group_id)
+    rescue Exception => error
+      errors.add_to_base(error.message)
+      @readings = []
+    end
+    @readings
+  end
+
+  def description=(value)
+    @description=value
+  end
+  
+  def description
+    begin
+      @description ||= reading_group.description
+    rescue
+      @description = ""
+    end
+    @description
+  end
+
+  def readings=(value)
+    @readings = value.kind_of?(Array) ? value : [value]
+    @readings = @readings.map { |element| to_reading(element) }
+  end
+
+  private
+  
+  def self.to_reading value
+    value.kind_of?(Hash) ? Kalibro::Reading.new(value) : value
+  end
+
+  def send_reading_group_to_service
+    created_reading_group = create_kalibro_reading_group
+    self.reading_group_id = created_reading_group.id
+  end
+
+  def create_kalibro_reading_group
+   Kalibro::ReadingGroup.create(
+      :name => name,
+      :description => description,
+      :id => self.reading_group_id
+    )
+  end
+
+  def destroy_reading_group_from_service
+    reading_group.destroy unless reading_group.nil?
+  end
+
+end
@@ -1,22 +0,0 @@
-Copyright (c) 2012 Lakshan Perera
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
@@ -1,328 +0,0 @@
-/**
- * Really Simple Color Picker in jQuery
- *
- * Licensed under the MIT (MIT-LICENSE.txt) licenses.
- *
- * Copyright (c) 2008-2012
- * Lakshan Perera (www.laktek.com) & Daniel Lacy (daniellacy.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-(function ($) {
-    /**
-     * Create a couple private variables.
-    **/
-    var selectorOwner,
-        activePalette,
-        cItterate       = 0,
-        templates       = {
-            control : $('<div class="colorPicker-picker">&nbsp;</div>'),
-            palette : $('<div id="colorPicker_palette" class="colorPicker-palette" />'),
-            swatch  : $('<div class="colorPicker-swatch">&nbsp;</div>'),
-            hexLabel: $('<label for="colorPicker_hex">Hex</label>'),
-            hexField: $('<input type="text" id="colorPicker_hex" />')
-        },
-        transparent     = "transparent",
-        lastColor;
-
-    /**
-     * Create our colorPicker function
-    **/
-    $.fn.colorPicker = function (options) {
-
-        return this.each(function () {
-            // Setup time. Clone new elements from our templates, set some IDs, make shortcuts, jazzercise.
-            var element      = $(this),
-                opts         = $.extend({}, $.fn.colorPicker.defaults, options),
-                defaultColor = $.fn.colorPicker.toHex(
-                        (element.val().length > 0) ? element.val() : opts.pickerDefault
-                    ),
-                newControl   = templates.control.clone(),
-                newPalette   = templates.palette.clone().attr('id', 'colorPicker_palette-' + cItterate),
-                newHexLabel  = templates.hexLabel.clone(),
-                newHexField  = templates.hexField.clone(),
-                paletteId    = newPalette[0].id,
-                swatch;
-
-
-            /**
-             * Build a color palette.
-            **/
-            $.each(opts.colors, function (i) {
-                swatch = templates.swatch.clone();
-
-                if (opts.colors[i] === transparent) {
-                    swatch.addClass(transparent).text('X');
-                    $.fn.colorPicker.bindPalette(newHexField, swatch, transparent);
-                } else {
-                    swatch.css("background-color", "#" + this);
-                    $.fn.colorPicker.bindPalette(newHexField, swatch);
-                }
-                swatch.appendTo(newPalette);
-            });
-
-            newHexLabel.attr('for', 'colorPicker_hex-' + cItterate);
-
-            newHexField.attr({
-                'id'    : 'colorPicker_hex-' + cItterate,
-                'value' : defaultColor
-            });
-
-            newHexField.bind("keydown", function (event) {
-                if (event.keyCode === 13) {
-                    var hexColor = $.fn.colorPicker.toHex($(this).val());
-                    $.fn.colorPicker.changeColor(hexColor ? hexColor : element.val());
-                }
-                if (event.keyCode === 27) {
-                    $.fn.colorPicker.hidePalette();
-                }
-            });
-
-            newHexField.bind("keyup", function (event) {
-              var hexColor = $.fn.colorPicker.toHex($(event.target).val());
-              $.fn.colorPicker.previewColor(hexColor ? hexColor : element.val());
-            });
-
-            $('<div class="colorPicker_hexWrap" />').append(newHexLabel).appendTo(newPalette);
-
-            newPalette.find('.colorPicker_hexWrap').append(newHexField);
-
-            $("body").append(newPalette);
-
-            newPalette.hide();
-
-
-            /**
-             * Build replacement interface for original color input.
-            **/
-            newControl.css("background-color", defaultColor);
-
-            newControl.bind("click", function () {
-                $.fn.colorPicker.togglePalette($('#' + paletteId), $(this));
-            });
-
-            if( options && options.onColorChange ) {
-              newControl.data('onColorChange', options.onColorChange);
-            } else {
-              newControl.data('onColorChange', function() {} );
-            }
-            element.after(newControl);
-
-            element.bind("change", function () {
-                element.next(".colorPicker-picker").css(
-                    "background-color", $.fn.colorPicker.toHex($(this).val())
-                );
-            });
-
-            // Hide the original input.
-            element.val(defaultColor).hide();
-
-            cItterate++;
-        });
-    };
-
-    /**
-     * Extend colorPicker with... all our functionality.
-    **/
-    $.extend(true, $.fn.colorPicker, {
-        /**
-         * Return a Hex color, convert an RGB value and return Hex, or return false.
-         *
-         * Inspired by http://code.google.com/p/jquery-color-utils
-        **/
-        toHex : function (color) {
-            // If we have a standard or shorthand Hex color, return that value.
-            if (color.match(/[0-9A-F]{6}|[0-9A-F]{3}$/i)) {
-                return (color.charAt(0) === "#") ? color : ("#" + color);
-
-            // Alternatively, check for RGB color, then convert and return it as Hex.
-            } else if (color.match(/^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/)) {
-                var c = ([parseInt(RegExp.$1, 10), parseInt(RegExp.$2, 10), parseInt(RegExp.$3, 10)]),
-                    pad = function (str) {
-                        if (str.length < 2) {
-                            for (var i = 0, len = 2 - str.length; i < len; i++) {
-                                str = '0' + str;
-                            }
-                        }
-
-                        return str;
-                    };
-
-                if (c.length === 3) {
-                    var r = pad(c[0].toString(16)),
-                        g = pad(c[1].toString(16)),
-                        b = pad(c[2].toString(16));
-
-                    return '#' + r + g + b;
-                }
-
-            // Otherwise we wont do anything.
-            } else {
-                return false;
-
-            }
-        },
-
-        /**
-         * Check whether user clicked on the selector or owner.
-        **/
-        checkMouse : function (event, paletteId) {
-            var selector = activePalette,
-                selectorParent = $(event.target).parents("#" + selector.attr('id')).length;
-
-            if (event.target === $(selector)[0] || event.target === selectorOwner[0] || selectorParent > 0) {
-                return;
-            }
-
-            $.fn.colorPicker.hidePalette();
-        },
-
-        /**
-         * Hide the color palette modal.
-        **/
-        hidePalette : function () {
-            $(document).unbind("mousedown", $.fn.colorPicker.checkMouse);
-
-            $('.colorPicker-palette').hide();
-        },
-
-        /**
-         * Show the color palette modal.
-        **/
-        showPalette : function (palette) {
-            var hexColor = selectorOwner.prev("input").val();
-
-            palette.css({
-                top: selectorOwner.offset().top + (selectorOwner.outerHeight()),
-                left: selectorOwner.offset().left
-            });
-
-            $("#color_value").val(hexColor);
-
-            palette.show();
-
-            $(document).bind("mousedown", $.fn.colorPicker.checkMouse);
-        },
-
-        /**
-         * Toggle visibility of the colorPicker palette.
-        **/
-        togglePalette : function (palette, origin) {
-            // selectorOwner is the clicked .colorPicker-picker.
-            if (origin) {
-                selectorOwner = origin;
-            }
-
-            activePalette = palette;
-
-            if (activePalette.is(':visible')) {
-                $.fn.colorPicker.hidePalette();
-
-            } else {
-                $.fn.colorPicker.showPalette(palette);
-
-            }
-        },
-
-        /**
-         * Update the input with a newly selected color.
-        **/
-        changeColor : function (value) {
-            selectorOwner.css("background-color", value);
-            selectorOwner.prev("input").val(value).change();
-
-            $.fn.colorPicker.hidePalette();
-
-            selectorOwner.data('onColorChange').call(selectorOwner, $(selectorOwner).prev("input").attr("id"), value);
-        },
-
-
-        /**
-         * Preview the input with a newly selected color.
-        **/
-        previewColor : function (value) {
-            selectorOwner.css("background-color", value);
-        },
-
-        /**
-         * Bind events to the color palette swatches.
-        */
-        bindPalette : function (paletteInput, element, color) {
-            color = color ? color : $.fn.colorPicker.toHex(element.css("background-color"));
-
-            element.bind({
-                click : function (ev) {
-                    lastColor = color;
-
-                    $.fn.colorPicker.changeColor(color);
-                },
-                mouseover : function (ev) {
-                    lastColor = paletteInput.val();
-
-                    $(this).css("border-color", "#598FEF");
-
-                    paletteInput.val(color);
-
-                    $.fn.colorPicker.previewColor(color);
-                },
-                mouseout : function (ev) {
-                    $(this).css("border-color", "#000");
-
-                    paletteInput.val(selectorOwner.css("background-color"));
-
-                    paletteInput.val(lastColor);
-
-                    $.fn.colorPicker.previewColor(lastColor);
-                }
-            });
-        }
-    });
-
-    /**
-     * Default colorPicker options.
-     *
-     * These are publibly available for global modification using a setting such as:
-     *
-     * $.fn.colorPicker.defaults.colors = ['151337', '111111']
-     *
-     * They can also be applied on a per-bound element basis like so:
-     *
-     * $('#element1').colorPicker({pickerDefault: 'efefef', transparency: true});
-     * $('#element2').colorPicker({pickerDefault: '333333', colors: ['333333', '111111']});
-     *
-    **/
-    $.fn.colorPicker.defaults = {
-        // colorPicker default selected color.
-        pickerDefault : "FFFFFF",
-
-        // Default color set.
-        colors : [
-            '000000', '993300', '333300', '000080', '333399', '333333', '800000', 'FF6600',
-            '808000', '008000', '008080', '0000FF', '666699', '808080', 'FF0000', 'FF9900',
-            '99CC00', '339966', '33CCCC', '3366FF', '800080', '999999', 'FF00FF', 'FFCC00',
-            'FFFF00', '00FF00', '00FFFF', '00CCFF', '993366', 'C0C0C0', 'FF99CC', 'FFCC99',
-            'FFFF99', 'CCFFFF', '99CCFF', 'FFFFFF'
-        ],
-
-        // If we want to simply add more colors to the default set, use addColors.
-        addColors : []
-    };
-
-})(jQuery);
@@ -1,26 +0,0 @@
-/**
- * Really Simple Color Picker in jQuery
- * 
- * Licensed under the MIT (MIT-LICENSE.txt) licenses.
- *
- * Copyright (c) 2008-2012 
- * Lakshan Perera (www.laktek.com) & Daniel Lacy (daniellacy.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */(function(a){var b,c,d=0,e={control:a('<div class="colorPicker-picker">&nbsp;</div>'),palette:a('<div id="colorPicker_palette" class="colorPicker-palette" />'),swatch:a('<div class="colorPicker-swatch">&nbsp;</div>'),hexLabel:a('<label for="colorPicker_hex">Hex</label>'),hexField:a('<input type="text" id="colorPicker_hex" />')},f="transparent",g;a.fn.colorPicker=function(b){return this.each(function(){var c=a(this),g=a.extend({},a.fn.colorPicker.defaults,b),h=a.fn.colorPicker.toHex(c.val().length>0?c.val():g.pickerDefault),i=e.control.clone(),j=e.palette.clone().attr("id","colorPicker_palette-"+d),k=e.hexLabel.clone(),l=e.hexField.clone(),m=j[0].id,n;a.each(g.colors,function(b){n=e.swatch.clone(),g.colors[b]===f?(n.addClass(f).text("X"),a.fn.colorPicker.bindPalette(l,n,f)):(n.css("background-color","#"+this),a.fn.colorPicker.bindPalette(l,n)),n.appendTo(j)}),k.attr("for","colorPicker_hex-"+d),l.attr({id:"colorPicker_hex-"+d,value:h}),l.bind("keydown",function(b){if(b.keyCode===13){var d=a.fn.colorPicker.toHex(a(this).val());a.fn.colorPicker.changeColor(d?d:c.val())}b.keyCode===27&&a.fn.colorPicker.hidePalette()}),l.bind("keyup",function(b){var d=a.fn.colorPicker.toHex(a(b.target).val());a.fn.colorPicker.previewColor(d?d:c.val())}),a('<div class="colorPicker_hexWrap" />').append(k).appendTo(j),j.find(".colorPicker_hexWrap").append(l),a("body").append(j),j.hide(),i.css("background-color",h),i.bind("click",function(){a.fn.colorPicker.togglePalette(a("#"+m),a(this))}),b&&b.onColorChange?i.data("onColorChange",b.onColorChange):i.data("onColorChange",function(){}),c.after(i),c.bind("change",function(){c.next(".colorPicker-picker").css("background-color",a.fn.colorPicker.toHex(a(this).val()))}),c.val(h).hide(),d++})},a.extend(!0,a.fn.colorPicker,{toHex:function(a){if(a.match(/[0-9A-F]{6}|[0-9A-F]{3}$/i))return a.charAt(0)==="#"?a:"#"+a;if(!a.match(/^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/))return!1;var b=[parseInt(RegExp.$1,10),parseInt(RegExp.$2,10),parseInt(RegExp.$3,10)],c=function(a){if(a.length<2)for(var b=0,c=2-a.length;b<c;b++)a="0"+a;return a};if(b.length===3){var d=c(b[0].toString(16)),e=c(b[1].toString(16)),f=c(b[2].toString(16));return"#"+d+e+f}},checkMouse:function(d,e){var f=c,g=a(d.target).parents("#"+f.attr("id")).length;if(d.target===a(f)[0]||d.target===b[0]||g>0)return;a.fn.colorPicker.hidePalette()},hidePalette:function(){a(document).unbind("mousedown",a.fn.colorPicker.checkMouse),a(".colorPicker-palette").hide()},showPalette:function(c){var d=b.prev("input").val();c.css({top:b.offset().top+b.outerHeight(),left:b.offset().left}),a("#color_value").val(d),c.show(),a(document).bind("mousedown",a.fn.colorPicker.checkMouse)},togglePalette:function(d,e){e&&(b=e),c=d,c.is(":visible")?a.fn.colorPicker.hidePalette():a.fn.colorPicker.showPalette(d)},changeColor:function(c){b.css("background-color",c),b.prev("input").val(c).change(),a.fn.colorPicker.hidePalette(),b.data("onColorChange").call(b,a(b).prev("input").attr("id"),c)},previewColor:function(a){b.css("background-color",a)},bindPalette:function(c,d,e){e=e?e:a.fn.colorPicker.toHex(d.css("background-color")),d.bind({click:function(b){g=e,a.fn.colorPicker.changeColor(e)},mouseover:function(b){g=c.val(),a(this).css("border-color","#598FEF"),c.val(e),a.fn.colorPicker.previewColor(e)},mouseout:function(d){a(this).css("border-color","#000"),c.val(b.css("background-color")),c.val(g),a.fn.colorPicker.previewColor(g)}})}}),a.fn.colorPicker.defaults={pickerDefault:"FFFFFF",colors:["000000","993300","333300","000080","333399","333333","800000","FF6600","808000","008000","008080","0000FF","666699","808080","FF0000","FF9900","99CC00","339966","33CCCC","3366FF","800080","999999","FF00FF","FFCC00","FFFF00","00FF00","00FFFF","00CCFF","993366","C0C0C0","FF99CC","FFCC99","FFFF99","CCFFFF","99CCFF","FFFFFF"],addColors:[]}})(jQuery)
 \ No newline at end of file
@@ -0,0 +1,133 @@
+var processingTree = false;
+var metricName;
+jQuery(function (){
+  jQuery('.source-tree-link').live("click", reloadModule);
+  jQuery('[show-metric-history]').live("click", display_metric_history);
+  jQuery('[show-grade-history]').live("click", display_grade_history);
+  jQuery('#project_date_submit').live("click", reloadProcessingWithDate);
+  showLoadingProcess(true);
+  showProcessing();
+});
+
+function showProcessing() {
+  repository_id = processingData('repository-id');
+  callAction('processing', 'state', {repository_id: repository_id}, showProcessingFor);
+}
+
+function display_metric_history() {
+  var module_result_id = jQuery(this).attr('data-module-id');
+  var formatted_name = jQuery(this).attr('show-metric-history');
+  var metric_name = jQuery(this).attr('data-metric-name');
+  toggle_mezuro("." + formatted_name);
+  metricName = formatted_name;
+  callAction('module_result', 'metric_result_history', {metric_name: metric_name, module_result_id: module_result_id}, show_metrics);
+  return false;
+}
+
+function display_grade_history() {
+  var module_result_id = jQuery(this).attr('data-module-id');
+  toggle_mezuro("#historical-grade");
+  callAction('module_result', 'module_result_history', {module_result_id: module_result_id}, show_grades);
+  return false;
+}
+
+function show_metrics(content) {
+  jQuery('#historical-' + metricName).html(content);
+}
+
+function show_grades(content) {
+  jQuery('#historical-grade').html(content);
+}
+
+function toggle_mezuro(element){
+  jQuery(element).toggle();
+  return false;
+}
+
+function reloadModule(){
+  var module_result_id = jQuery(this).attr('data-module-id');
+  showLoadingProcess(false);
+  processingTree = true;
+  callAction('module_result', 'module_result', {module_result_id: module_result_id}, showModuleResult);
+  return false;
+}
+
+function reloadProcessingWithDate(date){
+	reloadProcessing(date + "T00:00:00+00:00");
+  return false;
+}
+
+function reloadProcessing(date){
+  repository_id = processingData('repository-id');
+  showLoadingProcess(true);
+
+  callAction('processing', 'processing', {date: date, repository_id: repository_id}, function(content){
+                                                                            showReadyProcessing(content);
+                                                                            var module_result_id = jQuery("#module_result_root_id").attr('module_result_root_id');
+                                                                            callAction('module_result', 'module_result', {module_result_id: module_result_id}, showModuleResult);
+                                                                         }
+            );
+}
+
+function showProcessingFor(state){
+  repository_id = processingData('repository-id');
+  if (state == 'ERROR') {
+    jQuery('#processing-state').html('<div style="color:Red">ERROR</div>');
+    callAction('processing', 'processing', {repository_id: repository_id}, showReadyProcessing);
+    showModuleResult('');
+  }
+  else if (state == 'READY') {
+    jQuery('#msg-time').html('');
+    jQuery('#processing-state').html('<div style="color:Green">READY</div>');
+    callAction('processing', 'processing', {repository_id: repository_id}, function(content){
+                                                                              showReadyProcessing(content);
+                                                                              var module_result_id = jQuery("#module_result_root_id").attr('module_result_root_id');
+                                                                              callAction('module_result', 'module_result', {module_result_id: module_result_id}, showModuleResult);
+                                                                           }
+              );
+  }
+  else if (state.endsWith("ING")) {
+    jQuery('#processing-state').html('<div style="color:DarkGoldenRod">'+ state +'</div>');
+    jQuery('#msg-time').html("The project analysis may take long. <br/> You'll receive an e-mail when it's ready!");
+    showProcessingAfter(20);
+  }
+}
+
+function showProcessingAfter(seconds){
+  if (seconds > 0){
+    setTimeout(function() { showProcessingAfter(seconds - 10);}, 10000);
+  } else {
+    showProcessing();
+  }
+}
+
+function showReadyProcessing(content) {
+  jQuery('#processing').html(content);
+}
+
+function showModuleResult(content){
+    jQuery('#module-result').html(content);
+}
+
+function callAction(controller, action, params, callback){
+  var profile = processingData('profile');
+  var content = processingData('content');
+  var endpoint = '/profile/' + profile + '/plugin/mezuro/' + controller + '/' + action + '/' + content;
+  jQuery.get(endpoint, params, callback);
+}
+
+function processingData(data){
+  return jQuery('#processing').attr('data-' + data);
+}
+
+function showLoadingProcess(firstLoad){
+	if(firstLoad)
+  	showReadyProcessing("<img src='/images/loading-small.gif'/>");
+  showModuleResult("<img src='/images/loading-small.gif'/>");
+}
+
+function sourceNodeToggle(id){
+  var suffixes = ['_hidden', '_plus', '_minus'];
+  for (var i in suffixes)
+    jQuery('#' + id + suffixes[i]).toggle();
+}
@@ -40,18 +40,15 @@ function IsNotInfinite(value){
 }
  
 function validate_new_range_configuration(event){    
-    var label = jQuery("#range_label").val();
     var beginning = jQuery("#range_beginning").val();
     var end = jQuery("#range_end").val();
-    var color = jQuery("#range_color").val();
-    var grade = jQuery("#range_grade").val();
  
-    if (is_null(label) || is_null(beginning) || is_null(end) || is_null(color) || is_null(grade))
+    if (is_null(beginning) || is_null(end))
     {
         alert("Please fill all fields marked with (*).");
         return false;
     }
-    if ( (IsNotNumeric(beginning) && IsNotInfinite(beginning)) || (IsNotNumeric(end) && IsNotInfinite(end)) || IsNotNumeric(grade))
+    if ( (IsNotNumeric(beginning) && IsNotInfinite(beginning)) || (IsNotNumeric(end) && IsNotInfinite(end)))
     {
         alert("Beginning, End and Grade must be numeric values.");
         return false;
-require File.dirname(__FILE__) + '/native_metric_fixtures'
+require File.dirname(__FILE__) + '/metric_fixtures'
  
 class BaseToolFixtures
  
@@ -6,10 +6,14 @@ class BaseToolFixtures
     Kalibro::BaseTool.new base_tool_hash
   end
  
-  def self.base_tool_hash
-    {:name => 'Analizo', :supported_metric => [
-        NativeMetricFixtures.total_cof_hash,
-        NativeMetricFixtures.amloc_hash]}
+  def self.base_tool_hash 
+  {
+    :name => 'Analizo', 
+    :supported_metric => [
+      MetricFixtures.total_cof_hash,
+      MetricFixtures.amloc_hash], 
+    :collector_class_name => "org.analizo.AnalizoMetricCollector"
+  }
   end
  
 end
@@ -1,11 +0,0 @@
-class CompoundMetricFixtures
-
-  def self.compound_metric
-    Kalibro::CompoundMetric.new compound_metric_hash
-  end
-
-  def self.compound_metric_hash
-    {:name => 'Structural Complexity', :scope => 'CLASS', :script => 'return 42;', :description => 'Calculate the Structural Complexity of the Code'}
-  end
-
-end
@@ -1,20 +0,0 @@
-require File.dirname(__FILE__) + '/error_fixtures'
-require File.dirname(__FILE__) + '/compound_metric_fixtures'
-
-class CompoundMetricWithErrorFixtures
-    
-  def self.compound_metric_with_error
-    Kalibro::CompoundMetricWithError.new compound_metric_with_error_hash
-  end
-
-  def self.compound_metric_with_error_hash
-    {:metric => CompoundMetricFixtures.compound_metric_hash, :error => ErrorFixtures.error_hash,
-      :attributes! => {:metric => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:compoundMetricXml'  },
-          :error => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:errorXml'  }}}
-  end
-
-end
@@ -0,0 +1,23 @@
+class ConfigurationContentFixtures
+
+  def self.configuration_content
+    MezuroPlugin::ConfigurationContent.new configuration_content_hash
+  end
+  
+  def self.created_configuration_content
+    MezuroPlugin::ConfigurationContent.new( {
+      :name => 'Sample Configuration',
+      :description => 'Kalibro configuration for Java projects.',
+      :configuration_id => nil
+    } )
+  end
+
+  def self.configuration_content_hash
+    {
+      :name => 'Sample Configuration',
+      :description => 'Kalibro configuration for Java projects.',
+      :configuration_id => "42"
+    }
+  end
+
+end
@@ -6,23 +6,23 @@ class ConfigurationFixtures
     Kalibro::Configuration.new configuration_hash
   end
  
+  def self.created_configuration
+    Kalibro::Configuration.new({
+      :name => 'Created Sample Configuration',
+      :description => 'Kalibro configuration for Java projects.'
+    })
+  end
+
   def self.configuration_hash
     {
+      :id => "42",
       :name => 'Sample Configuration',
-      :description => 'Kalibro configuration for Java projects.',
-      :metric_configuration => [
-        MetricConfigurationFixtures.amloc_metric_configuration_hash,
-        MetricConfigurationFixtures.sc_metric_configuration_hash
-      ]
+      :description => 'Kalibro configuration for Java projects.'
     }
   end
  
-  def self.configuration_content(clone_configuration)
-    MezuroPlugin::ConfigurationContent.new({
-      :name => 'Sample Configuration',
-      :description => 'Kalibro configuration for Java projects.',
-      :configuration_to_clone_name => clone_configuration
-    })
+  def self.all
+    [configuration]
   end
  
 end
@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/metric_result_fixtures'
+
+class DateMetricResultFixtures
+
+  def self.date_metric_result
+    Kalibro::DateMetricResult.new date_metric_result_hash
+  end
+
+  def self.date_metric_result_hash
+    {
+      :date => '2011-10-20T18:26:43.151+00:00',
+      :metric_result => MetricResultFixtures.native_metric_result_hash,
+      :attributes! =>
+      {
+        :metric_result =>
+        {
+          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+          "xsi:type"=>"kalibro:metricResultXml"
+        }
+      }
+    }
+  end
+
+  def self.score_history
+    result = []
+    result << date_metric_result
+    newer_date_metric_result = date_metric_result
+    newer_date_metric_result.date = '2011-10-25T18:26:43.151+00:00'
+    newer_date_metric_result.metric_result.value = 5.0
+    result << newer_date_metric_result    
+  end
+
+end
@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/module_result_fixtures'
+
+class DateModuleResultFixtures
+
+  def self.date_module_result
+    Kalibro::DateModuleResult.new date_module_result_hash
+  end
+
+  def self.date_module_result_hash
+    {
+      :date => '2011-10-20T18:26:43.151+00:00',
+      :module_result => ModuleResultFixtures.module_result_hash,
+      :attributes! =>
+      {
+        :module_result =>
+        {
+          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+          "xsi:type"=>"kalibro:moduleResultXml"
+        }
+      }
+    }
+  end
+
+end
@@ -1,20 +0,0 @@
-require File.dirname(__FILE__) + '/stack_trace_element_fixtures'
-
-class ErrorFixtures
-
-  def self.error
-    Kalibro::Error.new error_hash
-  end
-
-  def self.error_hash
-    {
-      :error_class => 'java.lang.Exception',
-      :message => 'Error message from ErrorTest',
-      :stack_trace_element => [
-        StackTraceElementFixtures.stack_trace_element_hash('my method 1', 42),
-        StackTraceElementFixtures.stack_trace_element_hash('my method 2', 84)
-      ]
-    }
-  end
-    
-end
-require File.dirname(__FILE__) + '/compound_metric_fixtures'
-require File.dirname(__FILE__) + '/native_metric_fixtures'
-require File.dirname(__FILE__) + '/range_fixtures'
+require File.dirname(__FILE__) + '/metric_fixtures'
  
 class MetricConfigurationFixtures
  
   def self.amloc_metric_configuration
     amloc = Kalibro::MetricConfiguration.new amloc_metric_configuration_hash
-    amloc.configuration_name = "Sample Configuration"
-    amloc
-  end
-
-  def self.metric_configuration_without_ranges
-    amloc = Kalibro::MetricConfiguration.new 
-      {
-        :metric => NativeMetricFixtures.amloc_hash,
-        :code => 'amloc',
-        :weight => 1.0,
-        :aggregation_form => 'AVERAGE'
-      }
-    amloc.configuration_name = "Sample Configuration"
+    amloc.configuration_id = "13"
     amloc
   end
  
   def self.sc_metric_configuration
     sc = Kalibro::MetricConfiguration.new sc_metric_configuration_hash
-    sc.configuration_name = "Sample Configuration"
+    sc.configuration_id = "13"
     sc
   end
+  
+  def self.created_metric_configuration
+    Kalibro::MetricConfiguration.new({
+        :code => 'amloc',
+        :metric => MetricFixtures.amloc_hash,
+        :base_tool_name => "Analizo",
+        :weight => "1.0",
+        :aggregation_form => 'AVERAGE',
+        :reading_group_id => "31",
+        :configuration_id => "13"
+      })
+  end
  
   def self.amloc_metric_configuration_hash
-    {:metric => NativeMetricFixtures.amloc_hash, :code => 'amloc', :weight => 1.0,
+    {
+      :id => "42",
+      :code => 'amloc',
+      :metric => MetricFixtures.amloc_hash,
+      :base_tool_name => "Analizo",
+      :weight => "1.0",
       :aggregation_form => 'AVERAGE',
-      :range => [RangeFixtures.range_excellent_hash, RangeFixtures.range_bad_hash],
+      :reading_group_id => "31",
       :attributes! => {:metric => {
           'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:nativeMetricXml'  }}}
+          'xsi:type' => 'kalibro:metricXml'  }}
+    }
   end
  
   def self.sc_metric_configuration_hash
-    {:metric => CompoundMetricFixtures.compound_metric_hash, :code => 'sc', :weight => 1.0, :aggregation_form => 'AVERAGE',
+    {
+      :id => "42",
+      :code => 'sc',
+      :metric => MetricFixtures.compound_metric_hash,
+      :weight => "1.0",
+      :aggregation_form => 'AVERAGE',
+      :reading_group_id => "31",
       :attributes! => {:metric => {
           'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:compoundMetricXml'  }}}
+          'xsi:type' => 'kalibro:metricXml'  }}
+    }
   end
  
 end
@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/metric_fixtures'
+require File.dirname(__FILE__) + '/range_snapshot_fixtures'
+
+class MetricConfigurationSnapshotFixtures
+
+  def self.metric_configuration_snapshot
+    Kalibro::MetricConfigurationSnapshot.new metric_configuration_snapshot_hash
+  end
+
+  def self.metric_configuration_snapshot_hash
+    {
+      :code => "code",
+      :weight => "1.0",
+      :aggregation_form => 'AVERAGE',
+      :metric => MetricFixtures.amloc_hash,
+      :base_tool_name => "Analizo",
+      :range => [RangeSnapshotFixtures.range_snapshot_hash],
+      :attributes! => {
+        :metric => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:metricXml'  },
+        :range => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:rangeSnapshotXml'  }
+      }
+    }
+  end
+
+  def self.metric_configuration_snapshot_with_2_elements
+    Kalibro::MetricConfigurationSnapshot.new  metric_configuration_snapshot_hash_with_2_elements
+  end
+
+  def self.metric_configuration_snapshot_hash_with_2_elements
+    hash = self.metric_configuration_snapshot_hash
+    hash[:range] << RangeSnapshotFixtures.range_snapshot_hash
+    hash
+  end
+
+  def self.compound_metric_configuration_snapshot
+    Kalibro::MetricConfigurationSnapshot.new compound_metric_configuration_snapshot_hash
+  end
+
+  def self.compound_metric_configuration_snapshot_hash
+    {
+      :code => "code",
+      :weight => "1.0",
+      :aggregation_form => 'AVERAGE',
+      :metric => MetricFixtures.compound_metric,
+      :base_tool_name => "Analizo",
+      :range => [RangeSnapshotFixtures.range_snapshot_hash],
+      :attributes! => {
+        :metric => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:metricXml'  },
+        :range => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:rangeSnapshotXml'  }
+      }
+    }
+  end
+
+end
@@ -0,0 +1,27 @@
+class MetricFixtures
+
+  def self.compound_metric
+    Kalibro::Metric.new compound_metric_hash
+  end
+
+  def self.compound_metric_hash
+    {:name => 'Structural Complexity', :compound => "true", :scope => 'CLASS', :script => 'return 42;', :description => 'Calculate the Structural Complexity of the Code'}
+  end
+
+  def self.total_cof
+    Kalibro::Metric.new total_cof_hash
+  end
+
+  def self.total_cof_hash
+    {:name => 'Total Coupling Factor', :compound => "false", :scope => 'APPLICATION', :language => ['JAVA']}
+  end
+
+  def self.amloc
+    Kalibro::Metric.new amloc_hash
+  end
+
+  def self.amloc_hash
+    {:name => 'Average Method LOC', :compound => "false", :scope => 'CLASS', :language => ['JAVA']}
+  end
+
+end
-require File.dirname(__FILE__) + '/compound_metric_fixtures'
-require File.dirname(__FILE__) + '/native_metric_fixtures'
-require File.dirname(__FILE__) + '/range_fixtures'
+require File.dirname(__FILE__) + '/metric_configuration_snapshot_fixtures'
+require File.dirname(__FILE__) + '/throwable_fixtures'
  
 class MetricResultFixtures
  
@@ -12,32 +11,42 @@ class MetricResultFixtures
     Kalibro::MetricResult.new compound_metric_result_hash
   end
  
+  def self.metric_result_with_error_hash
+    {
+      :id => "41",
+      :configuration => MetricConfigurationSnapshotFixtures.metric_configuration_snapshot_hash,
+      :error => ThrowableFixtures.throwable_hash
+    }
+  end
+
   def self.native_metric_result_hash
     {
-      :metric => NativeMetricFixtures.amloc_hash,
-      :value => 0.0,
-      :descendent_result => [40.0, 42.0],
-      :range => RangeFixtures.range_excellent_hash,
-      :attributes! => {
-        :metric => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:nativeMetricXml'  },
-        :range => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:rangeXml'  }
+      :id => "42",
+      :configuration => MetricConfigurationSnapshotFixtures.metric_configuration_snapshot_hash,
+      :value => "0.0",
+      :attributes! =>
+      {
+        :configuration =>
+        {
+          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+          "xsi:type"=>"kalibro:metricConfigurationSnapshotXml"
+        }
       }
     }
   end
  
   def self.compound_metric_result_hash
     {
-      :metric => CompoundMetricFixtures.compound_metric_hash,
-      :value => 1.0,
-      :descendent_result => [2.0, 42.0],
-      :attributes! => {
-        :metric => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:compoundMetricXml'  }
+      :id => "43",
+      :configuration => MetricConfigurationSnapshotFixtures.compound_metric_configuration_snapshot_hash,
+      :value => "1.0",
+      :attributes! =>
+      {
+        :configuration =>
+        {
+          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+          "xsi:type"=>"kalibro:metricConfigurationSnapshotXml"
+        }
       }
     }
   end
@@ -1,47 +0,0 @@
-require File.dirname(__FILE__) + '/module_fixtures'
-
-class ModuleNodeFixtures
-
-  def self.module_node
-    Kalibro::ModuleNode.new module_node_hash
-  end
-
-  def self.module_node_hash
-    {
-      :module => ModuleFixtures.module_hash,:attributes! => {:module => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:moduleXml'  }},
-      :child => [{
-        :module => {
-          :name => 'org',
-          :granularity => 'PACKAGE'
-        },:attributes! => {:module => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:moduleXml'  }},
-        :child => [{
-          :module => {
-            :name => 'org.Window',
-            :granularity => 'CLASS'
-          },:attributes! => {:module => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:moduleXml'  }}
-        }]
-      },{
-        :module => {
-          :name => 'Dialog',
-          :granularity => 'CLASS'
-        },:attributes! => {:module => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:moduleXml'  }}
-      },{
-        :module => {
-          :name => 'main',
-          :granularity => 'CLASS'
-        },:attributes! => {:module => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:moduleXml'  }}
-      }]
-    }
-  end
-
-end
 require File.dirname(__FILE__) + '/module_fixtures'
-require File.dirname(__FILE__) + '/metric_result_fixtures'
-require File.dirname(__FILE__) + '/compound_metric_with_error_fixtures'
  
 class ModuleResultFixtures
  
@@ -10,19 +8,37 @@ class ModuleResultFixtures
  
   def self.module_result_hash
     {
+      :id => "42",
       :module => ModuleFixtures.module_hash,
-      :date => '2011-10-20T18:26:43.151+00:00',
-      :grade => 10.0,
-      :metric_result => [
-        MetricResultFixtures.native_metric_result_hash,
-        MetricResultFixtures.compound_metric_result_hash],
-      :compound_metric_with_error => [CompoundMetricWithErrorFixtures.compound_metric_with_error_hash],
-      :attributes! => {
-        :module => {
-          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:type' => 'kalibro:moduleXml'  }
+      :grade => "10.0",
+      :parent_id => "31",
+      :attributes! =>
+      {
+        :module =>
+        {
+          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+          "xsi:type"=>"kalibro:moduleXml"
+        }
       }
     }
   end
  
+  def self.parent_module_result_hash
+    {
+      :id => "31",
+      :module =>  {
+        :name => 'Qt-Calculator Parent',
+        :granularity => 'APPLICATION'
+      },
+      :grade => "10.0",
+      :attributes! =>
+      {
+        :module =>
+        {
+          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+          "xsi:type"=>"kalibro:moduleXml"
+        }
+      }
+    }
+  end
 end
@@ -1,19 +0,0 @@
-class NativeMetricFixtures
-
-  def self.total_cof
-    Kalibro::NativeMetric.new total_cof_hash
-  end
-
-  def self.total_cof_hash
-    {:name => 'Total Coupling Factor', :scope => 'APPLICATION', :origin => 'Analizo', :language => ['JAVA']}
-  end
-
-  def self.amloc
-    Kalibro::NativeMetric.new amloc_hash
-  end
-
-  def self.amloc_hash
-    {:name => 'Average Method LOC', :scope => 'CLASS', :origin => 'Analizo', :language => ['JAVA']}
-  end
-
-end
@@ -0,0 +1,11 @@
+class ProcessTimeFixtures
+
+  def self.process_time
+    Kalibro::ProcessTime.new process_time_hash
+  end
+
+  def self.process_time_hash
+    {:state => "Ready", :time => "1"}
+  end
+
+end
@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/process_time_fixtures'
+require File.dirname(__FILE__) + '/throwable_fixtures'
+
+class ProcessingFixtures
+
+  def self.processing
+    Kalibro::Processing.new processing_hash  
+  end
+ 
+  def self.processing_hash
+    {
+      :id => "31",
+      :date => '2011-10-20T18:26:43.151+00:00',
+      :state => 'READY',
+      :process_time => [ProcessTimeFixtures.process_time_hash],
+      :results_root_id => "13"
+    }
+  end
+
+  def self.processing_with_error_hash
+    {
+      :id => "31",
+      :date => '2011-10-20T18:26:43.151+00:00',
+      :state => 'ERROR',
+      :process_time => [ProcessTimeFixtures.process_time_hash],
+      :error => ThrowableFixtures.throwable_hash
+    }
+  end
+
+end
@@ -0,0 +1,9 @@
+class ProjectContentFixtures
+
+  def self.project_content
+    content = MezuroPlugin::ProjectContent.new
+    content.project_id = 42
+    content
+  end
+
+end
@@ -6,35 +6,15 @@ class ProjectFixtures
     Kalibro::Project.new project_hash
   end
  
+  def self.created_project
+    Kalibro::Project.new :name => 'Qt-Calculator', :description => 'Calculator for Qt'
+  end
+
   def self.project_hash
     {
+      :id => "42",
       :name => 'Qt-Calculator',
-      :license => 'GPL',
-      :description => 'Calculator for Qt',
-      :repository => RepositoryFixtures.repository_hash,
-      :configuration_name => 'Kalibro for Java',
-      :state => 'READY',
-      :attributes! =>
-      {
-        :repository=>
-        {
-          "xsi:type"=>"kalibro:repositoryXml",
-          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance"
-        }
-      }
+      :description => 'Calculator for Qt'
     }
   end
-    
-  def self.project_content
-    content = MezuroPlugin::ProjectContent.new
-    content.name = 'Qt-Calculator'
-    content.project_license = 'GPL'
-    content.description = 'Calculator for Qt'
-    content.repository_type = RepositoryFixtures.repository_hash[:type]
-    content.repository_url = RepositoryFixtures.repository_hash[:address]
-    content.configuration_name = 'Kalibro for Java'
-    content.periodicity_in_days = 1
-    content
-  end
-
 end
@@ -1,35 +0,0 @@
-require File.dirname(__FILE__) + '/project_fixtures'
-require File.dirname(__FILE__) + '/module_node_fixtures'
-require File.dirname(__FILE__) + '/module_result_fixtures'
-
-class ProjectResultFixtures
-
-  def self.project_result
-    Kalibro::ProjectResult.new project_result_hash  
-  end
-
-  def self.project_result_hash
-    {
-      :project => ProjectFixtures.project_hash,
-      :date => ModuleResultFixtures.module_result_hash[:date],
-      :load_time => 14878,
-      :analysis_time => 1022,
-      :source_tree => ModuleNodeFixtures.module_node_hash, 
-      :collect_time => 14878,
-      :attributes! =>
-      {
-        :source_tree =>
-        {
-          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
-          "xsi:type"=>"kalibro:moduleNodeXml"
-        },
-        :project =>
-        {
-          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
-          "xsi:type"=>"kalibro:projectXml"
-        }
-      }
-    }
-  end
-    
-end
 class RangeFixtures
  
-  Infinity = 1.0/0.0
-
-  def self.range_excellent
-    Kalibro::Range.new range_excellent_hash
+  def self.range
+    Kalibro::Range.new range_hash
   end
  
-  def self.range_bad
-    Kalibro::Range.new range_bad_hash
+  def self.created_range
+    Kalibro::Range.new created_range_hash
   end
-
-  def self.range_excellent_hash
-    {:beginning => 0.0, :end => 7.0, :label => 'Excellent', :grade => 10.0, :color => 'ff00ff00'}
+  
+  def self.created_range_hash
+    {:beginning => "19.5", :end => "INF", :reading_id => "1", :comments => "Test range 1"}
   end
  
-  def self.range_bad_hash
-    {:beginning => 19.5, :end => "INF", :label => 'Bad',:grade => 0.0, :color => 'ffff0000'}
+  def self.range_hash
+    {:id => "1", :beginning => "19.5", :end => "INF", :reading_id => "1", :comments => "Test range 1"}
   end
  
 end
@@ -0,0 +1,19 @@
+class RangeSnapshotFixtures
+
+  def self.range_snapshot
+    Kalibro::RangeSnapshot.new range_snapshot_hash
+  end
+
+  def self.range_snapshot_with_infinite_range
+    Kalibro::RangeSnapshot.new range_snapshot_with_infinite_range_hash
+  end
+
+  def self.range_snapshot_hash
+    { :beginning => "1.1", :end => "5.1", :label => "snapshot", :grade => "10.1", :color => "FF2284", :comments => "comment" }
+	end
+
+  def self.range_snapshot_with_infinite_range_hash
+    { :beginning => "-INF", :end => "INF", :label => "snapshot", :grade => "10.1", :color => "FF2284", :comments => "comment" }
+  end
+
+end
@@ -0,0 +1,16 @@
+class ReadingFixtures
+
+  def self.reading
+    Kalibro::Reading.new reading_hash
+  end
+  
+  def self.created_reading # A created object has no id before being sent to kalibro
+    Kalibro::Reading.new :label => "Reading Test Label", :grade => "10.5", :color => "AABBCC"
+  end
+
+  def self.reading_hash
+    {:id => "42", :label => "Reading Test Label", :grade => "10.5", :color => "AABBCC" }
+  end
+
+end
+
@@ -0,0 +1,9 @@
+class ReadingGroupContentFixtures
+
+  def self.reading_group_content
+    content = MezuroPlugin::ReadingGroupContent.new
+    content.reading_group_id = 42
+    content
+  end
+
+end
@@ -0,0 +1,15 @@
+class ReadingGroupFixtures
+
+  def self.reading_group
+    Kalibro::ReadingGroup.new reading_group_hash
+  end
+
+  def self.created_reading_group  # A created object has no id before being sent to kalibro
+    Kalibro::ReadingGroup.new :name => "Reading Group Test", :description => "Reading group in the fixtures"
+  end
+
+  def self.reading_group_hash
+    {:id => "42", :name => "Reading Group Test", :description => "Reading group in the fixtures"}
+  end
+
+end
@@ -4,8 +4,24 @@ class RepositoryFixtures
     Kalibro::Repository.new repository_hash
   end
  
+  def self.created_repository
+    Kalibro::Repository.new({
+      :name => "test created repository",
+      :description => "test description",
+      :license => "GPL",
+      :process_period => "1",
+      :type => 'SUBVERSION',
+      :address => 'https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator',
+      :configuration_id => "31"
+    })
+  end
+
   def self.repository_hash
-    {:type => 'SUBVERSION', :address => 'https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator'}
+    {:id => "42", :name => "test repository", :description => "test description", :license => "GPL", :process_period => "1", :type => 'SUBVERSION', :address => "https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator", :configuration_id => "31"}
+  end
+
+  def self.types
+    ["SUBVERSION", "GIT"]
   end
  
 end
 class StackTraceElementFixtures
  
-  def self.stack_trace_element(method_name = 'my method name', line_number = 42)
-    Kalibro::StackTraceElement.new stack_trace_element_hash(method_name, line_number)
+  def self.stack_trace_element
+    Kalibro::StackTraceElement.new stack_trace_element_hash
   end
  
-  def self.stack_trace_element_hash(method_name = 'my method name', line_number = 42)
+  def self.stack_trace_element_hash
     {
       :declaring_class => 'my.declaring.Class',
-      :method_name => method_name,
+      :method_name => 'my method name',
       :file_name => 'MyFile.java',
-      :line_number => line_number
+      :line_number => '42'
     }
   end
  
@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/stack_trace_element_fixtures'
+
+class ThrowableFixtures
+
+  def self.throwable
+    Kalibro::Throwable.new throwable_hash
+  end
+
+  def self.throwable_hash
+    {
+      :target_string => 'Target String',
+      :message => 'Throwable message from ThrowableTest',
+      :stack_trace_element => [
+        StackTraceElementFixtures.stack_trace_element_hash, StackTraceElementFixtures.stack_trace_element_hash
+      ]
+    }
+  end
+    
+end
@@ -1,56 +0,0 @@
-require 'test_helper'
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/error_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/native_metric_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
-
-class MezuroPluginMyprofileControllerTest < ActionController::TestCase
-
-  def setup
-    @controller = MezuroPluginMyprofileController.new
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @profile = fast_create(Community)
-
-    @base_tool = BaseToolFixtures.base_tool
-    @base_tool_hash = BaseToolFixtures.base_tool_hash
-    @metric = NativeMetricFixtures.amloc
-    @metric_configuration = MetricConfigurationFixtures.amloc_metric_configuration
-    @metric_configuration_hash = MetricConfigurationFixtures.amloc_metric_configuration_hash
-    @compound_metric_configuration = MetricConfigurationFixtures.sc_metric_configuration
-    @compound_metric_configuration_hash = MetricConfigurationFixtures.sc_metric_configuration_hash
-    @configuration = ConfigurationFixtures.configuration
-    @configuration_hash = ConfigurationFixtures.configuration_hash
-
-    Kalibro::Configuration.expects(:all_names).returns([])
-    @content = MezuroPlugin::ConfigurationContent.new(:profile => @profile, :name => @configuration.name)
-    @content.expects(:send_kalibro_configuration_to_service).returns(nil)
-    @content.stubs(:solr_save)
-    @content.save
-
-    @native_hash = @metric_configuration.to_hash.merge({:configuration_name => @metric_configuration.configuration_name})
-    @native_hash.delete :attributes!    
-    @compound_hash = @compound_metric_configuration.to_hash.merge({:configuration_name => @compound_metric_configuration.configuration_name})
-    @compound_hash.delete :attributes!
-  end
-
-  should 'test choose base tool' do
-    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool_names).returns({:base_tool_name => @base_tool.name})
-    get :choose_base_tool, :profile => @profile.identifier, :id => @content.id
-    assert_equal [@base_tool.name], assigns(:base_tools)
-    assert_equal @content, assigns(:configuration_content)
-    assert_response 200
-  end
-
-  should 'test choose metric' do
-    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool, {:base_tool_name => @base_tool.name}).returns({:base_tool => @base_tool_hash})
-    get :choose_metric, :profile => @profile.identifier, :id => @content.id, :base_tool => @base_tool.name
-    assert_equal @content, assigns(:configuration_content)
-    assert_equal @base_tool.name, assigns(:base_tool)
-    assert_equal @base_tool.supported_metric[0].name, assigns(:supported_metrics)[0].name
-    assert_response 200
-  end
-
-end
@@ -1,34 +0,0 @@
-require 'test_helper'
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
-
-class MezuroPluginBaseToolControllerTest < ActionController::TestCase
-
-  def setup
-    @controller = MezuroPluginBaseToolController.new
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @profile = fast_create(Community)
-
-    @base_tool = BaseToolFixtures.base_tool
-    @base_tool_hash = BaseToolFixtures.base_tool_hash
-    @configuration = ConfigurationFixtures.configuration
-
-    Kalibro::Configuration.expects(:all_names).returns([])
-    @content = MezuroPlugin::ConfigurationContent.new(:profile => @profile, :name => @configuration.name)
-    @content.expects(:send_kalibro_configuration_to_service).returns(nil)
-    @content.stubs(:solr_save)
-    @content.save
-  end
-
-  should 'test choose metric' do
-    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool_names).returns({:base_tool_name => @base_tool.name})
-    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool, {:base_tool_name => @base_tool.name}).returns({:base_tool => @base_tool_hash})
-    get :choose_metric, :profile => @profile.identifier, :id => @content.id
-    assert_equal @base_tool.name, assigns(:base_tools).first.name
-    assert_equal @content, assigns(:configuration_content)
-    assert_response 200
-  end
-
-end
 require 'test_helper'
  
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/native_metric_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_fixtures"
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_group_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_fixtures"
  
 class MezuroPluginMetricConfigurationControllerTest < ActionController::TestCase
  
@@ -11,131 +14,111 @@ class MezuroPluginMetricConfigurationControllerTest &lt; ActionController::TestCase
     @controller = MezuroPluginMetricConfigurationController.new
     @request = ActionController::TestRequest.new
     @response = ActionController::TestResponse.new
-    @profile = fast_create(Community)
+    @profile = fast_create(Profile)
+
+    @configuration = ConfigurationFixtures.configuration
+    @created_configuration = ConfigurationFixtures.created_configuration
+    @configuration_hash = ConfigurationFixtures.configuration_hash
+
+    @configuration_content = MezuroPlugin::ConfigurationContent.new(:profile => @profile, :name => @configuration.name, :configuration_id => 42)
+    @configuration_content.expects(:send_configuration_to_service).returns(nil)
+    @configuration_content.expects(:validate_configuration_name).returns(true)
+    @configuration_content.stubs(:solr_save)
+    @configuration_content.save
  
     @base_tool = BaseToolFixtures.base_tool
     @base_tool_hash = BaseToolFixtures.base_tool_hash
-    @metric = NativeMetricFixtures.amloc
-    @metric_configuration = MetricConfigurationFixtures.amloc_metric_configuration
-    @metric_configuration_hash = MetricConfigurationFixtures.amloc_metric_configuration_hash
+
+    @metric = MetricFixtures.amloc
+
+    @reading_group = ReadingGroupFixtures.reading_group
+    @range = RangeFixtures.range
+    @reading = ReadingFixtures.reading
+
+    @native_metric_configuration = MetricConfigurationFixtures.amloc_metric_configuration
+    @native_metric_configuration_hash = MetricConfigurationFixtures.amloc_metric_configuration_hash
+    @created_metric_configuration = MetricConfigurationFixtures.created_metric_configuration
     @compound_metric_configuration = MetricConfigurationFixtures.sc_metric_configuration
     @compound_metric_configuration_hash = MetricConfigurationFixtures.sc_metric_configuration_hash
-    @configuration = ConfigurationFixtures.configuration
-    @configuration_hash = ConfigurationFixtures.configuration_hash
+  end
  
-    Kalibro::Configuration.expects(:all_names).returns([])
-    @content = MezuroPlugin::ConfigurationContent.new(:profile => @profile, :name => @configuration.name)
-    @content.expects(:send_kalibro_configuration_to_service).returns(nil)
-    @content.stubs(:solr_save)
-    @content.save
-
-    @native_hash = @metric_configuration.to_hash.merge({:configuration_name => @metric_configuration.configuration_name})
-    @native_hash.delete :attributes!    
-    @compound_hash = @compound_metric_configuration.to_hash.merge({:configuration_name => @compound_metric_configuration.configuration_name})
-    @compound_hash.delete :attributes!
-    
+  should 'choose metric' do
+    Kalibro::BaseTool.expects(:all).returns([@base_tool])
+    get :choose_metric, :profile => @profile.identifier, :id => @configuration_content.id
+    assert_equal @configuration_content, assigns(:configuration_content)
+    assert_equal [@base_tool], assigns(:base_tools)
+    assert_response :success
   end
-  
-  should 'test new metric configuration' do
-    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool, {:base_tool_name => @base_tool.name}).returns({:base_tool => @base_tool_hash})
-    get :new_metric_configuration, :profile => @profile.identifier, :id => @content.id, :base_tool => @base_tool.name, :metric_name => @metric.name
-    assert_equal @content, assigns(:configuration_content)
+
+  should 'initialize native' do
+    Kalibro::BaseTool.expects(:find_by_name).with(@base_tool.name).returns(@base_tool)
+    Kalibro::ReadingGroup.expects(:all).returns([@reading_group])
+    get :new_native, :profile => @profile.identifier, :id => @configuration_content.id, :base_tool_name => @base_tool.name, :metric_name => @metric.name
+    assert_equal @configuration_content, assigns(:configuration_content)
     assert_equal @metric.name, assigns(:metric).name
-    assert_response 200
+    assert_equal @base_tool.name, assigns(:metric_configuration).base_tool_name
+    assert_equal [[@reading_group.name,@reading_group.id]], assigns(:reading_group_names_and_ids)
+    assert_response :success
   end
-  
-  
-  should 'test new compound metric configuration' do
-    Kalibro::Configuration.expects(:request).with("Configuration", :get_configuration, {
-      :configuration_name => @content.name}).returns({:configuration => @configuration_hash})
-    get :new_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id
-    assert_equal @content, assigns(:configuration_content)
-    assert_equal @configuration.metric_configuration[0].code, assigns(:metric_configurations)[0].code
-    assert_response 200
+
+  should 'edit native' do
+    Kalibro::MetricConfiguration.expects(:metric_configurations_of).with(@configuration.id).returns([@native_metric_configuration])
+    Kalibro::ReadingGroup.expects(:all).returns([@reading_group])
+    Kalibro::Range.expects(:ranges_of).with(@native_metric_configuration.id).returns([@range])
+    Kalibro::Reading.expects(:find).with(@range.reading_id).returns(@reading)    
+    get :edit_native, :profile => @profile.identifier, :id => @configuration_content.id, :metric_configuration_id => @native_metric_configuration.id
+    assert_equal @configuration_content, assigns(:configuration_content)
+    assert_equal @native_metric_configuration.code, assigns(:metric_configuration).code
+    assert_equal @native_metric_configuration.metric.name, assigns(:metric).name
+    assert_equal [[@reading_group.name,@reading_group.id]], assigns(:reading_group_names_and_ids)
+    assert_equal [@range], assigns(:ranges)
+    assert_response :success
   end
  
-  should 'test edit metric configuration' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @metric_configuration.metric.name}).returns({:metric_configuration => @metric_configuration_hash})
-    get :edit_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
-    assert_equal @content, assigns(:configuration_content)
-    assert_equal @metric_configuration.code, assigns(:metric_configuration).code
-    assert_equal @metric_configuration.metric.name, assigns(:metric).name
-    assert_response 200
+  should 'initialize compound' do
+    Kalibro::ReadingGroup.expects(:all).returns([@reading_group])
+    Kalibro::MetricConfiguration.expects(:metric_configurations_of).with(@configuration_content.configuration_id).returns([@compound_metric_configuration])
+    get :new_compound, :profile => @profile.identifier, :id => @configuration_content.id
+    assert_equal @configuration_content, assigns(:configuration_content)
+    assert_equal @compound_metric_configuration.code, assigns(:metric_configurations).first.code
+    assert_equal [[@reading_group.name,@reading_group.id]], assigns(:reading_group_names_and_ids)
+    assert_response :success
   end
-  
-  should 'test edit compound metric configuration' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @compound_metric_configuration.metric.name}).returns({:metric_configuration => @compound_metric_configuration_hash})
-    Kalibro::Configuration.expects(:request).with("Configuration", :get_configuration, {:configuration_name => @content.name}).returns({:configuration => @configuration_hash})
-    get :edit_compound_metric_configuration,
-        :profile => @profile.identifier,
-        :id => @content.id,
-        :metric_name => @compound_metric_configuration.metric.name
-    assert_equal @content, assigns(:configuration_content)
+
+  should 'edit compound' do
+    Kalibro::MetricConfiguration.expects(:metric_configurations_of).with(@configuration.id).returns([@compound_metric_configuration])
+    Kalibro::ReadingGroup.expects(:all).returns([@reading_group])
+    Kalibro::Range.expects(:ranges_of).with(@compound_metric_configuration.id).returns([@range])
+    Kalibro::Reading.expects(:find).with(@range.reading_id).returns(@reading)    
+    get :edit_compound, :profile => @profile.identifier, :id => @configuration_content.id, :metric_configuration_id => @compound_metric_configuration.id
+    assert_equal @configuration_content, assigns(:configuration_content)
     assert_equal @compound_metric_configuration.code, assigns(:metric_configuration).code
     assert_equal @compound_metric_configuration.metric.name, assigns(:metric).name
-    assert_equal @configuration.metric_configuration[0].code, assigns(:metric_configurations)[0].code
-    assert_response 200
-  end
-  
-  should 'test create native metric configuration' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, {
-        :metric_configuration => @metric_configuration.to_hash,
-        :configuration_name => @metric_configuration.configuration_name})
-    get :create_metric_configuration,
-        :profile => @profile.identifier,
-        :id => @content.id,
-        :metric_configuration => @native_hash
-    assert_response 302
-  end
-  
-  should 'test compound metric creation' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, {
-      :metric_configuration => @compound_metric_configuration.to_hash,
-      :configuration_name => @compound_metric_configuration.configuration_name})
-    get :create_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id, 
-      :metric_configuration => @compound_hash
-    assert_response 302
+    assert_equal [@compound_metric_configuration], assigns(:metric_configurations)
+    assert_equal [[@reading_group.name,@reading_group.id]], assigns(:reading_group_names_and_ids)
+    assert_equal [@range], assigns(:ranges)
+    assert_response :success
   end
  
-  should 'test update native metric configuration' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @metric_configuration.metric.name}).returns({:metric_configuration => @metric_configuration_hash})
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, {
-        :metric_configuration => @metric_configuration.to_hash,
-        :configuration_name => @metric_configuration.configuration_name})
-    get :update_metric_configuration, :profile => @profile.identifier, :id => @content.id, 
-      :metric_configuration => @native_hash
-    assert_equal @content, assigns(:configuration_content)
-    assert_response 302
+  should 'create' do
+    Kalibro::MetricConfiguration.expects(:create).returns(@compound_metric_configuration) #FIXME need .with(some_hash), should it mock the request?.
+    get :create, :profile => @profile.identifier, :id => @configuration_content.id, :metric_configuration => @compound_metric_configuration_hash
+    assert_response :redirect
   end
  
-  should 'test update compound metric configuration' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @compound_metric_configuration.metric.name}).returns({:metric_configuration => @compound_metric_configuration_hash})
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, {
-        :metric_configuration => @compound_metric_configuration.to_hash,
-        :configuration_name => @compound_metric_configuration.configuration_name})
-    get :update_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id, 
-    :metric_configuration => @compound_hash
-    assert_equal @content, assigns(:configuration_content)
-    assert_response 302
+  should 'update' do
+    Kalibro::MetricConfiguration.expects(:metric_configurations_of).with(@configuration_content.configuration_id).returns([@native_metric_configuration])
+    @native_metric_configuration.expects(:update_attributes).returns(true) #FIXME need .with(some_hash), should it mock the request?.
+    get :update, :profile => @profile.identifier, :id => @configuration_content.id, :metric_configuration => @native_metric_configuration_hash
+    assert_equal @configuration_content, assigns(:configuration_content)
+    assert_response :redirect
   end
  
-  should 'test remove metric configuration' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @metric.name}).returns({:metric_configuration => @metric_configuration_hash})
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :remove_metric_configuration, {
-        :metric_name => @metric.name,
-        :configuration_name => @metric_configuration.configuration_name})
-    get :remove_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
-    assert_response 302
+  should 'remove' do
+    Kalibro::MetricConfiguration.expects(:new).with({:id => @native_metric_configuration.id}).returns(@native_metric_configuration)
+    @native_metric_configuration.expects(:destroy).returns()
+    get :remove, :profile => @profile.identifier, :id => @configuration_content.id, :metric_configuration_id => @native_metric_configuration.id
+    assert_response :redirect
   end
  
 end
 require 'test_helper'
  
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/native_metric_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_fixtures"
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_fixtures"
  
 class MezuroPluginRangeControllerTest < ActionController::TestCase
  
@@ -11,87 +12,73 @@ class MezuroPluginRangeControllerTest &lt; ActionController::TestCase
     @controller = MezuroPluginRangeController.new
     @request = ActionController::TestRequest.new
     @response = ActionController::TestResponse.new
-    @profile = fast_create(Community)
+    @profile = fast_create(Profile)
  
-    @metric = NativeMetricFixtures.amloc
     @metric_configuration = MetricConfigurationFixtures.amloc_metric_configuration
     @metric_configuration_hash = MetricConfigurationFixtures.amloc_metric_configuration_hash
     @configuration = ConfigurationFixtures.configuration
  
-    Kalibro::Configuration.expects(:all_names).returns([])
-    @content = MezuroPlugin::ConfigurationContent.new(:profile => @profile, :name => @configuration.name)
-    @content.expects(:send_kalibro_configuration_to_service).returns(nil)
+    @content = MezuroPlugin::ConfigurationContent.new(:profile => @profile, :name => @configuration.name, :configuration_id => 42)
+    @content.expects(:send_configuration_to_service).returns(nil)
+    @content.expects(:validate_configuration_name).returns(true)
     @content.stubs(:solr_save)
     @content.save
  
-    @range = RangeFixtures.range_excellent
-    @range_hash = RangeFixtures.range_excellent_hash
+    @created_range = RangeFixtures.created_range
+    @range = RangeFixtures.range
+    @created_range_hash = RangeFixtures.created_range_hash 
+    @range_hash = RangeFixtures.range_hash
+
+    @reading = ReadingFixtures.reading
   end
  
-  should 'test new range' do
-    get :new_range, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
-    assert_equal @content.id.to_s, assigns(:content_id)
-    assert_equal @metric.name, assigns(:metric_name)
-    assert_response 200
+  should 'set correct attributes to create a new range' do
+    Kalibro::Reading.expects(:readings_of).with(@metric_configuration.reading_group_id).returns([@reading])
+    get :new, :profile => @profile.identifier, :id => @content.id, :metric_configuration_id => @metric_configuration.id, :reading_group_id => @metric_configuration.reading_group_id, :compound => @metric_configuration.metric.compound
+    assert_equal @content.id, assigns(:content_id)
+    assert_equal @metric_configuration.id, assigns(:metric_configuration_id)
+    assert_equal [[@reading.label,@reading.id]], assigns(:reading_labels_and_ids)
+    assert_equal @metric_configuration.reading_group_id, assigns(:reading_group_id)
+    assert_equal @metric_configuration.metric.compound, assigns(:compound)
+    assert_response :success
   end
  
-  should 'test edit range' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @metric.name}).returns({:metric_configuration => @metric_configuration_hash})
-    get :edit_range, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name, :beginning_id => @range.beginning
-    assert_equal @content.id.to_s, assigns(:content_id)
-    assert_equal @metric.name, assigns(:metric_name)
-    assert_equal @range.beginning, assigns(:beginning_id)
-    assert_equal @range.end, assigns(:range).end
-    assert_response 200
+  should 'set correct attributes to edit a range' do
+    Kalibro::Reading.expects(:readings_of).with(@metric_configuration.reading_group_id).returns([@reading])
+    Kalibro::Range.expects(:ranges_of).with(@metric_configuration.id).returns([@range])
+    get :edit, :profile => @profile.identifier, :id => @content.id, :metric_configuration_id => @metric_configuration.id, :range_id => @range.id, :reading_group_id => @metric_configuration.reading_group_id
+    assert_equal @content.id, assigns(:content_id)
+    assert_equal @metric_configuration.id, assigns(:metric_configuration_id)
+    assert_equal [[@reading.label,@reading.id]], assigns(:reading_labels_and_ids)
+    assert_equal @range, assigns(:range)
+    assert_response :success
   end
  
   should 'test create instance range' do
-    metric_configuration = @metric_configuration
-    metric_configuration.add_range(@range)
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @metric.name}).returns({:metric_configuration => @metric_configuration_hash})
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, {
-        :metric_configuration => metric_configuration.to_hash,
-        :configuration_name => metric_configuration.configuration_name})
-    get :create_range, :profile => @profile.identifier, :range => @range_hash, :id => @content.id, :metric_name => @metric.name
-    assert_equal @content, assigns(:configuration_content)
-    assert_equal @range.end, assigns(:range).end
-    assert_response 200
+    Kalibro::Range.expects(:request).with(:save_range, {
+        :metric_configuration_id => @metric_configuration.id,
+        :range => @created_range.to_hash}).returns(:range_id => @range.id)
+    Kalibro::Reading.expects(:find).with(@created_range.reading_id).returns(@reading)
+    get :create, :profile => @profile.identifier, :range => @created_range_hash, :metric_configuration_id => @metric_configuration.id, :reading_group_id => @metric_configuration.reading_group_id, :compound => @metric_configuration.metric.compound
+    assert_equal @range.id, assigns(:range).id
+    assert_equal @metric_configuration.reading_group_id, assigns(:reading_group_id)
+    assert_equal @metric_configuration.metric.compound, assigns(:compound)
+    assert_response :success
   end
  
   should 'test update range' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @metric.name}).returns({:metric_configuration => @metric_configuration_hash})
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, {
-        :metric_configuration => @metric_configuration.to_hash,
-        :configuration_name => @metric_configuration.configuration_name})
-    get :update_range,
-        :profile => @profile.identifier,
-        :range => @range_hash,
-        :id => @content.id,
-        :metric_name => @metric.name,
-        :beginning_id => @range.beginning
-    assert_response 200
+    Kalibro::Range.expects(:request).with(:save_range, {
+        :metric_configuration_id => @metric_configuration.id,
+        :range => @range.to_hash}).returns(:range_id => @range.id)
+    get :update, :profile => @profile.identifier, :range => @range_hash, :metric_configuration_id => @metric_configuration.id
+    assert_equal @range.id, assigns(:range).id
+    assert_response :success
   end
  
-  should 'test remove range' do
-    metric_configuration = @metric_configuration
-    metric_configuration.ranges.delete_if { |range| range.beginning == @range.beginning.to_f }
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, {
-      :configuration_name => @content.name,
-      :metric_name => @metric.name}).returns({:metric_configuration => @metric_configuration_hash})
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, {
-        :metric_configuration => metric_configuration.to_hash,
-        :configuration_name => metric_configuration.configuration_name})
-    get :remove_range,
-        :profile => @profile.identifier,
-        :id => @content.id,
-        :metric_name => @metric.name,
-        :beginning_id => @range.beginning
-     assert_response 302
+  should 'test remove range in native metric configuration' do
+    Kalibro::Range.expects(:new).with({:id => @range.id}).returns(@range)
+    @range.expects(:destroy).with().returns()
+    get :remove, :profile => @profile.identifier, :id => @content.id, :metric_configuration_id => @metric_configuration.id, :range_id => @range.id, :compound => false
+     assert_response :redirect
   end
 end
@@ -0,0 +1,74 @@
+require 'test_helper'
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_group_content_fixtures"
+
+class MezuroPluginReadingControllerTest < ActionController::TestCase
+
+  def setup
+    @controller = MezuroPluginReadingController.new
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    @profile = fast_create(Profile)
+
+    @reading = ReadingFixtures.reading
+    @created_reading = ReadingFixtures.created_reading
+    @reading_hash = ReadingFixtures.hash
+    @content = MezuroPlugin::ReadingGroupContent.new(:profile => @profile, :name => name)
+    @content.expects(:send_reading_group_to_service).returns(nil)
+    @content.stubs(:solr_save)
+    @content.save
+  end
+
+  should 'set variables to create a new reading' do
+    get :new, :profile => @profile.identifier, :id => @content.id
+    assert_equal @content.id, assigns(:reading_group_content).id
+    assert_response :success
+  end
+
+  should 'create a reading' do
+    Kalibro::Reading.expects(:new).with(@reading_hash.to_s).returns(@created_reading)
+    @created_reading.expects(:save).with(@content.reading_group_id).returns(true)
+    get :save, :profile => @profile.identifier, :id => @content.id, :reading => @reading_hash
+    assert @created_reading.errors.empty?
+    assert_response :redirect
+  end
+
+  should 'put an Exception in reading when an error occurs in create action' do
+    @created_reading.errors = [Exception.new]
+    Kalibro::Reading.expects(:new).with(@reading_hash.to_s).returns(@created_reading)
+    @created_reading.expects(:save).with(@content.reading_group_id).returns(false)
+    get :save, :profile => @profile.identifier, :id => @content.id, :reading => @reading_hash
+    assert !@created_reading.errors.empty?
+    assert_response :redirect
+  end
+
+  should 'set variables to edit a reading' do
+    Kalibro::Reading.expects(:find).with(@reading.id.to_s).returns(@reading)
+    get :edit, :profile => @profile.identifier, :id => @content.id, :reading_id => @reading.id
+    assert_equal @content.id, assigns(:reading_group_content).id
+    assert_equal @reading, assigns(:reading)
+    assert_response :success
+  end
+
+  should 'destroy a reading' do
+    @reading.expects(:destroy)    
+    Kalibro::Reading.expects(:find).with(@reading.id.to_s).returns(@reading)
+
+    get :destroy, :profile => @profile.identifier, :id => @content.id, :reading_id => @reading.id
+
+    assert @reading.errors.empty?
+    assert_response :redirect
+  end
+
+  should 'put an Exception in reading when an error occurs in destroy action' do
+    @reading.errors = [Exception.new]
+    @reading.expects(:destroy)
+    Kalibro::Reading.expects(:find).with(@reading.id.to_s).returns(@reading)
+
+    get :destroy, :profile => @profile.identifier, :id => @content.id, :reading_id => @reading.id
+
+    assert !@reading.errors.empty?
+    assert_response :redirect
+  end
+end
@@ -1,74 +0,0 @@
-require 'test_helper'
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/error_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/repository_fixtures"
-
-class MezuroPluginModuleControllerTest < ActionController::TestCase
-
-  def setup
-    @controller = MezuroPluginModuleController.new
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @profile = fast_create(Community)
-
-    @project_result = ProjectResultFixtures.project_result
-    @module_result = ModuleResultFixtures.module_result
-    @repository_url = RepositoryFixtures.repository.address
-    @project = @project_result.project
-    @date = "2012-04-13T20:39:41+04:00"
-    
-    Kalibro::Project.expects(:all_names).returns([])
-    @content = MezuroPlugin::ProjectContent.new(:profile => @profile, :name => @project.name, :repository_url => @repository_url)
-    @content.expects(:send_project_to_service).returns(nil)
-    @content.save
-  end
-
-
-  should 'get module result without date' do
-    date_with_milliseconds = Kalibro::ProjectResult.date_with_milliseconds(@project_result.date)
-    Kalibro::ProjectResult.expects(:request).
-      with("ProjectResult", :get_last_result_of, {:project_name => @project.name}).
-      returns({:project_result => @project_result.to_hash})
-    Kalibro::ModuleResult.expects(:request).
-      with("ModuleResult", :get_module_result, {:project_name => @project.name, :module_name => @project.name, :date => date_with_milliseconds}).
-      returns({:module_result => @module_result.to_hash})
-    get :module_result, :profile => @profile.identifier, :id => @content.id, :module_name => @project.name, :date => nil
-    assert_equal @content, assigns(:content)
-    assert_equal @module_result.grade, assigns(:module_result).grade
-    assert_response 200
-    assert_select('h5', 'Metric results for: Qt-Calculator (APPLICATION)')
-  end
-
-  should 'get module result with a specific date' do
-	  date_with_milliseconds = Kalibro::ProjectResult.date_with_milliseconds(@project_result.date)
-    request_body = {:project_name => @project.name, :date => @project_result.date}
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :has_results_before, request_body).returns({:has_results => true})
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_last_result_before, request_body).returns({:project_result => @project_result.to_hash})
-    Kalibro::ModuleResult.expects(:request).with("ModuleResult", :get_module_result, {:project_name => @project.name, :module_name => @project.name, :date => date_with_milliseconds}).returns({:module_result => @module_result.to_hash})
-    get :module_result, :profile => @profile.identifier, :id => @content.id, :module_name => @project.name, :date => @project_result.date
-    assert_equal @content, assigns(:content)
-    assert_equal @module_result.grade, assigns(:module_result).grade
-    assert_response 200
-    assert_select('h5', 'Metric results for: Qt-Calculator (APPLICATION)')
-  end
-
-  should 'test module metrics history' do
-    Kalibro::ModuleResult.expects(:request).with("ModuleResult", :get_result_history, {:project_name => @project.name, :module_name => @project.name}).returns({:module_result => @module_result})
-    get :module_metrics_history, :profile => @profile.identifier, :id => @content.id, :module_name => @project.name,
-    :metric_name => @module_result.metric_result.first.metric.name.delete("() ")
-    assert_equal @content, assigns(:content)
-    assert_equal [[@module_result.metric_result[0].value, @module_result.date.to_s[0..9]]], assigns(:score_history)
-    assert_response 200
-  end
-  
-  should 'test grade history' do
-    Kalibro::ModuleResult.expects(:request).with("ModuleResult", :get_result_history, {:project_name => @project.name, :module_name => @project.name}).returns({:module_result => @module_result})
-    get :module_grade_history, :profile => @profile.identifier, :id => @content.id, :module_name => @project.name
-    assert_equal @content, assigns(:content)
-    assert_equal [[@module_result.grade, @module_result.date.to_s[0..9]]], assigns(:score_history)
-    assert_response 200
-  end
-
-end
@@ -0,0 +1,58 @@
+require 'test_helper'
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/date_metric_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/date_module_result_fixtures"
+
+class MezuroPluginModuleResultControllerTest < ActionController::TestCase
+
+  def setup
+    @controller = MezuroPluginModuleResultController.new
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    @profile = fast_create(Community)
+
+    @module_result_hash = ModuleResultFixtures.module_result_hash
+    @metric_result_hash = MetricResultFixtures.native_metric_result_hash
+    @date_metric_result_hash = DateMetricResultFixtures.date_metric_result_hash
+    @date_module_result_hash = DateModuleResultFixtures.date_module_result_hash
+  end
+
+  should 'find module result on kalibro' do
+    parent_module_result = ModuleResultFixtures.parent_module_result_hash
+    Kalibro::ModuleResult.expects(:request).with(:get_module_result, { :module_result_id => @module_result_hash[:id].to_i }).
+        returns({:module_result => @module_result_hash})
+    Kalibro::MetricResult.expects(:request).with(:metric_results_of, { :module_result_id => @module_result_hash[:id].to_i }).
+        returns({:metric_result => @metric_result_hash})
+    Kalibro::ModuleResult.expects(:request).with(:get_module_result, { :module_result_id => @module_result_hash[:parent_id].to_i }).
+        returns({:module_result => parent_module_result})
+    Kalibro::ModuleResult.expects(:request).with(:children_of, {:module_result_id => @module_result_hash[:id].to_i}).
+        returns({:module_result => nil})
+    get :module_result, :profile => @profile.identifier, :module_result_id => @module_result_hash[:id]
+    assert_equal @module_result_hash[:grade].to_f, assigns(:module_result).grade
+    assert_equal @metric_result_hash[:value].to_f, assigns(:metric_results).first.value
+    assert_response :success
+    #TODO assert_select('h5', 'Metric results for: Qt-Calculator (APPLICATION)')
+  end
+
+  should 'get metric result history' do
+    metric_name = @metric_result_hash[:configuration][:metric][:name]
+    Kalibro::MetricResult.expects(:request).with(:history_of_metric, { :metric_name => metric_name, :module_result_id => @module_result_hash[:id].to_i }).
+        returns({:date_metric_result => @date_metric_result_hash})
+    get :metric_result_history, :profile => @profile.identifier, :module_result_id => @module_result_hash[:id], :metric_name => metric_name
+    assert_equal DateTime.parse(@date_metric_result_hash[:date]), assigns(:history).first.date
+    assert_response :success
+    #TODO assert_select
+  end
+
+  should 'get module result history' do
+    Kalibro::ModuleResult.expects(:request).with(:history_of_module, { :module_result_id => @module_result_hash[:id].to_i }).
+        returns({:date_module_result => @date_module_result_hash})
+    get :module_result_history, :profile => @profile.identifier, :module_result_id => @module_result_hash[:id]
+    assert_equal DateTime.parse(@date_module_result_hash[:date]), assigns(:history).first.date
+    assert_response :success
+    #TODO assert_select
+  end
+  
+end
@@ -0,0 +1,60 @@
+require 'test_helper' 
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/processing_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/throwable_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/repository_fixtures"
+
+
+class MezuroPluginProcessingControllerTest < ActionController::TestCase
+  def setup
+    @controller = MezuroPluginProcessingController.new
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    @profile = fast_create(Community)
+
+    @repository_id = RepositoryFixtures.repository.id
+    @processing = ProcessingFixtures.processing
+    @processing_hash = ProcessingFixtures.processing_hash
+    @processing_with_error_hash = ProcessingFixtures.processing_with_error_hash
+  end
+
+  should 'render last processing state' do
+    Kalibro::Processing.expects(:processing_of).with(@repository_id).returns(@processing)
+    get :state, :profile => @profile.identifier, :repository_id => @repository_id
+    assert_response :success
+    assert_equal @processing.state, @response.body
+  end
+
+  should 'render a processing state in a specific date' do
+    Kalibro::Processing.expects(:processing_with_date_of).with(@repository_id, @processing.date).returns(@processing)
+    get :state, :profile => @profile.identifier, :repository_id => @repository_id, :date => @processing.date
+    assert_response :success
+    assert_equal @processing.state, @response.body
+  end
+
+  should 'render processing with error' do
+    Kalibro::Processing.expects(:request).with(:has_ready_processing, {:repository_id => @repository_id}).returns({:exists => false})
+    Kalibro::Processing.expects(:request).with(:last_processing, :repository_id => @repository_id).returns({:processing => @processing_with_error_hash})
+    get :processing, :profile => @profile.identifier, :repository_id => @repository_id
+    assert_response :success
+    assert_equal @processing_with_error_hash[:state], assigns(:processing).state
+    #TODO How to assert from view? assert_select('h3', 'ERROR')
+  end
+
+  should 'test project result without date' do
+    Kalibro::Processing.expects(:request).with(:has_ready_processing, {:repository_id => @repository_id}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with(:last_ready_processing, {:repository_id => @repository_id}).returns({:processing => @processing_hash})
+    get :processing, :profile => @profile.identifier, :repository_id => @repository_id
+    assert_response :success
+    assert_select('h4', 'Last Result')
+  end
+  
+  should 'test project results from a specific date' do
+    Kalibro::Processing.expects(:request).with(:has_processing_after, {:repository_id => @repository_id, :date => @processing.date}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with(:first_processing_after, :repository_id => @repository_id, :date => @processing.date).returns({:processing => @processing_hash})
+    get :processing, :profile => @profile.identifier, :repository_id => @repository_id, :date => @processing.date
+    assert_response :success
+    assert_select('h4', 'Last Result')
+  end
+
+end
@@ -1,92 +0,0 @@
-require 'test_helper' 
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/error_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/repository_fixtures"
-
-class MezuroPluginProjectControllerTest < ActionController::TestCase
-  def setup
-    @controller = MezuroPluginProjectController.new
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @profile = fast_create(Community)
-
-    @project_result = ProjectResultFixtures.project_result
-    @repository_url = RepositoryFixtures.repository.address
-    @project = @project_result.project
-    @date = "2012-04-13T20:39:41+04:00"
-    
-    Kalibro::Project.expects(:all_names).returns([])
-    @content = MezuroPlugin::ProjectContent.new(:profile => @profile, :name => @project.name, :repository_url => @repository_url)
-    @content.expects(:send_project_to_service).returns(nil)
-    @content.save
-  end
-
-  should 'test project state without kalibro_error' do
-    Kalibro::Project.expects(:request).with("Project", :get_project, :project_name => @project.name).returns({:project => @project.to_hash})
-    get :project_state, :profile => @profile.identifier, :id => @content.id
-    assert_response 200
-    assert_equal @content, assigns(:content)
-  end
-
-  should 'test project state with kalibro_error' do
-    Kalibro::Project.expects(:request).with("Project", :get_project, :project_name => @project.name).returns({:project => @project.to_hash.merge({:error => ErrorFixtures.error_hash})})
-    get :project_state, :profile => @profile.identifier, :id => @content.id
-    assert_response 200
-    assert_equal "ERROR", @response.body
-    assert_equal @content, assigns(:content)
-  end
-
-  should 'test project error' do
-    Kalibro::Project.expects(:request).with("Project", :get_project, :project_name => @project.name).returns({:project => @project.to_hash.merge({:error => ErrorFixtures.error_hash})})
-    get :project_error, :profile => @profile.identifier, :id => @content.id
-    assert_response 200
-    assert_select('h3', 'ERROR')
-    assert_equal @content, assigns(:content)
-    assert_equal @project.name, assigns(:project).name
-  end
-
-  should 'test project result without date' do
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_last_result_of, {:project_name => @project.name}).returns({:project_result => @project_result.to_hash})
-    get :project_result, :profile => @profile.identifier, :id => @content.id, :date => nil
-    assert_equal @content, assigns(:content)
-    assert_equal @project_result.project.name, assigns(:project_result).project.name
-    assert_response 200
-    assert_select('h4', 'Last Result')
-  end
-  
-  should 'test project results from a specific date' do
-    request_body = {:project_name => @project.name, :date => @date}
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :has_results_before, request_body).returns({:has_results => true})
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_last_result_before, request_body).returns({:project_result => @project_result.to_hash})
-    get :project_result, :profile => @profile.identifier, :id => @content.id, :date => @date
-    assert_equal @content, assigns(:content)
-    assert_equal @project_result.project.name, assigns(:project_result).project.name
-    assert_response 200
-    assert_select('h4', 'Last Result')
-  end
-
-  should 'test project tree without date' do
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_last_result_of, {:project_name => @project.name}).returns({:project_result => @project_result.to_hash})
-    Kalibro::Project.expects(:request).with("Project", :get_project, :project_name => @project.name).returns({:project => @project.to_hash})
-  	get :project_tree, :profile => @profile.identifier, :id => @content.id, :module_name => @project.name, :date => nil
-    assert_equal @content, assigns(:content)
-    assert_equal @project.name, assigns(:project_name)
-    assert_equal @project_result.source_tree.module.name, assigns(:source_tree).module.name
-	  assert_response 200
-  	assert_select('h2', /Qt-Calculator/)
-  end
-
-  should 'test project tree with a specific date' do
-    request_body = {:project_name => @project.name, :date => @project_result.date}
-    Kalibro::Project.expects(:request).with("Project", :get_project, :project_name => @project.name).returns({:project => @project.to_hash})
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :has_results_before, request_body).returns({:has_results => true})
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_last_result_before, request_body).returns({:project_result => @project_result.to_hash})
-    get :project_tree, :profile => @profile.identifier, :id => @content.id, :module_name => @project.name, :date => @project_result.date
-    assert_equal @content, assigns(:content)
-    assert_equal @project.name, assigns(:project_name)
-    assert_equal @project_result.source_tree.module.name, assigns(:source_tree).module.name    
-	  assert_response 200
-  end
-
-end
@@ -0,0 +1,104 @@
+require 'test_helper'
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/processing_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/throwable_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/repository_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_content_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
+
+class MezuroPluginRepositoryControllerTest < ActionController::TestCase
+
+  def setup
+    @controller = MezuroPluginRepositoryController.new
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    @profile = fast_create(Community)
+
+    @configuration = ConfigurationFixtures.configuration
+    @repository_types = RepositoryFixtures.types
+    @all_configurations = ConfigurationFixtures.all
+    @repository = RepositoryFixtures.repository
+    @repository_hash = RepositoryFixtures.hash
+    @content = MezuroPlugin::ProjectContent.new(:profile => @profile, :name => name)
+    @content.expects(:send_project_to_service).returns(nil)
+    @content.stubs(:solr_save)
+    @content.save
+  end
+
+  should 'set variables to create a new repository' do
+    Kalibro::Repository.expects(:repository_types).returns(@repository_types)
+    Kalibro::Configuration.expects(:all).returns(@all_configurations)
+
+    get :new, :profile => @profile.identifier, :id => @content.id
+
+    assert_equal @content.id, assigns(:project_content).id
+    assert_equal @repository_types, assigns(:repository_types)
+    assert_equal @all_configurations.first.name, assigns(:configuration_select).first.first
+    assert_equal @all_configurations.first.id, assigns(:configuration_select).first.last
+    assert_response :success
+  end
+
+  should 'save a repository' do
+    Kalibro::Repository.expects(:new).returns(@repository)
+    @repository.expects(:save).with(@content.project_id).returns(true)
+    @repository.expects(:process)
+    get :save, :profile => @profile.identifier, :id => @content.id, :repository => @repository_hash
+    assert @repository.errors.empty?
+    assert_response :redirect
+  end
+
+  should 'not save a repository' do
+    @repository.errors = [Exception.new]
+    Kalibro::Repository.expects(:new).returns(@repository)
+    @repository.expects(:save).with(@content.project_id).returns(false)
+    get :save, :profile => @profile.identifier, :id => @content.id, :repository => @repository_hash
+    assert !@repository.errors.empty?
+    assert_response :redirect
+  end
+
+  should 'set variables to edit a repository' do
+    Kalibro::Repository.expects(:repository_types).returns(@repository_types)
+    Kalibro::Configuration.expects(:all).returns(@all_configurations)
+    Kalibro::Repository.expects(:repositories_of).with(@content.project_id).returns([@repository])
+
+    get :edit, :profile => @profile.identifier, :id => @content.id, :repository_id => @repository.id
+
+    assert_equal @content.id, assigns(:project_content).id
+    assert_equal @repository_types, assigns(:repository_types)
+    assert_equal @all_configurations.first.name, assigns(:configuration_select).first.first
+    assert_equal @all_configurations.first.id, assigns(:configuration_select).first.last
+    assert_equal @repository, assigns(:repository)
+    assert_response :success
+  end
+
+  should 'set variables to show a repository' do
+    Kalibro::Repository.expects(:repositories_of).with(@content.project_id).returns([@repository])
+    Kalibro::Configuration.expects(:configuration_of).with(@repository.id).returns(@configuration)
+
+    get :show, :profile => @profile.identifier, :id => @content.id, :repository_id => @repository.id
+
+    assert_equal @content.id, assigns(:project_content).id
+    assert_equal @repository, assigns(:repository)
+    assert_equal @configuration.name, assigns(:configuration_name)
+    assert_response :success
+  end
+
+  should 'destroy a repository' do
+    Kalibro::Repository.expects(:new).with(:id => @repository.id.to_s).returns(@repository)
+    @repository.expects(:destroy)    
+    get :destroy, :profile => @profile.identifier, :id => @content.id, :repository_id => @repository.id
+
+    assert @repository.errors.empty?
+    assert_response :redirect
+  end
+
+  should 'not destroy a repository' do
+    @repository.errors = [Exception.new]
+    Kalibro::Repository.expects(:new).with(:id => @repository.id.to_s).returns(@repository)
+    @repository.expects(:destroy)    
+    get :destroy, :profile => @profile.identifier, :id => @content.id, :repository_id => @repository.id
+
+    #TODO verify if it is redirected to the right page
+    assert_response :redirect
+  end
+end
@@ -0,0 +1,42 @@
+#!/bin/bash
+
+TEST_FILE=$1
+PROFILE=$2
+
+if [ -z "$PROFILE" ]; then
+  PROFILE='default'
+fi
+
+# where are your .kalibro dir?
+KALIBRO_HOME='/usr/share/tomcat6/.kalibro'
+
+# create a kalibro test dir
+echo "-->  Creating tests directory"
+sudo mkdir $KALIBRO_HOME/tests
+echo "-->  Copying test settings"
+sudo cp $KALIBRO_HOME/kalibro_tests.settings $KALIBRO_HOME/tests/kalibro.settings
+echo "-->  Changing owner of tests directory to tomcat6"
+sudo chown -R tomcat6:tomcat6 $KALIBRO_HOME/tests
+
+# you must restart tomcat6
+#if you are using a tomcat installed from apt-get, for example:
+sudo service tomcat6 restart
+
+#if you are using a tomcat installed a specific dir, for exemple:
+#~/tomcat6/bin/shoutdown.sh
+#~/tomcat6/bin/startup.sh
+
+# run test
+cucumber $TEST_FILE -p $PROFILE
+
+#back to normal mode
+echo "-->  Removing tests directory"
+sudo rm -rf $KALIBRO_HOME/tests
+
+# you must restart tomcat6 again
+sudo service tomcat6 restart
+
+#or some thing like that...
+#~/tomcat6/bin/shoutdown.sh
+#~/tomcat6/bin/startup.sh
+
 require "test_helper"
-
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
  
 class BaseToolTest < ActiveSupport::TestCase
@@ -10,27 +9,19 @@ class BaseToolTest &lt; ActiveSupport::TestCase
   end
  
   should 'create base tool from hash' do
-    assert_equal @base_tool.name, Kalibro::BaseTool.new(@hash).name
-  end
-
-  should 'convert base tool to hash' do
-    assert_equal @hash, @base_tool.to_hash
+    assert_equal @hash[:name], Kalibro::BaseTool.new(@hash).name
   end
-
+  
   should 'get base tool names' do
     names = ['Analizo', 'Checkstyle']
-    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool_names).returns({:base_tool_name => names})
+    Kalibro::BaseTool.expects(:request).with(:all_base_tool_names).returns({:base_tool_name => names})
     assert_equal names, Kalibro::BaseTool.all_names
   end
  
   should 'get base tool by name' do
     request_body = {:base_tool_name => @base_tool.name}
-    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool, request_body).returns({:base_tool => @hash})
+    Kalibro::BaseTool.expects(:request).with(:get_base_tool, request_body).returns({:base_tool => @hash})
     assert_equal @base_tool.name, Kalibro::BaseTool.find_by_name(@base_tool.name).name
   end
  
-  should 'get base tool metrics' do
-    assert_equal @base_tool.supported_metrics[0].name, @base_tool.metric('Total Coupling Factor').name
-  end
-  
 end
@@ -1,20 +0,0 @@
-require "test_helper"
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/compound_metric_fixtures"
-
-class CompoundMetricTest < ActiveSupport::TestCase
-
-  def setup
-    @hash = CompoundMetricFixtures.compound_metric_hash
-    @metric = CompoundMetricFixtures.compound_metric
-  end
-
-  should 'create compound metric from hash' do
-    assert_equal @hash[:script], Kalibro::CompoundMetric.new(@hash).script
-  end
-
-  should 'convert compound metric to hash' do
-    assert_equal @hash, @metric.to_hash
-  end
-
-end
@@ -1,20 +0,0 @@
-require "test_helper"
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/compound_metric_with_error_fixtures"
-
-class CompoundMetricWithErrorTest < ActiveSupport::TestCase
-  
-  def setup
-    @hash = CompoundMetricWithErrorFixtures.compound_metric_with_error_hash
-    @compound_metric_with_error = CompoundMetricWithErrorFixtures.compound_metric_with_error
-  end
-
-  should 'create error from hash' do
-    assert_equal @hash[:error][:message], Kalibro::CompoundMetricWithError.new(@hash).error.message
-  end
-
-  should 'convert error to hash' do
-    assert_equal @hash, @compound_metric_with_error.to_hash
-  end
-
-end
@@ -7,7 +7,7 @@ class ConfigurationTest &lt; ActiveSupport::TestCase
   def setup
     @hash = ConfigurationFixtures.configuration_hash
     @configuration = ConfigurationFixtures.configuration
-    @configuration_content = ConfigurationFixtures.configuration_content([])
+    @created_configuration = ConfigurationFixtures.created_configuration
   end
  
   should 'initialize configuration' do
@@ -18,39 +18,49 @@ class ConfigurationTest &lt; ActiveSupport::TestCase
     assert_equal @hash, @configuration.to_hash
   end
  
-  should 'return true when configuration is saved successfully' do
-    Kalibro::Configuration.expects(:request).with("Configuration", :save_configuration, {:configuration => @configuration.to_hash})
-    assert @configuration.save
+  should 'answer if configuration exists in kalibro' do
+    Kalibro::Configuration.expects(:request).with(:configuration_exists, {:configuration_id => @configuration.id}).returns({:exists => true})
+    assert Kalibro::Configuration.exists?(@configuration.id)
   end
  
-  should 'return false when configuration is not saved successfully' do
-    Kalibro::Configuration.expects(:request).with("Configuration", :save_configuration, {:configuration => @configuration.to_hash}).raises(Exception.new)
-    assert !(@configuration.save)
+  should 'find configuration' do
+    Kalibro::Configuration.expects(:request).with(:configuration_exists, {:configuration_id => @configuration.id}).returns({:exists => true})
+    Kalibro::Configuration.expects(:request).with(:get_configuration, {:configuration_id => @configuration.id}).returns(:configuration => @hash)
+    assert_equal @hash[:name], Kalibro::Configuration.find(@configuration.id).name
+  end
+
+  should 'return exception when configuration doesnt exist' do
+    Kalibro::Configuration.expects(:request).with(:configuration_exists, {:configuration_id => @configuration.id}).returns({:exists => false})
+    assert_raise(Kalibro::Errors::RecordNotFound){Kalibro::Configuration.find(@configuration.id)}
+  end
+
+  should 'get configuration of a repository' do
+    repository_id = 31
+    Kalibro::Configuration.expects(:request).with(:configuration_of, {:repository_id => repository_id}).returns({:configuration => @hash})
+    assert_equal @hash[:name], Kalibro::Configuration.configuration_of(repository_id).name
   end
-  
-  should 'get all configuration names' do
-    names = ['Kalibro for Java', 'ConfigurationClientTest configuration']
-    Kalibro::Configuration.expects(:request).with("Configuration", :get_configuration_names).returns({:configuration_name => names})
-    assert_equal names, Kalibro::Configuration.all_names
+
+  should 'get all configuration' do
+    Kalibro::Configuration.expects(:request).with(:all_configurations).returns({:configuration => [@hash]})
+    assert_equal @hash[:name], Kalibro::Configuration.all.first.name
   end
  
-  should 'find configuration by name' do
-    request_body = {:configuration_name => @configuration.name}
-    response_hash = {:configuration => @configuration.to_hash}
-    Kalibro::Configuration.expects(:request).with("Configuration", :get_configuration, request_body).returns(response_hash)
-    assert_equal @configuration.name, Kalibro::Configuration.find_by_name(@configuration.name).name
+  should 'return true when configuration is saved successfully' do
+    id_from_kalibro = 1
+    Kalibro::Configuration.expects(:request).with(:save_configuration, {:configuration => @created_configuration.to_hash}).returns(:configuration_id => id_from_kalibro)
+    assert @created_configuration.save
+    assert_equal id_from_kalibro, @created_configuration.id
   end
  
-  should 'return nil when configuration doesnt exist' do
-    request_body = {:configuration_name => @configuration.name}
-    Kalibro::Configuration.expects(:request).with("Configuration", :get_configuration, request_body).raises(Exception.new)
-    assert_raise Exception do
-      Kalibro::Configuration.find_by_name(@configuration.name)
-    end
+  should 'return false when configuration is not saved successfully' do
+    Kalibro::Configuration.expects(:request).with(:save_configuration, {:configuration => @created_configuration.to_hash}).raises(Exception.new)
+    assert !(@created_configuration.save)
+    assert_nil @created_configuration.id
   end
  
-  should 'destroy configuration by name' do
-    Kalibro::Configuration.expects(:request).with("Configuration", :remove_configuration, {:configuration_name => @configuration.name})
+  should 'remove existent configuration from service' do
+    Kalibro::Configuration.expects(:request).with(:delete_configuration, {:configuration_id => @configuration.id})
     @configuration.destroy
   end
+
 end
@@ -0,0 +1,20 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/date_metric_result_fixtures"
+
+class DateMetricResultTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = DateMetricResultFixtures.date_metric_result_hash
+    @date_metric_result = DateMetricResultFixtures.date_metric_result
+  end
+
+  should 'create date_metric_result from hash' do
+    assert_equal @hash[:metric_result][:id].to_i, Kalibro::DateMetricResult.new(@hash).metric_result.id
+  end
+
+  should 'convert date_metric_result to hash' do
+    assert_equal @hash, @date_metric_result.to_hash
+  end
+
+end
@@ -0,0 +1,20 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/date_module_result_fixtures"
+
+class DateModuleResultTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = DateModuleResultFixtures.date_module_result_hash
+    @date_module_result = DateModuleResultFixtures.date_module_result
+  end
+
+  should 'create date_module_result from hash' do
+    assert_equal @hash[:module_result][:id].to_i, Kalibro::DateModuleResult.new(@hash).module_result.id
+  end
+
+  should 'convert date_module_result to hash' do
+    assert_equal @hash, @date_module_result.to_hash
+  end
+
+end
@@ -1,20 +0,0 @@
-require "test_helper"
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/error_fixtures"
-
-class ErrorTest < ActiveSupport::TestCase
-
-  def setup
-    @hash = ErrorFixtures.error_hash
-    @error = ErrorFixtures.error
-  end
-
-  should 'create error from hash' do
-    assert_equal @hash[:message], Kalibro::Error.new(@hash).message
-  end
-
-  should 'convert error to hash' do
-    assert_equal @hash, @error.to_hash
-  end
-
-end
@@ -0,0 +1,24 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_snapshot_fixtures"
+
+class MetricConfigurationSnapshotTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = MetricConfigurationSnapshotFixtures.metric_configuration_snapshot_hash
+    @hash2 = MetricConfigurationSnapshotFixtures.metric_configuration_snapshot_hash_with_2_elements
+    @metric_configuration_snapshot = MetricConfigurationSnapshotFixtures.metric_configuration_snapshot
+    @metric_configuration_snapshot2 = MetricConfigurationSnapshotFixtures.metric_configuration_snapshot_with_2_elements
+  end
+
+  should 'create and convert metric configuration snapshot from hash' do
+    assert_equal @hash[:code], Kalibro::MetricConfigurationSnapshot.new(@hash).code
+    assert_equal @hash[:weight].to_f, @metric_configuration_snapshot.weight
+  end
+
+  should 'create and convert metric configuration snapshot from hash with 2 elements' do
+    assert_equal @hash2[:code], Kalibro::MetricConfigurationSnapshot.new(@hash2).code
+    assert_equal @hash2, @metric_configuration_snapshot2.to_hash
+  end
+
+end
 require "test_helper"
  
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_fixtures"
  
 class MetricConfigurationTest < ActiveSupport::TestCase
  
   def setup
     @native_metric_configuration = MetricConfigurationFixtures.amloc_metric_configuration
     @native_metric_configuration_hash = MetricConfigurationFixtures.amloc_metric_configuration_hash
-    @compound_metric_configuration = MetricConfigurationFixtures.sc_metric_configuration
-    @metric_configuration_without_ranges = MetricConfigurationFixtures.metric_configuration_without_ranges
-    @excellent_range = RangeFixtures.range_excellent
-    @bad_range = RangeFixtures.range_bad
+    @created_metric_configuration = MetricConfigurationFixtures.created_metric_configuration
   end
  
   should 'create metric configuration from hash' do
-    assert_equal @native_metric_configuration_hash[:code], Kalibro::MetricConfiguration.new(@native_metric_configuration_hash).code
+    metric_configuration = Kalibro::MetricConfiguration.new(@native_metric_configuration_hash)
+    assert_equal @native_metric_configuration_hash[:code], metric_configuration.code
+    assert_equal @native_metric_configuration_hash[:id].to_i, metric_configuration.id
+    assert_equal @native_metric_configuration_hash[:reading_group_id].to_i, metric_configuration.reading_group_id
   end
  
   should 'convert metric configuration to hash' do
-    assert_equal @native_metric_configuration_hash, @native_metric_configuration.to_hash()
+    assert_equal @native_metric_configuration_hash, @native_metric_configuration.to_hash
   end
  
-  should 'create appropriate metric type' do
-    assert @native_metric_configuration.metric.instance_of?(Kalibro::NativeMetric)
-    assert @compound_metric_configuration.metric.instance_of?(Kalibro::CompoundMetric)
+  should 'get all metric configurations of a configuration' do
+    configuration_id = 13
+    request_body = { :configuration_id => configuration_id }
+    response_hash = {:metric_configuration => [@native_metric_configuration_hash]}
+    Kalibro::MetricConfiguration.expects(:request).with(:metric_configurations_of, request_body).returns(response_hash)    
+    assert_equal @native_metric_configuration.code, Kalibro::MetricConfiguration.metric_configurations_of(configuration_id).first.code
   end
  
-  should 'add a range to an empty range list' do
-    @metric_configuration_without_ranges.add_range @excellent_range
-    assert_equal @metric_configuration_without_ranges.ranges, [@excellent_range]
-  end
-  
-  should 'add a range to an non-empty range list' do
-    @metric_configuration_without_ranges.ranges = [@excellent_range]
-    @metric_configuration_without_ranges.add_range @bad_range
-    assert_equal @metric_configuration_without_ranges.ranges, [@excellent_range, @bad_range]
-  end
-
-  should 'save metric configuration' do
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, {
-        :metric_configuration => @native_metric_configuration_hash,
-        :configuration_name => @native_metric_configuration.configuration_name
-      })
-    @native_metric_configuration.save
+  should 'return true when metric configuration is saved successfully' do
+    id_from_kalibro = 1
+    configuration_id = @created_metric_configuration.configuration_id
+    Kalibro::MetricConfiguration.expects(:request).with(:save_metric_configuration, {:metric_configuration => @created_metric_configuration.to_hash, :configuration_id => configuration_id}).returns(:metric_configuration_id => id_from_kalibro)
+    assert @created_metric_configuration.save
+    assert_equal id_from_kalibro, @created_metric_configuration.id
   end
  
-  should 'get metric configuration by name and configuration name' do
-    request_body = {
-      :configuration_name => @native_metric_configuration.configuration_name,
-      :metric_name => @native_metric_configuration.metric.name
-    }
-    response_hash = {:metric_configuration => @native_metric_configuration_hash}
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, request_body).returns(response_hash)
-    metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@native_metric_configuration.configuration_name,
-                                                                                         @native_metric_configuration.metric.name)
-    assert_equal @native_metric_configuration.code, metric_configuration.code
+  should 'return false when metric configuration is not saved successfully' do
+    configuration_id = @created_metric_configuration.configuration_id
+    Kalibro::MetricConfiguration.expects(:request).with(:save_metric_configuration, {:metric_configuration => @created_metric_configuration.to_hash, :configuration_id => configuration_id}).raises(Exception.new)
+    assert !(@created_metric_configuration.save)
+    assert_nil @created_metric_configuration.id
   end
  
-  should 'destroy metric configuration by name' do
-    request_body = {
-      :configuration_name => @native_metric_configuration.configuration_name,
-      :metric_name => @native_metric_configuration.metric.name
-    }
-    Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :remove_metric_configuration, request_body)
+  should 'destroy metric configuration' do
+    Kalibro::MetricConfiguration.expects(:request).with(:delete_metric_configuration, :metric_configuration_id => @native_metric_configuration.id)
     @native_metric_configuration.destroy
   end
  
 require "test_helper"
  
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/date_metric_result_fixtures"
  
 class MetricResultTest < ActiveSupport::TestCase
  
   def setup
-    @hash = MetricResultFixtures.native_metric_result_hash
+    @native_hash = MetricResultFixtures.native_metric_result_hash
+    @compound_hash = MetricResultFixtures.compound_metric_result_hash
     @result = MetricResultFixtures.native_metric_result
   end
  
   should 'create metric result from hash' do
-    assert_equal @hash[:metric][:name], Kalibro::MetricResult.new(@hash).metric.name
+    metric_result = Kalibro::MetricResult.new(@native_hash)
+    assert_equal @native_hash[:configuration][:code], metric_result.configuration.code
+    assert_equal @native_hash[:id].to_i, metric_result.id
+    assert_equal @native_hash[:value].to_f, metric_result.value
   end
  
-  should 'convert metric result to hash' do
-    assert_equal @hash, @result.to_hash
+  should 'create metric result with aggregated value from hash' do
+    hash = @native_hash
+    hash[:aggregated_value] = "2.0"
+    hash[:value] = "NaN"
+    metric_result = Kalibro::MetricResult.new(hash)
+    assert_equal @native_hash[:aggregated_value].to_f, metric_result.value
   end
  
-  should 'create appropriate metric type' do
-    assert MetricResultFixtures.native_metric_result.metric.instance_of?(Kalibro::NativeMetric)
-    assert MetricResultFixtures.compound_metric_result.metric.instance_of?(Kalibro::CompoundMetric)
+  should 'convert metric result to hash' do
+    assert_equal @native_hash, @result.to_hash
   end
  
-  should 'convert single descendent result to array' do
-    @result.descendent_result = 1
-    assert_equal [1], @result.descendent_results
+  should 'return descendant results of a metric result' do
+    descendant = [31, 13]
+    Kalibro::MetricResult.expects(:request).with(:descendant_results_of, {:metric_result_id => @result.id}).returns({:descendant_result => descendant})
+    assert_equal descendant, @result.descendant_results
   end
  
+  should 'return metric results of a module result' do
+    id = 31
+    Kalibro::MetricResult.expects(:request).with(:metric_results_of, {:module_result_id => id}).returns(:metric_result => [@native_hash, @compound_hash])
+    assert_equal @native_hash[:id].to_i, Kalibro::MetricResult.metric_results_of(id).first.id
+  end
+
+  should 'return history of a metric with a module result id' do
+    module_result_id = 31
+    Kalibro::MetricResult.expects(:request).with(:history_of_metric, {:metric_name => @result.configuration.metric.name, :module_result_id => module_result_id}).returns({:date_metric_result => DateMetricResultFixtures.date_metric_result_hash})
+    assert_equal DateMetricResultFixtures.date_metric_result_hash[:metric_result][:id].to_i, Kalibro::MetricResult.history_of(@result.configuration.metric.name, module_result_id).first.metric_result.id
+  end
+
 end
@@ -0,0 +1,29 @@
+require "test_helper"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_fixtures"
+
+class MetricTest < ActiveSupport::TestCase
+
+  def setup
+    @native_hash = MetricFixtures.amloc_hash
+    @native = MetricFixtures.amloc
+    @compound_hash = MetricFixtures.compound_metric_hash
+    @compound = MetricFixtures.compound_metric
+  end
+
+  should 'create native metric from hash' do
+    assert_equal @native_hash[:name], Kalibro::Metric.new(@native_hash).name
+  end
+
+  should 'convert native metric to hash' do
+    assert_equal @native_hash, @native.to_hash
+  end
+
+  should 'create compound metric from hash' do
+    assert_equal @compound_hash[:script], Kalibro::Metric.new(@compound_hash).script
+  end
+
+  should 'convert compound metric to hash' do
+    assert_equal @compound_hash, @compound.to_hash
+  end
+
+end
@@ -1,19 +0,0 @@
-require "test_helper"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_node_fixtures"
-
-class ModuleNodeTest < ActiveSupport::TestCase
-
-  def setup
-    @hash = ModuleNodeFixtures.module_node_hash
-    @node = ModuleNodeFixtures.module_node
-  end
-
-  should 'create module node from hash' do
-    assert_equal( @node.child[0].module.name, Kalibro::ModuleNode.new(@hash).child[0].module.name)
-  end
-
-  should 'convert children hash to array of ModuleNode' do
-    assert_equal @hash, @node.to_hash
-  end
-  
-end
 require "test_helper"
  
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/date_module_result_fixtures"
  
 class ModuleResultTest < ActiveSupport::TestCase
  
@@ -8,8 +9,12 @@ class ModuleResultTest &lt; ActiveSupport::TestCase
     @hash = ModuleResultFixtures.module_result_hash
     @module_result = ModuleResultFixtures.module_result
   end
+
   should 'create module result' do
-    assert_equal @module_result.date.to_s , Kalibro::ModuleResult.new(@hash).date.to_s
+    module_result = Kalibro::ModuleResult.new(@hash)
+    assert_equal @hash[:id].to_i , module_result.id
+    assert_equal @hash[:grade].to_f , module_result.grade
+    assert_equal @hash[:parent_id].to_i , module_result.parent_id
   end
  
   should 'convert module result to hash' do
@@ -17,22 +22,29 @@ class ModuleResultTest &lt; ActiveSupport::TestCase
   end
  
   should 'find module result' do
-    date = DateTime.parse(@module_result.date.to_s)
-    name = @module_result.module.name
-    request_body = {:project_name => name, :module_name => name, :date => '2011-10-20T18:26:43.0+00:00'}
     response = {:module_result => @hash}
-    Kalibro::ModuleResult.expects(:request).with('ModuleResult',:get_module_result, request_body).returns(response)
-    assert_equal @module_result.grade, Kalibro::ModuleResult.find_by_project_name_and_module_name_and_date(name, name, date).grade
+    Kalibro::ModuleResult.expects(:request).with(:get_module_result, {:module_result_id => @module_result.id}).returns(response)
+    assert_equal @module_result.grade, Kalibro::ModuleResult.find(@module_result.id).grade
   end
  
-  should 'find all module results' do
-    name = @module_result.module.name
-    request_body = {:project_name => name, :module_name => name}
-    response = {:module_result => @hash}
-    Kalibro::ModuleResult.expects(:request).with('ModuleResult',:get_result_history, request_body).returns(response)
-    response_array = Kalibro::ModuleResult.all_by_project_name_and_module_name(name, name)
-    assert_equal [@module_result].class, response_array.class
-    assert_equal @module_result.grade, response_array[0].grade
+  should 'return children of a module result' do
+    response = {:module_result => [@hash]}
+    Kalibro::ModuleResult.expects(:request).with(:children_of, {:module_result_id => @module_result.id}).returns(response)
+    assert @hash[:id], @module_result.children.first.id
+  end
+
+  should 'return parents of a module result' do
+    parent_module_result = ModuleResultFixtures.parent_module_result_hash
+    response = {:module_result => parent_module_result}
+    Kalibro::ModuleResult.expects(:request).with(:get_module_result, {:module_result_id => @module_result.parent_id}).returns(response)
+    parents = @module_result.parents
+    assert parent_module_result[:module][:name], parents.first.module.name 
+    assert parent_module_result[:module][:name], parents.last.module.name 
+  end
+
+  should 'return history of a module result' do
+    Kalibro::ModuleResult.expects(:request).with(:history_of_module, {:module_result_id => @module_result.id}).returns({:date_module_result => [DateModuleResultFixtures.date_module_result_hash]})
+    assert_equal DateModuleResultFixtures.date_module_result_hash[:module_result][:id].to_i, Kalibro::ModuleResult.history_of(@module_result.id).first.module_result.id
   end
  
 end
@@ -12,19 +12,9 @@ class ModuleTest &lt; ActiveSupport::TestCase
   should 'create module from hash' do
     assert_equal @hash[:name], Kalibro::Module.new(@hash).name
   end
-  
+
   should 'convert module to hash' do
     assert_equal @hash, @module.to_hash
   end
  
-  should 'list ancestor names' do
-    @module.name = "org.kalibro.core"
-    assert_equal ["org", "org.kalibro", "org.kalibro.core"], @module.ancestor_names
-  end
-
-  should 'list ancestor with one name' do
-    @module.name = "org"
-    assert_equal ["org"], @module.ancestor_names
-  end
- 
 end
@@ -1,20 +0,0 @@
-require "test_helper"
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/native_metric_fixtures"
-
-class NativeMetricTest < ActiveSupport::TestCase
-
-  def setup
-    @hash = NativeMetricFixtures.amloc_hash
-    @metric = NativeMetricFixtures.amloc
-  end
-
-  should 'create native metric from hash' do
-    assert_equal @hash[:name], Kalibro::NativeMetric.new(@hash).name
-  end
-
-  should 'convert native metric to hash' do
-    assert_equal @hash, @metric.to_hash
-  end
-
-end
@@ -0,0 +1,25 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/process_time_fixtures"
+
+class ProcessTimeTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = ProcessTimeFixtures.process_time_hash
+    @process_time = ProcessTimeFixtures.process_time
+  end
+
+  should 'create process time from hash' do
+    assert_equal @hash[:state], Kalibro::ProcessTime.new(@hash).state
+    assert_equal @hash[:time].to_i, Kalibro::ProcessTime.new(@hash).time
+  end
+
+  should 'convert process time to hash' do
+    assert_equal @hash, @process_time.to_hash
+  end
+
+  should 'get time as an integer' do
+    assert_equal 1.class, @process_time.time.class
+  end
+
+end
@@ -0,0 +1,98 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/processing_fixtures"
+class ProcessingTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = ProcessingFixtures.processing_hash
+    @processing = ProcessingFixtures.processing
+    
+    @repository_id = 31
+  end
+
+  should 'create processing from hash' do
+    processing = Kalibro::Processing.new(@hash)
+    assert_equal @hash[:results_root_id].to_i, processing.results_root_id
+    assert_equal @hash[:process_time].first[:state], processing.process_times.first.state
+    assert_equal @hash[:id].to_i, processing.id
+  end
+
+  should 'convert processing to hash' do
+    assert_equal @hash, @processing.to_hash
+  end
+
+  should 'verify if a repository has a processing' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with(:has_processing, {:repository_id => true_repository_id}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with(:has_processing, {:repository_id => false_repository_id}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing(true_repository_id)
+    assert !Kalibro::Processing.has_processing(false_repository_id)
+  end
+  
+  should 'verify if a repository has a ready processing' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with(:has_ready_processing, {:repository_id => true_repository_id}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with(:has_ready_processing, {:repository_id => false_repository_id}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_ready_processing(true_repository_id)
+    assert !Kalibro::Processing.has_ready_processing(false_repository_id)
+  end
+  
+  should 'verify if a repository has a processing after a date' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with(:has_processing_after, {:repository_id => true_repository_id, :date => @processing.date}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with(:has_processing_after, {:repository_id => false_repository_id, :date => @processing.date}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing_after(true_repository_id, @processing.date)
+    assert !Kalibro::Processing.has_processing_after(false_repository_id, @processing.date)
+  end  
+  
+  should 'verify if a repository has a processing before a date' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with(:has_processing_before, {:repository_id => true_repository_id, :date => @processing.date}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with(:has_processing_before, {:repository_id => false_repository_id, :date => @processing.date}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing_before(true_repository_id, @processing.date)
+    assert !Kalibro::Processing.has_processing_before(false_repository_id, @processing.date)
+  end  
+  
+  should 'get last processing state of a repository' do
+    Kalibro::Processing.expects(:request).with(:last_processing_state, {:repository_id => @repository_id}).returns({:process_state => @processing.state})
+    assert_equal @processing.state, Kalibro::Processing.last_processing_state_of(@repository_id)
+  end
+  
+  should 'get last ready processing of a repository' do
+    Kalibro::Processing.expects(:request).with(:last_ready_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_ready_processing_of(@repository_id).id
+  end
+
+  should 'get first processing of a repository' do
+    Kalibro::Processing.expects(:request).with(:first_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.first_processing_of(@repository_id).id
+  end
+  
+  should 'get last processing of a repository' do
+    Kalibro::Processing.expects(:request).with(:last_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_processing_of(@repository_id).id
+  end
+  
+  should 'get first processing after a date of a repository' do
+    Kalibro::Processing.expects(:request).with(:first_processing_after, {:repository_id => @repository_id, :date => @processing.date}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.first_processing_after(@repository_id, @processing.date).id
+  end
+  
+  should 'get last processing before a date of a repository' do
+    Kalibro::Processing.expects(:request).with(:last_processing_before, {:repository_id => @repository_id, :date => @processing.date}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_processing_before(@repository_id, @processing.date).id
+  end
+  
+end
@@ -1,88 +0,0 @@
-require "test_helper"
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
-
-class ProjectResultTest < ActiveSupport::TestCase
-
-  def setup
-    @hash = ProjectResultFixtures.project_result_hash
-    @project_result = ProjectResultFixtures.project_result
-    
-    @project_name = @project_result.project.name
-    @date = @project_result.date
-    @flag = DateTime.now.sec % 2 == 0 #random choose between true or false
-
-    @request = {:project_name => @project_name}
-    @request_with_date = {:project_name => @project_name, :date => @date}
-    @flag_response = {:has_results => @flag}
-    @result_response = {:project_result => @project_result.to_hash}
-  end
-
-  should 'create project result from hash' do
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.new(@hash).analysis_time
-  end
-
-  should 'convert project result to hash' do
-    assert_equal @hash, @project_result.to_hash
-  end
-
-  should 'get last result' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_last_result_of, @request).returns(@result_response)
-    assert_equal @project_result.analysis_time , Kalibro::ProjectResult.last_result(@project_name).analysis_time
-  end
-
-  should 'get first result' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_first_result_of, @request).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.first_result(@project_name).analysis_time
-  end
-
-  should 'get first result after date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_first_result_after, @request_with_date).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.first_result_after(@project_name, @date).analysis_time
-  end
-  
-  should 'get last result before date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_last_result_before, @request_with_date).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.last_result_before(@project_name, @date).analysis_time
-  end
-  
-  should 'verify if project has results' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_for, @request).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results?(@project_name)
-  end
-  
-  should 'verify if project has results before date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_before, @request_with_date).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results_before?(@project_name, @date)
-  end
-  
-  should 'verify if project has results after date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_after, @request_with_date).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results_after?(@project_name, @date)
-  end
-
-  should 'retrieve formatted load time' do
-    assert_equal '00:00:14', @project_result.formatted_load_time
-  end
-
-  should 'retrieve formatted analysis time' do
-    assert_equal '00:00:01', @project_result.formatted_analysis_time
-  end
-
-  should 'retrive complex module' do
-    assert_equal @hash[:source_tree][:child][0][:child].first, @project_result.node("org.Window").to_hash
-  end
-
-  should 'return source tree node when nil is given' do
-    assert_equal @hash[:source_tree], @project_result.node(nil).to_hash 
-  end
-  
-  should 'return source tree node when project name is given' do
-    assert_equal @hash[:source_tree], @project_result.node(@project_result.project.name).to_hash 
-  end
-
-  should 'return correct node when module name is given' do
-    assert_equal @hash[:source_tree][:child][2], @project_result.node("main").to_hash
-  end
-
-end
@@ -7,82 +7,75 @@ class ProjectTest &lt; ActiveSupport::TestCase
   def setup
     @hash = ProjectFixtures.project_hash
     @project = ProjectFixtures.project
-    @project_content = ProjectFixtures.project_content
+    @created_project = ProjectFixtures.created_project
   end
-
-  should 'get all project names' do
-    response_hash = {:project_name => [@project.name]}
-    Kalibro::Project.expects(:request).with("Project", :get_project_names).returns(response_hash)
-    assert_equal response_hash[:project_name], Kalibro::Project.all_names
+  
+  should 'initialize new project from hash' do
+    project = Kalibro::Project.new @hash
+    assert_equal @hash[:name], project.name
+    assert_equal @hash[:id].to_i, project.id
   end
  
-  should 'return empty when there are no projects' do
-    response_hash = {:project_name => nil}
-    Kalibro::Project.expects(:request).with("Project", :get_project_names).returns(response_hash)
-    assert_equal [], Kalibro::Project.all_names
+  should 'convert project to hash' do
+    hash = @project.to_hash
+    assert_equal @project.name, hash[:name]
   end
  
-  should 'find project by name' do
-    request_body = {:project_name => @project.name}
-    response_hash = {:project => @hash}
-    Kalibro::Project.expects(:new).with(@hash).returns(@project)
-    Kalibro::Project.expects(:request).with("Project", :get_project, request_body).returns(response_hash)
-    assert_equal @project, Kalibro::Project.find_by_name(@project.name)
+  should 'answer if project exists in kalibro' do
+    Kalibro::Project.expects(:request).with(:project_exists, {:project_id => @project.id}).returns({:exists => true})
+    assert Kalibro::Project.exists?(@project.id)
   end
  
-  should 'raise error when project doesnt exist' do
-    request_body = {:project_name => @project.name}
-    Kalibro::Project.expects(:request).with("Project", :get_project, request_body).raises(Exception.new("(S:Server) There is no project named " + @project.name))
-    assert_raise Exception do Kalibro::Project.find_by_name(@project.name) end
+  should 'find project' do
+    Kalibro::Project.expects(:request).with(:project_exists, {:project_id => @project.id}).returns({:exists => true})
+    Kalibro::Project.expects(:request).with(:get_project, {:project_id => @project.id}).returns(:project => @hash)
+    assert_equal @hash[:name], Kalibro::Project.find(@project.id).name
   end
  
-  should 'return true when project is saved successfully' do
-    Kalibro::Project.expects(:request).with("Project", :save_project, {:project => @project.to_hash})
-    assert @project.save
+  should 'raise RecordNotFound exception when project doesnt exist' do
+    Kalibro::Project.expects(:request).with(:project_exists, {:project_id => @project.id}).returns({:exists => false})
+    assert_raise(Kalibro::Errors::RecordNotFound){Kalibro::Project.find(@project.id)}
   end
  
-  should 'return false when project is not saved successfully' do
-    Kalibro::Project.expects(:request).with("Project", :save_project, {:project => @project.to_hash}).raises(Exception.new)
-    assert !(@project.save)
+  should 'get project of a repository' do
+    repository_id = 31
+    Kalibro::Project.expects(:request).with(:project_of, {:repository_id => repository_id}).returns({:project => @hash})
+    assert_equal @hash[:name], Kalibro::Project.project_of(repository_id).name
   end
  
-  should 'remove existent project from service' do
-    Kalibro::Project.expects(:request).with("Project", :remove_project, {:project_name => @project.name})
-    @project.destroy
-  end
-  
-  should 'initialize new project from hash' do
-    project = Kalibro::Project.new @hash
-    assert_equal @project.name, project.name
-    assert_equal @project.repository.type, project.repository.type
+  should 'get all projects when there is only one project' do
+    Kalibro::Project.expects(:request).with(:all_projects).returns({:project => @hash})
+    assert_equal @hash[:name], Kalibro::Project.all.first.name
   end
  
-  should 'convert project to hash' do
-    hash = @project.to_hash
-    assert_equal @hash[:name], hash[:name]
-    assert_equal @hash[:configuration_name], hash[:configuration_name]
-    assert_equal @hash[:repository], hash[:repository]
-    assert_equal @hash[:state], hash[:state]
+  should 'get all projects when there are many projects' do
+    Kalibro::Project.expects(:request).with(:all_projects).returns({:project => [@hash, @hash]})
+    projects = Kalibro::Project.all
+    assert_equal @hash[:name], projects.first.name
+    assert_equal @hash[:name], projects.last.name
   end
-  
-  should 'process project without days' do
-    Kalibro::Project.expects(:request).with('Kalibro', :process_project, {:project_name => @project.name})
-    @project.process_project
+
+  should 'return empty when there are no projects' do
+    Kalibro::Project.expects(:request).with(:all_projects).returns({:project => nil})
+    assert_equal [], Kalibro::Project.all
   end
  
-  should 'process project with days' do
-    Kalibro::Project.expects(:request).with('Kalibro', :process_periodically, {:project_name => @project.name, :period_in_days => "1"})
-    @project.process_project "1"
+  should 'return true when project is saved successfully' do
+    id_from_kalibro = 1
+    Kalibro::Project.expects(:request).with(:save_project, {:project => @created_project.to_hash}).returns(:project_id => id_from_kalibro)
+    assert @created_project.save
+    assert_equal id_from_kalibro, @created_project.id
   end
  
-  should 'process period' do
-    Kalibro::Project.expects(:request).with('Kalibro', :get_process_period,  {:project_name => @project.name}).returns({:period => "1"})
-    assert_equal "1", @project.process_period
+  should 'return false when project is not saved successfully' do
+    Kalibro::Project.expects(:request).with(:save_project, {:project => @created_project.to_hash}).raises(Exception.new)
+    assert !(@created_project.save)
+    assert_nil @created_project.id
   end
-  
-  should 'cancel periodic process' do
-    Kalibro::Project.expects(:request).with("Kalibro", :cancel_periodic_process, {:project_name => @project.name})
-    @project.cancel_periodic_process
+
+  should 'remove existent project from service' do
+    Kalibro::Project.expects(:request).with(:delete_project, {:project_id => @project.id})
+    @project.destroy
   end
  
 end
@@ -0,0 +1,32 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_snapshot_fixtures"
+
+class RangeSnapshotTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = RangeSnapshotFixtures.range_snapshot_hash
+    @range_snapshot_with_infinite_range_hash = RangeSnapshotFixtures.range_snapshot_with_infinite_range_hash
+    @range_snapshot = RangeSnapshotFixtures.range_snapshot
+    @range_snapshot_with_infinite_range = RangeSnapshotFixtures.range_snapshot_with_infinite_range
+  end
+
+  should 'create range_snapshot from hash' do
+    range_snapshot = Kalibro::RangeSnapshot.new(@hash)
+    assert_equal @hash[:comments], range_snapshot.comments
+    assert_equal @hash[:beginning].to_f, range_snapshot.beginning
+    assert_equal @hash[:end].to_f, range_snapshot.end
+    assert_equal @hash[:grade].to_f, range_snapshot.grade
+  end
+
+  should 'create range_snapshot from hash with infinity values' do
+    range_snapshot = Kalibro::RangeSnapshot.new(@range_snapshot_with_infinite_range_hash)
+    assert_equal -1.0/0, range_snapshot.beginning
+    assert_equal 1.0/0, range_snapshot.end
+  end
+
+  should 'convert range_snapshot to hash' do
+    assert_equal @hash, @range_snapshot.to_hash
+  end
+
+end
@@ -5,24 +5,43 @@ require &quot;#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_fixtures&quot;
 class RangeTest < ActiveSupport::TestCase
  
   def setup
-    @hash = RangeFixtures.range_bad_hash
-    @range = RangeFixtures.range_bad
+    @hash = RangeFixtures.range_hash
+    @range = RangeFixtures.range
+    @created_range = RangeFixtures.created_range
   end
  
   should 'create range from hash' do
-    assert_equal @hash[:label], Kalibro::Range.new(@hash).label
+    assert_equal @hash[:comments], Kalibro::Range.new(@hash).comments
   end
  
   should 'convert range to hash' do
     assert_equal @hash, @range.to_hash
   end
  
-	should 'create a default color for new range' do 
-		assert_equal "e4ca2d", Kalibro::Range.new.mezuro_color
-	end
-	
-	should "convert color from 'ff' to '#'" do
-		assert_equal "ff0000", @range.mezuro_color
-	end
+  should 'get ranges of a metric configuration' do
+    metric_configuration_id = 31
+    Kalibro::Range.expects(:request).with(:ranges_of, {:metric_configuration_id => metric_configuration_id}).returns({:range => [@hash]})
+    assert_equal @hash[:comments], Kalibro::Range.ranges_of(metric_configuration_id).first.comments
+  end
+  
+  should 'return true when range is saved successfully' do
+    id_from_kalibro = 1
+    metric_configuration_id = 2
+    Kalibro::Range.expects(:request).with(:save_range, {:range => @created_range.to_hash, :metric_configuration_id => metric_configuration_id}).returns(:range_id => id_from_kalibro)
+    assert @created_range.save(metric_configuration_id)
+    assert_equal id_from_kalibro, @created_range.id
+  end
+
+  should 'return false when range is not saved successfully' do
+    metric_configuration_id = 2
+    Kalibro::Range.expects(:request).with(:save_range, {:range => @created_range.to_hash, :metric_configuration_id => metric_configuration_id}).raises(Exception.new)
+    assert !(@created_range.save(metric_configuration_id))
+    assert_nil @created_range.id
+  end
+
+  should 'destroy range by id' do
+    Kalibro::Range.expects(:request).with(:delete_range, {:range_id => @range.id})
+    @range.destroy
+  end
  
 end
@@ -0,0 +1,78 @@
+require "test_helper"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_group_fixtures"
+
+class ReadingGroupTest < ActiveSupport::TestCase
+
+  def setup  
+    @hash = ReadingGroupFixtures.reading_group_hash
+    @reading_group = ReadingGroupFixtures.reading_group
+    @created_reading_group = ReadingGroupFixtures.created_reading_group
+  end
+
+  should 'create reading group from hash' do
+    assert_equal @hash[:name], Kalibro::ReadingGroup.new(@hash).name
+    assert_equal @hash[:id].to_i, Kalibro::ReadingGroup.new(@hash).id
+  end
+  
+  should 'convert reading group to hash' do
+    assert_equal @hash, @reading_group.to_hash
+  end
+  
+  should 'verify existence of reading group' do
+    fake_id = 0
+    Kalibro::ReadingGroup.expects(:request).with(:reading_group_exists, {:group_id => fake_id}).returns({:exists => false})
+    Kalibro::ReadingGroup.expects(:request).with(:reading_group_exists, {:group_id => @hash[:id].to_i}).returns({:exists => true})
+    assert !Kalibro::ReadingGroup.exists?(fake_id)
+    assert Kalibro::ReadingGroup.exists?(@hash[:id].to_i)
+  end
+  
+  should 'get reading group' do
+    Kalibro::ReadingGroup.expects(:request).with(:reading_group_exists, {:group_id => @hash[:id]}).returns({:exists => true})
+    Kalibro::ReadingGroup.expects(:request).with(:get_reading_group, {:group_id => @hash[:id]}).
+      returns({:reading_group => @hash})
+    assert_equal @hash[:name], Kalibro::ReadingGroup.find(@hash[:id]).name
+  end
+
+  should 'get all reading groups when there is only one reading group' do
+    Kalibro::ReadingGroup.expects(:request).with(:all_reading_groups).returns({:reading_group => @hash})
+    assert_equal @hash[:name], Kalibro::ReadingGroup.all.first.name
+  end
+  
+  should 'get all reading groups when there are many reading groups' do
+    Kalibro::ReadingGroup.expects(:request).with(:all_reading_groups).returns({:reading_group => [@hash, @hash]})
+    reading_groups = Kalibro::ReadingGroup.all
+    assert_equal @hash[:name], reading_groups.first.name
+    assert_equal @hash[:name], reading_groups.last.name
+  end
+
+  should 'return empty when there are no reading groups' do
+    Kalibro::ReadingGroup.expects(:request).with(:all_reading_groups).returns({:reading_group => nil})
+    assert_equal [], Kalibro::ReadingGroup.all
+  end
+  
+  should 'get reading group of a metric configuration' do
+    id = 31
+    Kalibro::ReadingGroup.expects(:request).with(:reading_group_of, {:metric_configuration_id => id}).returns({:reading_group => @hash})
+    assert_equal @hash[:name], Kalibro::ReadingGroup.reading_group_of(id).name
+  end
+
+  should 'return true when reading group is saved successfully' do
+    id_from_kalibro = 1
+    Kalibro::ReadingGroup.expects(:request).with(:save_reading_group, {:reading_group => @created_reading_group.to_hash}).returns(:reading_group_id => id_from_kalibro)
+    assert @created_reading_group.save
+    assert_equal id_from_kalibro, @created_reading_group.id
+  end
+
+  should 'return false when reading group is not saved successfully' do
+    Kalibro::ReadingGroup.expects(:request).with(:save_reading_group, {:reading_group => @created_reading_group.to_hash}).raises(Exception.new)
+    assert !(@created_reading_group.save)
+    assert_nil @created_reading_group.id
+  end
+
+  should 'destroy reading group by id' do
+    Kalibro::ReadingGroup.expects(:request).with(:delete_reading_group, {:group_id => @reading_group.id})
+    @reading_group.destroy
+  end
+  
+end
+
@@ -0,0 +1,61 @@
+require "test_helper"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_fixtures"
+
+class ReadingTest < ActiveSupport::TestCase
+
+  def setup  
+    @hash = ReadingFixtures.reading_hash
+    @reading = ReadingFixtures.reading
+    @created_reading = ReadingFixtures.created_reading
+  end
+
+  should 'create reading from hash' do
+    assert_equal @hash[:label], Kalibro::Reading.new(@hash).label
+    assert_equal @hash[:id].to_i, Kalibro::Reading.new(@hash).id
+    assert_equal @hash[:grade].to_f, Kalibro::Reading.new(@hash).grade
+  end
+  
+  should 'convert reading to hash' do
+    assert_equal @hash, @reading.to_hash
+  end
+  
+  should 'get reading' do
+    Kalibro::Reading.expects(:request).with(:get_reading, {:reading_id => @hash[:id]}).
+      returns({:reading => @hash})
+    assert_equal @hash[:label], Kalibro::Reading.find(@hash[:id]).label
+  end
+  
+  should 'get reading of a range' do
+    range_id = 31
+    Kalibro::Reading.expects(:request).with(:reading_of, {:range_id => range_id}).returns({:reading => @hash})
+    assert_equal @hash[:label], Kalibro::Reading.reading_of(range_id).label
+  end
+  
+  should 'get readings of a reading group' do
+    reading_group_id = 31
+    Kalibro::Reading.expects(:request).with(:readings_of, {:group_id => reading_group_id}).returns({:reading => [@hash]})
+    assert_equal @hash[:label], Kalibro::Reading.readings_of(reading_group_id).first.label
+  end
+
+  should 'return true when reading is saved successfully' do
+    reading_group_id = 31
+    id_from_kalibro = 1
+    Kalibro::Reading.expects(:request).with(:save_reading, {:group_id => reading_group_id, :reading => @created_reading.to_hash}).returns(:reading_id => id_from_kalibro)
+    assert @created_reading.save reading_group_id
+    assert_equal id_from_kalibro, @created_reading.id
+  end
+
+  should 'return false when reading is not saved successfully' do
+    reading_group_id = 31
+    Kalibro::Reading.expects(:request).with(:save_reading, {:group_id => reading_group_id, :reading => @created_reading.to_hash}).raises(Exception.new)
+    assert !(@created_reading.save reading_group_id)
+    assert_nil @created_reading.id
+  end
+
+  should 'destroy reading by id' do
+    Kalibro::Reading.expects(:request).with(:delete_reading, {:reading_id => @reading.id})
+    @reading.destroy
+  end
+  
+end
+
@@ -7,10 +7,15 @@ class RepositoryTest &lt; ActiveSupport::TestCase
   def setup
     @hash = RepositoryFixtures.repository_hash
     @repository = RepositoryFixtures.repository
+    @created_repository = RepositoryFixtures.created_repository
   end
  
   should 'new repository from hash' do
-    assert_equal @repository.type, Kalibro::Repository.new(@hash).type
+    repository = Kalibro::Repository.new(@hash)
+    assert_equal @hash[:type], repository.type
+    assert_equal @hash[:id].to_i, repository.id
+    assert_equal @hash[:process_period].to_i, repository.process_period
+    assert_equal @hash[:configuration_id].to_i, repository.configuration_id
   end
  
   should 'convert repository to hash' do
@@ -19,8 +24,50 @@ class RepositoryTest &lt; ActiveSupport::TestCase
  
   should 'get supported repository types' do
     types = ['BAZAAR', 'GIT', 'SUBVERSION']
-    Kalibro::Repository.expects(:request).with('Kalibro', :get_supported_repository_types).returns({:repository_type => types})
+    Kalibro::Repository.expects(:request).with(:supported_repository_types).returns({:supported_type => types})
     assert_equal types, Kalibro::Repository.repository_types
   end
  
+  should 'get repository of a precessing' do
+    id = 31
+    Kalibro::Repository.expects(:request).with(:repository_of, {:processing_id => id}).returns({:repository => @hash})
+    assert_equal @hash[:name], Kalibro::Repository.repository_of(id).name
+  end
+
+  should 'get repositories of a project' do
+    project_id = 31
+    Kalibro::Repository.expects(:request).with(:repositories_of, {:project_id => project_id}).returns({:repository => [@hash]})
+    assert_equal @hash[:name], Kalibro::Repository.repositories_of(project_id).first.name
+  end
+
+  should 'return true when repository is saved successfully' do
+    id_from_kalibro = 1
+    project_id = 56
+    Kalibro::Repository.expects(:request).with(:save_repository, {:repository => @created_repository.to_hash, :project_id => project_id}).returns(:repository_id => id_from_kalibro)
+    assert @created_repository.save(project_id)
+    assert_equal id_from_kalibro, @created_repository.id
+  end
+
+  should 'return false when repository is not saved successfully' do
+    project_id = 56
+    Kalibro::Repository.expects(:request).with(:save_repository, {:repository => @created_repository.to_hash, :project_id => project_id}).raises(Exception.new)
+    assert !(@created_repository.save(project_id))
+    assert_nil @created_repository.id
+  end
+
+  should 'destroy repository by id' do
+    Kalibro::Repository.expects(:request).with(:delete_repository, {:repository_id => @repository.id})
+    @repository.destroy
+  end
+
+  should 'process repository' do
+    Kalibro::Repository.expects(:request).with(:process_repository, {:repository_id => @repository.id});
+    @repository.process
+  end
+
+  should 'cancel processing of a repository' do
+    Kalibro::Repository.expects(:request).with(:cancel_processing_of_repository, {:repository_id => @repository.id});
+    @repository.cancel_processing_of_repository
+  end
+
 end
@@ -0,0 +1,20 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/throwable_fixtures"
+
+class ThrowableTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = ThrowableFixtures.throwable_hash
+    @throwable = ThrowableFixtures.throwable
+  end
+
+  should 'create throwable from hash' do
+    assert_equal @hash[:message], Kalibro::Throwable.new(@hash).message
+  end
+
+  should 'convert throwable to hash' do
+    assert_equal @hash, @throwable.to_hash
+  end
+
+end
 require "test_helper"
  
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_content_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_fixtures"
  
 class ConfigurationContentTest < ActiveSupport::TestCase
  
   def setup
     @configuration = ConfigurationFixtures.configuration
-    @content = ConfigurationFixtures.configuration_content("None")
+    @content = ConfigurationContentFixtures.configuration_content
+    @created_configuration = ConfigurationFixtures.created_configuration
+    @content_hash = ConfigurationContentFixtures.configuration_content_hash
+    @configuration_hash = {:name => @content_hash[:name], :description => @content_hash[:description], :id => @content_hash[:configuration_id]}
+    @created_content = ConfigurationContentFixtures.created_configuration_content
+
+    @metric_configuration = MetricConfigurationFixtures.amloc_metric_configuration
+    @range = RangeFixtures.range
   end
  
   should 'be an article' do
@@ -18,7 +28,7 @@ class ConfigurationContentTest &lt; ActiveSupport::TestCase
   end
  
   should 'provide proper description' do
-    assert_equal 'Sets of thresholds to interpret metrics', MezuroPlugin::ConfigurationContent.description
+    assert_equal 'Set of metric configurations to interpret a Kalibro project', MezuroPlugin::ConfigurationContent.description
   end
  
   should 'have an html view' do
@@ -26,52 +36,56 @@ class ConfigurationContentTest &lt; ActiveSupport::TestCase
   end
  
   should 'not save a configuration with an existing cofiguration name in kalibro' do
-    Kalibro::Configuration.expects(:all_names).returns([@content.name.upcase])
-    @content.send :validate_kalibro_configuration_name
+    Kalibro::Configuration.expects(:all).returns([@configuration])
+    @content.send :validate_configuration_name
     assert_equal "Configuration name already exists in Kalibro", @content.errors.on_base
   end
  
   should 'get configuration from service' do
-    Kalibro::Configuration.expects(:find_by_name).with(@content.name).returns(@configuration)
+    Kalibro::Configuration.expects(:find).with(@content.configuration_id).returns(@configuration)
     assert_equal @configuration, @content.kalibro_configuration
   end
  
   should 'send configuration to service after saving' do
-    @content.expects :send_kalibro_configuration_to_service
+    @content.expects :send_configuration_to_service
     @content.stubs(:solr_save)
-    @content.run_callbacks :after_save
+    @content.run_callbacks :before_save
   end
  
   should 'create new configuration' do
-    Kalibro::Configuration.expects(:create).with(:name => @content.name, :description => @content.description)
-    Kalibro::Configuration.expects(:find_by_name).with(@content.name)
-    @content.send :send_kalibro_configuration_to_service
+    Kalibro::Configuration.expects(:create).with(:name => @created_content.name, :description => @created_content.description, :id => nil).returns(@configuration)
+    @created_content.send :send_configuration_to_service
+    assert_equal @configuration.id, @created_content.configuration_id
   end
-  
+
   should 'clone configuration' do
-    @content.configuration_to_clone_name = 'clone name'
-    Kalibro::Configuration.expects(:create).with(:name => @content.name, :description => @content.description, :metric_configuration => @configuration.metric_configurations_hash)
-    Kalibro::Configuration.expects(:find_by_name).with(@content.name).returns(nil)
-    Kalibro::Configuration.expects(:find_by_name).with('clone name').returns(@configuration)
-    @content.send :send_kalibro_configuration_to_service
+    clone_id = @configuration.id
+    @content.configuration_to_clone_id = clone_id
+    Kalibro::Configuration.expects(:create).with(:id => @content.configuration_id, :name => @content.name, :description => @content.description).returns(@configuration)
+    Kalibro::MetricConfiguration.expects(:metric_configurations_of).with(@configuration.id).returns([@metric_configuration])
+    Kalibro::MetricConfiguration.expects(:request).returns(:metric_configuration_id => @metric_configuration.id)
+    Kalibro::Range.expects(:ranges_of).with(@metric_configuration.id).returns([@range])
+    @range.expects(:save).with(@metric_configuration.id).returns(true)
+    @content.send :send_configuration_to_service
   end
  
   should 'edit configuration' do
-    Kalibro::Configuration.expects(:find_by_name).with(@content.name).returns(@configuration)
-    @configuration.expects(:update_attributes).with(:description => @content.description)
-    @content.send :send_kalibro_configuration_to_service
+    Kalibro::Configuration.expects(:new).with(@configuration_hash).returns(@configuration)
+    @configuration.expects(:save).returns(true)
+    @content.send :send_configuration_to_service
+    assert_equal @configuration.id, @content.configuration_id
   end
  
   should 'send correct configuration to service but comunication fails' do
-    Kalibro::Configuration.expects(:find_by_name).with(@content.name).returns(@configuration)
-    @configuration.expects(:save).returns(false)
-    @content.send :send_kalibro_configuration_to_service
+    Kalibro::Configuration.expects(:new).with(@configuration_hash).returns(@created_configuration)
+    @created_configuration.expects(:save).returns(false)
+    @content.send :send_configuration_to_service
   end
  
   should 'remove configuration from service' do
-    Kalibro::Configuration.expects(:find_by_name).with(@content.name).returns(@configuration)
+    Kalibro::Configuration.expects(:find).with(@content.configuration_id).returns(@configuration)
     @configuration.expects(:destroy)
-    @content.send :remove_kalibro_configuration_from_service
+    @content.send :remove_configuration_from_service
   end
  
 end
 require "test_helper"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_snapshot_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/date_metric_result_fixtures"
  
 class ContentViewerHelperTest < ActiveSupport::TestCase
  
+  def setup
+    @helper = MezuroPlugin::Helpers::ContentViewerHelper
+  end
+
   should 'get the number rounded by two decimal points' do
-    assert_equal '4.22', MezuroPlugin::Helpers::ContentViewerHelper.format_grade('4.22344')
-    assert_equal '4.10', MezuroPlugin::Helpers::ContentViewerHelper.format_grade('4.1')
-    assert_equal '4.00', MezuroPlugin::Helpers::ContentViewerHelper.format_grade('4')
+    assert_equal '4.22', @helper.format_grade('4.22344')
+    assert_equal '4.10', @helper.format_grade('4.1')
+    assert_equal '4.00', @helper.format_grade('4')
   end
  
   should 'create the periodicity options array' do
-    assert_equal [["Not Periodically", 0], ["1 day", 1], ["2 days", 2], ["Weekly", 7], ["Biweeky", 15], ["Monthly", 30]], MezuroPlugin::Helpers::ContentViewerHelper.create_periodicity_options
+    assert_equal [["Not Periodically", 0], ["1 day", 1], ["2 days", 2], ["Weekly", 7], ["Biweekly", 15], ["Monthly", 30]], @helper.periodicity_options
+  end
+
+  should 'return the correct string for a given periodicity' do
+    assert_equal "Not Periodically", @helper.periodicity_option(0)
+    assert_equal "1 day", @helper.periodicity_option(1)
+    assert_equal "2 days", @helper.periodicity_option(2)
+    assert_equal "Weekly", @helper.periodicity_option(7)
+    assert_equal "Biweekly", @helper.periodicity_option(15)
+    assert_equal "Monthly", @helper.periodicity_option(30)
+  end
+
+  should 'create the license options array' do
+   options = YAML.load_file("#{RAILS_ROOT}/plugins/mezuro/licenses.yml")
+   options = options.split(";")
+   assert_equal options, @helper.license_options
   end
  
-  should 'format metric name for module result' do
-    metric_result = MetricResultFixtures.native_metric_result
-    assert_equal 'AverageMethodLOC', MezuroPlugin::Helpers::ContentViewerHelper.format_name(metric_result)
+  should 'generate chart from metric result history' do
+    chart = "http://chart.apis.google.com/chart?chxt=y,x&chco=c4a000&chf=bg,ls,90,efefef,0.2,ffffff,0.2&chd=s:A9&chl=2011-10-20T18%3A26%3A43%2B00%3A00|2011-10-25T18%3A26%3A43%2B00%3A00&cht=lc&chs=600x180&chxr=0,0.0,5.0"
+    metric_history = DateMetricResultFixtures.score_history
+
+    assert_equal chart, @helper.generate_chart(metric_history)
+  end
+
+  should 'format time to show a sentence' do
+    assert_equal 'less than 5 seconds', @helper.format_time(0)
+    assert_equal 'less than 5 seconds', @helper.format_time(4999)
+    assert_equal 'less than 10 seconds', @helper.format_time(5000)
+    assert_equal '1 minute', @helper.format_time(70000)
+    assert_equal 'about 2 hours', @helper.format_time(7000000)
+  end
+
+  should 'format metric name for metric configuration snapshot' do
+    metric_configuration_snapshot = MetricConfigurationSnapshotFixtures.metric_configuration_snapshot
+    assert_equal 'AverageMethodLOC', @helper.format_name(metric_configuration_snapshot)
+  end
+
+  should 'create aggregation options array' do
+    assert_equal [["Average","AVERAGE"], ["Median", "MEDIAN"], ["Maximum", "MAXIMUM"], ["Minimum", "MINIMUM"], 
+    ["Count", "COUNT"], ["Standard Deviation", "STANDARD_DEVIATION"]], @helper.aggregation_options
+  end
+
+  should 'create scope options' do
+    assert_equal [["Software", "SOFTWARE"], ["Package", "PACKAGE"], ["Class", "CLASS"], ["Method", "METHOD"]], @helper.scope_options
   end
+
 end
@@ -0,0 +1,15 @@
+require "test_helper"
+
+class ModuleResultHelperTest < ActiveSupport::TestCase
+
+  should 'return last module name when receive a string' do
+    name = 'Class'
+    assert_equal name, MezuroPlugin::Helpers::ModuleResultHelper.module_name(name)
+  end
+
+  should 'return last module name when receive an array of strings' do
+    name = ['Class', 'Module']
+    assert_equal name.last, MezuroPlugin::Helpers::ModuleResultHelper.module_name(name)
+  end
+
+end
 require "test_helper"
  
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_fixtures"
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_content_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/processing_fixtures"
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_fixtures"
 require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/date_metric_result_fixtures"
  
 class ProjectContentTest < ActiveSupport::TestCase
  
   def setup
+    @project_content = ProjectContentFixtures.project_content
     @project = ProjectFixtures.project
-    @content = ProjectFixtures.project_content
-    @project_result = ProjectResultFixtures.project_result
+    @repository = RepositoryFixtures.repository
+    @processing = ProcessingFixtures.processing
+    @date = @processing.date
     @module = ModuleFixtures.module
     @module_result = ModuleResultFixtures.module_result
+    @date_metric_result = DateMetricResultFixtures.date_metric_result
   end
  
   should 'provide proper short description' do
@@ -24,98 +29,31 @@ class ProjectContentTest &lt; ActiveSupport::TestCase
   end
  
   should 'have an html view' do
-    assert_not_nil @content.to_html
+    assert_not_nil @project_content.to_html
   end
  
   should 'get project from service' do
-    Kalibro::Project.expects(:request).with("Project", :get_project, :project_name => @project.name).returns({:project => @project.to_hash})
-    assert_equal @project.name, @content.project.name
+    Kalibro::Project.expects(:find).with(@project.id).returns(@project)
+    assert_equal @project, @project_content.project
   end
  
-  should 'get project result from service' do
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_last_result_of, {:project_name => @project.name}).returns({:project_result => @project_result.to_hash})
-    assert_equal @project_result.load_time, @content.project_result.load_time
-  end
-  
-  should 'get date result from service when has_result_before is true' do
-    request_body = {:project_name => @project.name, :date => @project_result.date}
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :has_results_before, request_body).returns({:has_results => true})
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_last_result_before, request_body).returns({:project_result => @project_result.to_hash})
-    assert_equal @project_result.load_time, @content.project_result_with_date(@project_result.date).load_time
-  end
-
-  should 'get date result from service when has_result_before is false' do
-    request_body = {:project_name => @project.name, :date => @project_result.date}
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :has_results_before, request_body).returns({:has_results => false})
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_first_result_after, request_body).returns({:project_result => @project_result.to_hash})
-    assert_equal @project_result.load_time, @content.project_result_with_date(@project_result.date).load_time
-  end
-
-  should 'get module result from service without date' do
-    date_with_milliseconds = Kalibro::ProjectResult.date_with_milliseconds(@project_result.date)
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult', :get_last_result_of, {:project_name => @project.name}).returns({:project_result => @project_result.to_hash})
-    Kalibro::ModuleResult.expects(:request).with(
-      'ModuleResult',
-      :get_module_result,
-      {
-        :project_name => @project.name, 
-        :module_name => @module.name,
-        :date => date_with_milliseconds
-      }).returns({:module_result => @module_result.to_hash})
-    assert_equal @module_result.grade, @content.module_result({:module_name => @module.name}).grade
-  end
-
-  should 'get module result from service with date' do
-    date_with_milliseconds = Kalibro::ProjectResult.date_with_milliseconds(@project_result.date)
-    request_body = {:project_name => @project.name, :date => @project_result.date}
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :has_results_before, request_body).returns({:has_results => false})
-    Kalibro::ProjectResult.expects(:request).with("ProjectResult", :get_first_result_after, request_body).returns({:project_result => @project_result.to_hash})
-    Kalibro::ModuleResult.expects(:request).with(
-      'ModuleResult',
-      :get_module_result,
-      {
-        :project_name => @project.name, 
-        :module_name => @module.name,
-        :date => date_with_milliseconds
-      }).returns({:module_result => @module_result.to_hash})
-    assert_equal @module_result.grade, @content.module_result({:module_name => @module.name, :date => @project_result.date}).grade
+  should 'add error to base when the project does not exist' do
+    Kalibro::Project.expects(:find).with(@project.id).raises(Kalibro::Errors::RecordNotFound)
+    assert_nil @project_content.errors[:base]
+    @project_content.project
+    assert_not_nil @project_content.errors[:base]
   end
  
-  should 'get result history' do
-    Kalibro::ModuleResult.expects(:request).with(
-    'ModuleResult',
-    :get_result_history,
-      {
-        :project_name => @project.name, 
-        :module_name => @module.name
-      }).returns({:module_result => @module_result.to_hash})
-  	@content.result_history(@module.name)
+  should 'get repositories of the project from service' do
+    Kalibro::Repository.expects(:repositories_of).with(@project.id).returns([@repository])
+    assert_equal [@repository], @project_content.repositories
   end
-
-  should 'send project to service after saving' do
-    @content.expects :send_project_to_service
-    @content.run_callbacks :after_save
-  end
-
-  should 'send correct project to service' do
-    hash = ProjectFixtures.project_hash
-    hash.delete(:attributes!)
-    hash.delete(:state)
-    Kalibro::Project.expects(:create).with(hash).returns(@project)
-    @project.expects(:process_project).with(@content.periodicity_in_days)
-    @content.send :send_project_to_service
+  
+  should 'add error to base when getting the repositories of a project that does not exist' do
+    Kalibro::Repository.expects(:repositories_of).with(@project.id).raises(Kalibro::Errors::RecordNotFound)
+    assert_nil @project_content.errors[:base]
+    @project_content.repositories
+    assert_not_nil @project_content.errors[:base]
   end
  
-  should 'destroy project from service' do
-    Kalibro::Project.expects(:request).with("Project", :get_project, :project_name => @project.name).returns({:project => @project.to_hash})
-    Kalibro::Project.expects(:request).with("Project", :remove_project, {:project_name => @project.name})
-    @content.send :destroy_project_from_service
-  end
-  
-  should 'not save a project with an existing project name in kalibro' do
- 		Kalibro::Project.expects(:all_names).returns([@content.name])
-		@content.send :validate_kalibro_project_name
-		assert_equal "Project name already exists in Kalibro", @content.errors.on_base
-	end
-  
 end
@@ -0,0 +1,51 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_group_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/reading_group_content_fixtures"
+
+class ReadingGroupContentTest < ActiveSupport::TestCase
+
+  def setup
+    @reading_group_content = ReadingGroupContentFixtures.reading_group_content
+    @reading_group = ReadingGroupFixtures.reading_group
+    @reading = ReadingFixtures.reading
+  end
+
+  should 'provide proper short description' do
+    assert_equal 'Mezuro reading group', MezuroPlugin::ReadingGroupContent.short_description
+  end
+
+  should 'provide proper description' do
+    assert_equal 'Set of thresholds to interpret metric results', MezuroPlugin::ReadingGroupContent.description
+  end
+
+  should 'have an html view' do
+    assert_not_nil @reading_group_content.to_html
+  end
+
+  should 'get reading_group from service' do
+    Kalibro::ReadingGroup.expects(:find).with(@reading_group.id).returns(@reading_group)
+    assert_equal @reading_group, @reading_group_content.reading_group
+  end
+
+  should 'add error to base when the reading_group does not exist' do
+    Kalibro::ReadingGroup.expects(:find).with(@reading_group.id).raises(Kalibro::Errors::RecordNotFound)
+    assert_nil @reading_group_content.errors[:base]
+    @reading_group_content.reading_group
+    assert_not_nil @reading_group_content.errors[:base]
+  end
+
+  should 'get readings of the reading_group from service' do
+    Kalibro::Reading.expects(:readings_of).with(@reading_group.id).returns([@reading])
+    assert_equal [@reading], @reading_group_content.readings
+  end
+  
+  should 'add error to base when getting the readings of a reading_group that does not exist' do
+    Kalibro::Reading.expects(:readings_of).with(@reading_group.id).raises(Kalibro::Errors::RecordNotFound)
+    assert_nil @reading_group_content.errors[:base]
+    @reading_group_content.readings
+    assert_not_nil @reading_group_content.errors[:base]
+  end
+
+end
@@ -2,27 +2,18 @@
  
 <%
   kalibro_configuration = @article.title.nil? ? nil : @article.kalibro_configuration
-  kalibro_configuration_names = @article.kalibro_configuration_names
+  configuration_names_and_ids = @article.configuration_names_and_ids
 %>
  
 <%= error_messages_for 'kalibro_configuration' %>
  
-<%= hidden_field_tag 'kalibro_configuration[profile_id]', profile.id %>
-<%= hidden_field_tag 'id', @article.id %>
  
- 
-<% selected = (kalibro_configuration.nil? ? "None" : @article.configuration_to_clone_name) %>
+<%= hidden_field_tag 'configuration_content[profile_id]', profile.id %>
+<%= hidden_field_tag 'configuration_id', @article.configuration_id %>
+<%= render :partial => "cms/mezuro_plugin/mezuro_content_form", :locals => {:f => f} %>
  
-<%= required_fields_message %>
-
-<%= required labelled_form_field _('Clone Configuration'),
-if !kalibro_configuration.nil? && !@article.id.nil?
-  f.select(:configuration_to_clone_name, kalibro_configuration_names, {:selected => selected}, :disabled => 'true')
-else
-  f.select(:configuration_to_clone_name, kalibro_configuration_names, {:selected => selected})
-end %>
 <br/>
-
-<%= required f.text_field(:name, :disabled => !(kalibro_configuration.nil? || @article.id.nil?)) %>
-
-<%= f.text_field :description %><br/>
+<%= if kalibro_configuration.nil?
+  required labelled_form_field _('Clone Configuration'),
+  f.select(:configuration_to_clone_id, configuration_names_and_ids)
+end %>
@@ -0,0 +1,4 @@
+<%= hidden_field_tag 'id', @article.id %>
+<%= required_fields_message %>
+<%= required f.text_field(:name) %>
+<%= f.text_field :description %><br/>
@@ -2,50 +2,10 @@
  
 <%
   @project = @article.title.nil? ? nil : @article.project
-  begin
-    @repository_types = Kalibro::Repository.repository_types.sort
-    @configuration_names = Kalibro::Configuration.all_names.sort
-  rescue Exception => exception
-    @article.errors.add_to_base(exception.message)
-    @repository_types = []
-    @configuration_names = []
-  end
 %>
  
 <%= error_messages_for 'project_content' %>
  
 <%= hidden_field_tag 'project_content[profile_id]', profile.id %>
-<%= hidden_field_tag 'id', @article.id %>
-
-<%= required_fields_message %>
-<% if !@project.nil? && !@article.id.nil? %>
-  <%= required f.text_field(:name, :disabled => 'true') %>
-<% else %>
-  <%= required f.text_field(:name) %>
-<% end %>
-
-<% selected = (@project.nil? ? "" : @project.license) %>
-<%= required labelled_form_field _('License'),
-  f.select(:project_license, MezuroPlugin::Helpers::ContentViewerHelper.create_license_options ,{:selected => selected}) %><br/>
-
-<%= f.text_field :description %><br/>
-
-<% @selected = (@project.nil? ? @repository_types : @project.repository.type) %>
-<%= required labelled_form_field _('Repository type'),
-  f.select(:repository_type, @repository_types, {:selected => @selected}) %><br/>
-
-<%= required f.text_field(:repository_url) %><br/>
-
-<% @selected = (@project.nil? ? @configuration_names[0] : @project.configuration_name) %>
-
-<% if !@project.nil? && !@article.id.nil? %>
-  <%= required labelled_form_field _('Configuration') + " (Changing the configuration will erase your saved periodic avaliations)",
-    f.select(:configuration_name, @configuration_names, {:selected => @selected}) %>
-<% else %>
-  <%= required labelled_form_field _('Configuration'),
-    f.select(:configuration_name, @configuration_names, {:selected => @selected}) %><br/>
-<% end %>
-
-<% selected = (@project.nil? ? 0 : @project.process_period.to_i) %>
-<%= required labelled_form_field _('Periodic Avaliation'),
-  f.select(:periodicity_in_days, MezuroPlugin::Helpers::ContentViewerHelper.create_periodicity_options ,{:selected => selected}) %><br/>
+<%= hidden_field_tag 'project_id', @article.project_id %>
+<%= render :partial => "cms/mezuro_plugin/mezuro_content_form", :locals => {:f => f} %>
@@ -0,0 +1,11 @@
+<h1> <%= _(MezuroPlugin::ReadingGroupContent.short_description) %> </h1>
+
+<%
+  reading_group = @article.title.nil? ? nil : @article.reading_group
+%>
+
+<%= error_messages_for 'reading_group_content' %>
+
+<%= hidden_field_tag 'reading_group_content[profile_id]', profile.id %>
+<%= hidden_field_tag 'reading_group_id', (reading_group.id unless reading_group.nil?) %>
+<%= render :partial => "cms/mezuro_plugin/mezuro_content_form", :locals => {:f => f} %>
@@ -1,41 +0,0 @@
-<% form_for :metric_configuration, :url => {:action =>"update_metric_configuration", :controller => "mezuro_plugin_metric_configuration"}, :method => :get do |f| %>
-  <%= hidden_field_tag :id, @configuration_content.id %>
-  <%= f.hidden_field :configuration_name, :value => @configuration_content.name %>
-  
-  <% f.fields_for :metric do |m| %>
-  
-    <% @metric.language.each do |language| %>
-      <%= m.hidden_field :language, :multiple => true, :value => language %>
-    <% end %>
-    
-    <%= m.hidden_field "scope", :value => @metric.scope %>
-    <p>
-      <b><%= m.label :origin, "Collector Name:" %></b>
-      <%= @metric.origin %>
-      <%= m.hidden_field "origin", :value => @metric.origin %>
-    </p>
-    <p>
-      <b><%= m.label :metric_name, "Metric Name:" %></b>
-      <%= @metric.name %>
-      <%= m.hidden_field "name", :value => @metric.name %>
-    </p>
-  <% end %>
-  <p>
-    <b><%= f.label :code, "Code:" %></b>
-    <%= @metric_configuration.code %>
-    <%= f.hidden_field "code", :value => @metric_configuration.code %>
-  </p>
-  <p>
-    <b><%= f.label :aggregation_form, "Aggregation Form:" %></b>
-    <%= f.select :aggregation_form, [["Average","AVERAGE"], ["Median", "MEDIAN"], ["Maximum", "MAXIMUM"], ["Minimum", "MINIMUM"], 
-    ["Count", "COUNT"], ["Standard Deviation", "STANDARD_DEVIATION"]] %>
-  </p>
-  <p>
-    <b><%= f.label :weight, "Weight:" %></b>
-    <%= f.text_field "weight", :value => @metric_configuration.weight %>
-  </p>
-
-  <p>
-    <%= f.submit "Save" %>
-  </p>
-<% end %>
@@ -1,15 +0,0 @@
-<p> 
-  <b>Collector Name:</b> <%= @metric.origin %>
-</p>
-<p> 
-  <b>Metric Name:</b> <%= @metric.name %>
-</p>
-<p>
-  <b>Code:</b> <%= @metric_configuration.code %>
-</p>
-<p>
-  <b>Aggregation Form:</b> <%= @metric_configuration.aggregation_form %>
-</p>
-<p>
- <b>Weight:</b> <%= @metric_configuration.weight %>
-</p>
 <% @configuration_content = @page
 @kalibro_configuration = @page.kalibro_configuration %>
+<!-- #TODO check owner verification to remove or edit metric configuration -->
 <% owner = (not user.nil?) && user.id == @profile.id %>
-
 <% unless @page.errors[:base].nil? %>
-  <% if @page.errors[:base] =~ /There is no configuration named/ %>
+  <% if @page.errors[:base] =~ /Kalibro::Errors::RecordNotFound/ %>
     <h3>Warning:</h3>
     <p>This Configuration doesn't exist on the Web Service.</p>
     <% if owner %>
@@ -28,7 +28,7 @@
   <br/>
  
   <% if owner %>
-    <%= link_to "#{image_tag ('/plugins/mezuro/images/plus.png')}Add Metric", :controller => "mezuro_plugin_base_tool", 
+    <%= link_to "#{image_tag ('/plugins/mezuro/images/plus.png')}Add Metric", :controller => "mezuro_plugin_metric_configuration", 
   																			:profile => @page.profile.identifier, 
   																			:action => "choose_metric", 
   																			:id => @configuration_content.id %><br/>
@@ -39,30 +39,36 @@
         <td><h5>Metric Name</h5></td>
         <td><h5>Collector Name</h5></td>
         <td><h5>Metric Code</h5></td>
+        <td><h5>Weight</h5></td>
+        <td><h5>Aggregation Form</h5></td>
         <td/>
     </tr>
-    <% @kalibro_configuration.metric_configurations.each do |metric_configuration| %>
+    <% @configuration_content.metric_configurations.each do |metric_configuration| %>
       <tr class="metric">
-        <% if metric_configuration.metric.instance_of? Kalibro::NativeMetric %>
-        <td><%= link_to metric_configuration.metric.name, :controller => "mezuro_plugin_metric_configuration", :action => "edit_metric_configuration", 
-          						  :metric_name => metric_configuration.metric.name, :id => @configuration_content.id, 
+        <% if metric_configuration.metric.compound
+             edit_action = "edit_compound"
+           else
+             edit_action = "edit_native"
+           end
+        %>
+        <td><%= link_to metric_configuration.metric.name, :controller => "mezuro_plugin_metric_configuration", :action => edit_action, 
+          						  :metric_configuration_id => metric_configuration.id, :id => @configuration_content.id, 
           						  :profile => @page.profile.identifier %></td>
+        <% if metric_configuration.metric.compound %>
           <td>
-            <%= metric_configuration.metric.origin %>
+            Compound Metric
           </td>
-          <td><%= metric_configuration.code %></td>
         <% else %>
-          <td><%= link_to metric_configuration.metric.name, :controller => "mezuro_plugin_metric_configuration", 
-          						  :action => "edit_compound_metric_configuration", :metric_name => metric_configuration.metric.name, 
-          						  :id => @configuration_content.id, :profile => @page.profile.identifier %></td>
           <td>
-            Compound Metric
+            <%= metric_configuration.base_tool_name %>
           </td>
-          <td><%= metric_configuration.code %></td>
         <% end %>
+        <td><%= metric_configuration.code %></td>
+        <td><%= metric_configuration.weight %></td>
+        <td><%= metric_configuration.aggregation_form %></td>
         <% if owner %>
-          <td><%= link_to "Remove", :controller => "mezuro_plugin_metric_configuration", :action => "remove_metric_configuration", 
-        						  :metric_name => metric_configuration.metric.name, :id => @configuration_content.id, 
+          <td><%= link_to "Remove", :controller => "mezuro_plugin_metric_configuration", :action => "remove", 
+        						  :metric_configuration_id => metric_configuration.id, :id => @configuration_content.id, 
         						  :profile => @page.profile.identifier %></td>
         <% end %>
       </tr>
-<script src="/plugins/mezuro/javascripts/project_content.js" type="text/javascript"></script>
-
 <% @project = @page.project %>
 <% unless @page.errors[:base].nil? %>
-  <% if @page.errors[:base] =~ /There is no project named/ %>
+<!-- #TODO add owner verification to remove or edit repository -->
+  <% if @page.errors[:base] == "Kalibro::Errors::RecordNotFound" %>
     <h3>Warning:</h3>
     <p>This project doesn't exist on the Web Service. Do you want to <%= link_to 'delete', :action => 'destroy', :controller => 'cms', :profile => @page.profile.identifier, :id => @page.id %> or <%= link_to 'save it again', :action => 'edit', :controller => 'cms', :profile => @page.profile.identifier, :id => @page.id %>?</p>
   <% else %>
@@ -16,44 +15,38 @@
       <td><%= @project.name %></td>
     </tr>
     <tr>
-      <td><%= _('License') %></td>
-      <td><%= @project.license %></td>
-    </tr>
-    <tr>
       <td><%= _('Description') %></td>
       <td><%= @project.description %></td>
     </tr>
+  </table>
+  <br/>
+  <h5><%= _('Repositories') %></h5>
+  <table>
+  <% @page.repositories.each do |repository| %>
     <tr>
-      <td><%= _('Repository type') %></td>
-      <td><%= @project.repository.type %></td>
-    </tr>
-    <tr>
-      <td><%= _('Repository address') %></td>
-      <td><%= @project.repository.address %></td>
-    </tr>
-    <tr>
-      <td><%= _('Configuration') %></td>
-      <td><%= @project.configuration_name %></td>
-    </tr>
-    <tr> 
-      <td><%= _('Periodicity') %></td>
-      <td><%= MezuroPlugin::Helpers::ContentViewerHelper.get_periodicity_option(@page.periodicity_in_days) %></td>
-    </tr>
-    <tr>
-      <td><%= _('Status')%></td>
-      <td>
-        <div id="project-state" style="color:DarkGoldenRod"><%= @project.state %></div>
-        <div id="msg-time"></div> 
-      </td>
-    </tr>
+      <td><%= link_to repository.name, :controller => "mezuro_plugin_repository", 
+  																			:profile => @page.profile.identifier, 
+  																			:action => "show", 
+  																			:id => @page.id,
+  																			:repository_id => repository.id %></td>
+  		<td ><%= link_to _('Edit'), {:controller => "mezuro_plugin_repository", 
+  																			:profile => @page.profile.identifier, 
+  																			:action => "edit", 
+  																			:id => @page.id,
+  																			:repository_id => repository.id}, :class=>"button with-text icon-edit" %></td>
+  		<td ><%= link_to _('Remove'), {:controller => "mezuro_plugin_repository", 
+  																			:profile => @page.profile.identifier, 
+  																			:action => "destroy", 
+  																			:id => @page.id,
+  																			:repository_id => repository.id}, :class=>"button with-text icon-delete" %></td>
+  	</tr>
+  <% end %>
   </table>
+  
+  <br>
+  <%= link_to "#{image_tag('/plugins/mezuro/images/plus.png')}Add Repository", :controller => "mezuro_plugin_repository", 
+  																			:profile => @page.profile.identifier, 
+  																			:action => "new", 
+  																			:id => @page.id %><br/>
  
-  <br />
-
-  <div id="project-result" data-profile="<%= @page.profile.identifier %>" data-content="<%= @page.id %>"
-       data-project-name="<%= @project.name %>">
-  </div>
-  <div id="project-tree"></div>
-  <div id="module-result">
-  </div>
 <% end %>
@@ -0,0 +1,49 @@
+<% @reading_group = @page.reading_group %>
+<!-- #TODO add owner verification to remove or edit reading group -->
+<% unless @page.errors[:base].nil? %>
+  <% if @page.errors[:base] == "Kalibro::Errors::RecordNotFound" %>
+    <h3>Warning:</h3>
+    <p>This reading group doesn't exist on the Web Service. Do you want to <%= link_to 'delete', :action => 'destroy', :controller => 'cms', :profile => @page.profile.identifier, :id => @page.id %> or <%= link_to 'save it again', :action => 'edit', :controller => 'cms', :profile => @page.profile.identifier, :id => @page.id %>?</p>
+  <% else %>
+    <%= @page.errors[:base] %>
+  <% end %>
+<% else %>
+
+  <table>
+    <tr>
+      <td><%= _('Name') %></td>
+      <td><%= @reading_group.name %></td>
+    </tr>
+    <tr>
+      <td><%= _('Description') %></td>
+      <td><%= @reading_group.description %></td>
+    </tr>
+  </table>
+  <br/>
+  <h5><%= _('Readings') %></h5>
+  <table>
+  <% @page.readings.each do |reading| %>
+    <tr>
+      <td><%= link_to reading.label, :controller => "mezuro_plugin_reading", 
+  																			:profile => @page.profile.identifier, 
+  																			:action => "edit", 
+  																			:id => @page.id,
+  																			:reading_id => reading.id %></td>
+  		<td><%= reading.grade %></td>
+  		<td bgcolor="#<%= reading.color %>"></td>
+  		<td ><%= link_to _('Remove'), {:controller => "mezuro_plugin_reading", 
+  																			:profile => @page.profile.identifier, 
+  																			:action => "destroy", 
+  																			:id => @page.id,
+  																			:reading_id => reading.id}, :class=>"button with-text icon-delete" %></td>
+  	</tr>
+  <% end %>
+  </table>
+  
+  <br/>
+  <%= link_to "#{image_tag ('/plugins/mezuro/images/plus.png')}Add Reading", :controller => "mezuro_plugin_reading", 
+  																			:profile => @page.profile.identifier, 
+  																			:action => "new", 
+  																			:id => @page.id %><br/>
+
+<% end %>
@@ -1,2 +0,0 @@
-<h2> An error occured: </h2>
-<%= @message %>
@@ -1,18 +0,0 @@
-<h2><%= @configuration_content.name%> Configuration</h2>
-
-<%= link_to "New Compound Metric", :controller => "mezuro_plugin_metric_configuration", :action => "new_compound_metric_configuration",
-								   :id => @configuration_content.id %>
-
-<h5>Base Tools:</h5>
-<% @base_tools.each do |base_tool| %>
-  <h4><%= link_to base_tool.name, "#",  :onclick => "jQuery(\"\##{base_tool.name}\").toggle();"%></h4>
-  <hr/>
-
-  <div id="<%=base_tool.name%>" style="display:none">
-    <% base_tool.supported_metrics.each do |metric| %>
-      &nbsp&nbsp&nbsp&nbsp&nbsp&nbsp<%= link_to metric.name, :controller => "mezuro_plugin_metric_configuration", :action => "new_metric_configuration",
-      				:metric_name => metric.name, :base_tool => base_tool.name, :id => @configuration_content.id %>
-      <hr size="1" width="93%"/>
-    <% end %>
-  </div>
-<% end %>
@@ -0,0 +1,19 @@
+<%= hidden_field_tag :id, @configuration_content.id %>
+<%= f.hidden_field :configuration_id, :value => @configuration_content.configuration_id %>
+
+<% f.fields_for :metric do |m| %>
+  <%= m.hidden_field :compound, :value => "true" %>
+  <%= required labelled_form_field _('Metric Name:'), m.text_field(:name, :value => @metric_configuration.metric.name) %>
+  <%= labelled_form_field _('Description:'), m.text_field(:description, :value => @metric_configuration.metric.description) %>
+  <%= required labelled_form_field _('Script:'), m.text_area(:script, :rows => 5, :value => @metric_configuration.metric.script) %>
+  <%= required labelled_form_field _('Scope:'), 
+        m.select(:scope, MezuroPlugin::Helpers::ContentViewerHelper.scope_options, :selected => @metric_configuration.metric.scope) %>
+<% end %>
+
+<%= required labelled_form_field _('Code:'), f.text_field(:code) %>
+<%= required labelled_form_field _('Aggregation Form:'),
+    f.select(:aggregation_form, MezuroPlugin::Helpers::ContentViewerHelper.aggregation_options) %>
+<%= required labelled_form_field _('Weight:'), f.text_field(:weight) %>
+<%= required labelled_form_field _('Reading Group:'), f.select(:reading_group_id, @reading_group_names_and_ids) %>
+
+<p><%= f.submit "Save" %></p>
@@ -0,0 +1,26 @@
+<%= hidden_field_tag :id, @configuration_content.id %>
+<%= f.hidden_field :configuration_id, :value => @configuration_content.configuration_id %>
+
+<%= labelled_form_field _('Collector Name:'), f.text_field(:base_tool_name, :readonly => true) %>
+
+<% f.fields_for :metric do |m| %>
+  <%= m.hidden_field :compound, :value => "false" %>
+  <% @metric_configuration.metric.language.each do |language| %>
+    <%= m.hidden_field :language, :multiple => true, :value => language %>
+  <% end %>
+  <%= m.hidden_field "scope", :value => @metric.scope %>
+  <%= required labelled_form_field _('Metric Name:'), m.text_field(:name, :readonly => true, :value => @metric.name) %>
+  <%= labelled_form_field _('Description:'), m.text_field(:description, :readonly => true, :value => @metric.description) %>
+<% end %>
+
+<%= required labelled_form_field _('Code:'), f.text_field(:code) %>
+
+<%= required labelled_form_field _('Aggregation Form:'),
+f.select(:aggregation_form, MezuroPlugin::Helpers::ContentViewerHelper.aggregation_options) %>
+
+<%= required labelled_form_field _('Weight:'), f.text_field(:weight) %>
+
+<%= required labelled_form_field _('Reading Group:'),
+f.select(:reading_group_id, @reading_group_names_and_ids) %>
+
+<p><%= f.submit "Save" %></p>
@@ -0,0 +1,15 @@
+<p> 
+  <b>Collector Name:</b> <%= @metric_configuration.base_tool_name %>
+</p>
+<p> 
+  <b>Metric Name:</b> <%= @metric.name %>
+</p>
+<p>
+  <b>Code:</b> <%= @metric_configuration.code %>
+</p>
+<p>
+  <b>Aggregation Form:</b> <%= @metric_configuration.aggregation_form %>
+</p>
+<p>
+ <b>Weight:</b> <%= @metric_configuration.weight %>
+</p>
@@ -0,0 +1,18 @@
+<h2><%= link_to("#{@configuration_content.name} Configuration", @configuration_content.view_url) %></h2>
+
+<%= link_to "New Compound Metric", :controller => "mezuro_plugin_metric_configuration", :action => "new_compound",
+								   :id => @configuration_content.id %>
+
+<h5>Base Tools:</h5>
+<% @base_tools.each do |base_tool| %>
+  <h4><%= link_to base_tool.name, "#",  :onclick => "jQuery(\"\##{base_tool.name}\").toggle();"%></h4>
+  <hr/>
+
+  <div id="<%=base_tool.name%>" style="display:none">
+    <% base_tool.supported_metrics.each do |metric| %>
+      &nbsp&nbsp&nbsp&nbsp&nbsp&nbsp<%= link_to metric.name, :controller => "mezuro_plugin_metric_configuration", :action => "new_native",
+      				:metric_name => metric.name, :base_tool_name => base_tool.name, :id => @configuration_content.id %>
+      <hr size="1" width="93%"/>
+    <% end %>
+  </div>
+<% end %>
@@ -0,0 +1,16 @@
+<script src="/plugins/mezuro/javascripts/validations.js" type="text/javascript"></script>
+<script src="/javascripts/colorpicker.js" type="text/javascript"></script>
+<script src="/javascripts/colorpicker-noosfero.js" type="text/javascript"></script>
+
+<h2><%= link_to("#{@configuration_content.name} Configuration", @configuration_content.view_url) %></h2>
+
+<% owner = (not user.nil?) && user.id == @profile.id %>
+
+<% form_for :metric_configuration, :url => {:action =>"update", :controller => "mezuro_plugin_metric_configuration"}, :method => :get do |f| %>
+  <%= f.hidden_field :id %>
+  <%= render :partial => "compound_metric_configuration_form", :locals => {:f => f} %>
+<% end %>
+
+<%= render :partial => "mezuro_plugin_range/ranges", :locals => {:owner => owner} %>
+<hr>
+<%= render :partial => "metric_codes", :locals => {:metric_configurations => @metric_configurations} %>
@@ -1,81 +0,0 @@
-<script src="/plugins/mezuro/javascripts/validations.js" type="text/javascript"></script>
-<script src="/javascripts/colorpicker.js" type="text/javascript"></script>
-<script src="/javascripts/colorpicker-noosfero.js" type="text/javascript"></script>
-
-<h2><%= @configuration_content.name %> Configuration</h2>
-
-<% form_for :metric_configuration, :url => {:action =>"update_compound_metric_configuration", :controller => "mezuro_plugin_metric_configuration"}, :method => :get do |f| %>
-  <%= hidden_field_tag :id, @configuration_content.id %>
-  <%= f.hidden_field :configuration_name, :value => @configuration_content.name %>
-
-  <p>
-    <%= "Metric Name:" + @metric.name %>   
-  </p>  
-  <% f.fields_for :metric do |m| %>
-    <%= m.hidden_field :name, :value => @metric.name %>
-    <p>
-      <%= m.label :description, "Description:" %>
-      <%= m.text_field "description", :value => @metric.description %>
-    </p>
-    <p>
-      <%= m.label :scope, "Scope:" %>
-      <%= m.select :scope, [["Class", "CLASS"]], :selected => @metric.scope %>
-    </p>
-    <p>
-      <%= m.label :script, "Script:" %>
-      <%= m.text_area "script", :value => @metric.script, :rows => 5 %>
-    </p>
-  <% end %>
-  <p>
-    <%= f.label :code, "Code:" %>
-    <%= f.text_field "code" %>
-  </p>
-  <p>
-    <%= f.label :aggregation_form, "Aggregation Form:" %>
-    <%= f.select :aggregation_form, [["Average","AVERAGE"], ["Median", "MEDIAN"], ["Maximum", "MAXIMUM"], ["Minimum", "MINIMUM"], 
-    ["Count", "COUNT"], ["Standard Deviation", "STANDARD_DEVIATION"]] %>
-  </p>
-  <p>
-    <%= f.label :weight, "Weight:" %>
-    <%= f.text_field :weight %>
-  </p>
-  <p>
-    <%= f.submit "Save" %>
-  </p>
-<% end %>
-
-
-<h5> Ranges </h5><br/>
-
-<table id="ranges">
-  <tr>
-    <td>
-      Label
-    </td>
-    <td>
-      Beginning
-    </td>
-    <td>
-      End
-    </td>
-    <td>
-      Grade
-    </td>
-    <td>
-      Color
-    </td>       
-  </tr>
-  <% if (@metric_configuration.ranges!=nil) 
-    @metric_configuration.ranges.each do |range| %>
-      <%= render :partial => "mezuro_plugin_range/range", :locals => {:range => range, :id => @configuration_content.id, 
-          :metric_name => @metric_configuration.metric.name} %>
-    <% end
-  end %>
-</table>
-
-<br/>
-<%= link_to_remote "New Range", :url => {:action =>"new_range", :controller => "mezuro_plugin_range", :id => @configuration_content.id, :metric_name => @metric.name} %>
-<div id="range_form" style="display:none"></div>
-
-<br/>
-<%= render :partial => "metric_codes", :locals => {:metric_configurations => @metric_configurations} %>
@@ -1,50 +0,0 @@
-<script src="/plugins/mezuro/javascripts/validations.js" type="text/javascript"></script>
-<script src="/javascripts/colorpicker.js" type="text/javascript"></script>
-<script src="/javascripts/colorpicker-noosfero.js" type="text/javascript"></script>
-
-<h2><%= @configuration_content.name %> Configuration</h2>
-
-<% owner = (not user.nil?) && user.id == @profile.id %>
-
-<% if owner %>
-  <%=  render :partial => "content_viewer/metric_configuration_form" %>
-<% else %>
-  <%=  render :partial => "content_viewer/metric_configuration_view" %>
-<% end %>
-
-<h5> Ranges </h5><br/>
-
-<table id="ranges">
-  <tr>
-    <td>
-      Label
-    </td>
-    <td>
-      Beginning
-    </td>
-    <td>
-      End
-    </td>
-    <td>
-      Grade
-    </td>
-    <td>
-      Color
-    </td>   
-    <td></td>    
-    <td></td>
-  </tr>
-  <% if (@metric_configuration.ranges!=nil) 
-    @metric_configuration.ranges.each do |range| %>
-      <%= render :partial => "mezuro_plugin_range/range", :locals => {:range => range, :id => @configuration_content.id, 
-          :metric_name => @metric.name} %>
-    <% end
-  end %>
-</table>
-
-<br/>
-<% if owner %>
-  <%= link_to_remote "New Range", :url => {:action =>"new_range", :controller => "mezuro_plugin_range", :id => @configuration_content.id, :metric_name => @metric.name} %>
-<% end %>
-<div id="range_form" style="display:none"></div>
-
@@ -0,0 +1,18 @@
+<script src="/plugins/mezuro/javascripts/validations.js" type="text/javascript"></script>
+<script src="/javascripts/colorpicker.js" type="text/javascript"></script>
+<script src="/javascripts/colorpicker-noosfero.js" type="text/javascript"></script>
+
+<h2><%= link_to("#{@configuration_content.name} Configuration", @configuration_content.view_url) %></h2>
+  
+<% owner = (not user.nil?) && user.id == @profile.id %>
+
+<% if owner %>
+  <% form_for :metric_configuration, :url => {:action =>"update", :controller => "mezuro_plugin_metric_configuration"}, :method => :get do |f| %>
+    <%= f.hidden_field :id %>
+    <%= render :partial => "native_metric_configuration_form", :locals => {:f => f} %>
+  <% end %>
+<% else %>
+  <%=  render :partial => "native_metric_configuration_view" %>
+<% end %>
+
+<%= render :partial => "mezuro_plugin_range/ranges", :locals => {:owner => owner} %>
@@ -0,0 +1,7 @@
+<h2><%= link_to("#{@configuration_content.name} Configuration", @configuration_content.view_url) %></h2>
+
+<% form_for :metric_configuration, :url => {:action =>"create", :controller => "mezuro_plugin_metric_configuration"}, :method => :get do |f| %>
+  <%= render :partial => "compound_metric_configuration_form", :locals => {:f => f} %>
+<% end %>
+
+<%= render :partial => "metric_codes", :locals => {:metric_configurations => @metric_configurations} %>
@@ -1,44 +0,0 @@
-<h2><%= @configuration_content.name %> Configuration</h2>
-
-<% form_for :metric_configuration, :url => {:action =>"create_compound_metric_configuration", 
-:controller => "mezuro_plugin_metric_configuration"}, :method => :get do |f| %>
-  <%= hidden_field_tag :id, @configuration_content.id %>
-  <%= f.hidden_field :configuration_name, :value => @configuration_content.name %>
-
-  <% f.fields_for :metric do |m| %>
-    <p>
-      <%= m.label :name, "Name:" %>
-      <%= m.text_field "name" %>
-    </p>
-    <p>
-      <%= m.label :description, "Description:" %>
-      <%= m.text_field "description" %>
-    </p>
-    <p>
-      <%= m.label :scope, "Scope:" %>
-      <%= m.select :scope, [["Class", "CLASS"]] %>
-    </p>
-    <p>
-      <%= m.label :script, "Script:" %>
-      <%= m.text_area "script", :rows => 5 %>
-    </p>
-  <% end %>
-  <p>
-    <%= f.label :code, "Code:" %>
-    <%= f.text_field "code" %>
-  </p>
-  <p>
-    <%= f.label :aggregation_form, "Aggregation Form:" %>
-    <%= f.select :aggregation_form, [["Average","AVERAGE"], ["Median", "MEDIAN"], ["Maximum", "MAXIMUM"], ["Minimum", "MINIMUM"], 
-    ["Count", "COUNT"], ["Standard Deviation", "STANDARD_DEVIATION"]] %>
-  </p>
-  <p>
-    <%= f.label :weight, "Weight:" %>
-    <%= f.text_field :weight %>
-  </p>
-  <p>
-    <%= f.submit "Add" %>
-  </p>
-<% end %>
-
-<%= render :partial => "metric_codes", :locals => {:metric_configurations => @metric_configurations} %>
@@ -1,51 +0,0 @@
-<script src="/plugins/mezuro/javascripts/validations.js" type="text/javascript"></script>
-
-<h2><%= @configuration_content.name %> Configuration</h2>
-
-<% form_for :metric_configuration, :url => {:action =>"create_metric_configuration", :controller => "mezuro_plugin_metric_configuration"},  :method => :get do |f| %>
-  <%= hidden_field_tag :id, @configuration_content.id %>
-  <%= f.hidden_field :configuration_name, :value => @configuration_content.name %>
-  
-  <% f.fields_for :metric do |m| %>
-  
-    <% @metric.language.each do |language| %>
-      <%= m.hidden_field :language, :multiple => true, :value => language %>
-    <% end %>
-    
-    <%= m.hidden_field "scope", :value => @metric.scope %>
-    <p>
-      <%= m.label :origin, "Collector Name:" %>
-      <%= @metric.origin %>
-      <%= m.hidden_field "origin", :value => @metric.origin %>
-    </p>
-    <p>
-      <%= m.label :name, "Metric Name:" %>
-      <%= @metric.name %>
-      <%= m.hidden_field "name", :value => @metric.name %>
-    </p>
-    <!--<p>-->
-      <% m.label :description, "Description:" %>
-      <% @metric.description %>
-      <% m.hidden_field "description", :value => @metric.description %>
-    <!--</p>-->
-  <% end %>
-  <p>
-    <%= f.label :code, "Code:" %>
-    <%= f.text_field :code %>
-  </p>
-  <p>
-    <%= f.label :aggregation_form, "Aggregation Form:" %>
-    <%= f.select :aggregation_form, [["Average","AVERAGE"], ["Median", "MEDIAN"], ["Maximum", "MAXIMUM"], ["Minimum", "MINIMUM"], 
-    ["Count", "COUNT"], ["Standard Deviation", "STANDARD_DEVIATION"]] %>
-  </p>
-  <p>
-    <%= f.label :weight, "Weight:" %>
-    <%= f.text_field :weight %>
-  </p>
-
-  <p>
-    <%= f.submit "Add" %>
-  </p>
-
-<% end %>
-
@@ -0,0 +1,7 @@
+<script src="/plugins/mezuro/javascripts/validations.js" type="text/javascript"></script>
+
+<h2><%= link_to("#{@configuration_content.name} Configuration", @configuration_content.view_url) %></h2>
+
+<% form_for :metric_configuration, :url => {:action =>"create", :controller => "mezuro_plugin_metric_configuration"},  :method => :get do |f| %>
+  <%= render :partial => "native_metric_configuration_form", :locals => {:f => f} %>
+<% end %>
@@ -1,2 +0,0 @@
-<h2> An error occured: </h2>
-<%= @message %>
@@ -1,56 +0,0 @@
-<h5><%= _('Metric results for: ') + @module_label %> </h5>
-
-<hr/>
-<div class="zoomable-image">
-<table style="width: 100%">
-  <thead>
-    <tr>
-      <th style="width: 74%">Metric</th>
-      <th>Value</th>
-      <th>Weight</th>
-      <th>Threshold</th>
-    </tr>
-  </thead>
-  <tbody>
-    <% @module_result.metric_results.each do |metric_result|  %>
-      <% range = metric_result.range %>
-      <% if !range.nil? %>
-        <tr>
-          <td style="width: 74%"><a href="#" show-metric-history="<%= MezuroPlugin::Helpers::ContentViewerHelper.format_name(metric_result) %>" data-module-name="<%= @module.name %>"><%= metric_result.metric.name %></a></td>
-          <td><%= MezuroPlugin::Helpers::ContentViewerHelper.format_grade(metric_result.value) %></td>
-          <td><%= metric_result.weight %></td>
-          <td style="background-color: #<%= range.color[2..-1] %>">
-            <span title="<%= range.comments %>" >
-              <%= range.label %>
-            </span>
-          </td>
-        </tr>	  
-        <tr class="<%= MezuroPlugin::Helpers::ContentViewerHelper.format_name(metric_result) %>" style="display: none;">
-          <td colspan="3">
-            <div id='historical-<%= MezuroPlugin::Helpers::ContentViewerHelper.format_name(metric_result) %>'>
-            </div>
-          </td>
-          <td align="right">
-            <%= range.comments.nil? ? '' : range.comments %>
-          </td> 
-        </tr>
-      <% end %>
-    <% end %>
-  </tbody>
-  <tfoot>
-    <tr>
-      <td colspan = "3">
-        <div id='historical-grade' style="display: none;"></div>
-      </td>
-      <td align = "right">
-        <a href="#" show-grade-history="<%= @module_result.module.name %>" data-module-name="<%= @module.name%>" >
-          <strong>
-            <%= _('Grade:') %>
-            <%= "%.02f" % @module_result.grade %>
-          </strong>
-        </a>
-      </td>
-    </tr>
-  </tfoot>
-</table>
-</div>
@@ -1 +0,0 @@
-<%= image_tag(MezuroPlugin::Helpers::ContentViewerHelper.generate_chart(@score_history)) %>
@@ -0,0 +1,2 @@
+<h2> An error occured: </h2>
+<%= @message %>
@@ -0,0 +1,41 @@
+<thead>
+  <tr>
+    <th style="width: 74%">Metric</th>
+    <th>Value</th>
+    <th>Weight</th>
+    <th>Threshold</th>
+  </tr>
+</thead>
+<tbody>
+  <% @metric_results.each do |metric_result|  %>
+    <% metric_configuration_snapshot = metric_result.metric_configuration_snapshot%>
+    <% range_snapshots = metric_configuration_snapshot.range_snapshot %>
+    <% metric_name = metric_configuration_snapshot.metric.name %>
+    <% formatted_name = metric_name.delete("() ") %>
+    <% if !range_snapshots.nil? %>
+      <tr>
+        <td style="width: 74%"><a href="#" show-metric-history="<%= formatted_name %>" data-metric-name="<%= metric_name %>" data-module-id="<%= @module_result.id %>"><%= metric_name %></a></td>
+        <td><%= MezuroPlugin::Helpers::ContentViewerHelper.format_grade(metric_result.value) %></td>
+        <td><%= metric_configuration_snapshot.weight %></td>
+      <% range_snapshots.each do |range_snapshot| %>
+        <% if range_snapshot.beginning <= metric_result.value and range_snapshot.end > metric_result.value %>
+        <td style="background-color: #<%= range_snapshot.color %>">
+          <span title="<%= range_snapshot.comments %>" >
+            <%= range_snapshot.label %>
+          </span>
+        </td>
+      </tr>
+      <tr class="<%= formatted_name %>" style="display: none;">
+        <td colspan="3">
+          <div id='historical-<%= formatted_name %>'>
+          </div>
+        </td>
+        <td align="right">
+          <%= range_snapshot.comments.nil? ? '' : range_snapshot.comments %>
+        </td>
+      </tr>
+      <% end %>
+      <% end %>
+    <% end %>
+  <% end %>
+</tbody>
@@ -0,0 +1,24 @@
+<%= render :partial => "source_tree", :locals => {:module_result => @module_result} %>
+<h5><%= _"Metric results for: #{MezuroPlugin::Helpers::ModuleResultHelper.module_name(@module_result.module.name)} (#{@module_result.module.granularity})" %> </h5>
+
+<hr/>
+<div class="zoomable-image">
+<table style="width: 100%">
+  <%= render :partial => "metric_results", :locals => {:metric_results => @metric_results, :module_result_id => @module_result.id} %>
+  <tfoot>
+    <tr>
+      <td colspan = "3">
+        <div id='historical-grade' style="display: none;"></div>
+      </td>
+      <td align = "right">
+        <a href="#" show-grade-history="<%= @module_result.id %>" data-module-id="<%= @module_result.id %>" >
+          <strong>
+            <%= _('Grade:') %>
+            <%= "%.02f" % @module_result.grade %>
+          </strong>
+        </a>
+      </td>
+    </tr>
+  </tfoot>
+</table>
+</div>
@@ -0,0 +1 @@
+<%= image_tag(MezuroPlugin::Helpers::ContentViewerHelper.generate_chart(@history)) %>
@@ -0,0 +1,34 @@
+<h4><%= _('Source tree') %></h4>
+<% helper = MezuroPlugin::Helpers::ModuleResultHelper %>
+<% module_name = helper.module_name(module_result.module.name) %>
+<% module_label = "#{module_name} (#{module_result.module.granularity})" %>
+
+<p>
+  <h2 class="path">
+    <% module_result.parents.each do |parent| %>
+      /<a href="#" class="source-tree-link" data-module-id="<%= parent.id %>">
+        <%= helper.module_name parent.module.name %>
+      </a>
+    <% end %>/ <%= helper.module_name module_name %>
+  </h2>
+</p>
+  
+<table border="0" class="source-tree">
+  <% module_result.children.each do |child| %>
+    <% if child.module.granularity=='PACKAGE' %>
+      <tr>
+        <td class="icon"><%= image_tag('/plugins/mezuro/images/folder.png')%></td>
+        <td class="source-tree-text"><a href='#' class="source-tree-link" data-module-id="<%= child.id %>"><%= helper.module_name child.module.name %></a></td>
+      </tr>
+    <% else %>
+      <tr>
+        <td class="icon"><%= image_tag('/plugins/mezuro/images/file.png') %></td>
+        <td class="source-tree-text">
+          <a href='#' class="source-tree-link" data-module-id="<%= child.id %>">
+            <%= helper.module_name child.module.name %>
+          </a>
+        </td>
+      </tr>
+    <% end %>
+  <% end %>  
+</table>
@@ -0,0 +1,2 @@
+<h2> An error occured: </h2>
+<%= @processing.error.message %>
@@ -0,0 +1,36 @@
+<div id="current_processing_date" data-date="<%= @processing.date %>"/>
+
+<h4><%= _('Last Result') %></h4>
+
+<table>
+  <tr>
+    <td><%= _('Date') %></td>
+    <td><%= @processing.date.inspect %></td>
+  </tr>
+  <% @processing.process_time.each do |process_time| %>
+    <tr>
+      <td><%= _(process_time.state + ' time') %></td>
+      <td><%= MezuroPlugin::Helpers::ContentViewerHelper.format_time(process_time.time) %></td>
+    </tr>
+  <% end %>
+  <tr>
+    <td>Click to choose specific date:</td>
+    <td><%= link_to(image_tag('/images/calendar_date_select/calendar.png', :width => 20, :height => 20, :onClick => "$( 'datepicker' ).toggle();"), "javascript:void(0)") %></td>
+  </tr>
+</table>
+
+<div id="datepicker"></div>
+
+<script>
+  jQuery(document).ready(function($) {
+    $("#datepicker").datepicker({
+	  								onSelect: function(dateText, inst) {
+	  									reloadProcessingWithDate(dateText) } });
+    $("#datepicker").toggle();
+    var date = jQuery("#current_processing_date").attr('data-date').substr(0,10);
+    $("#datepicker").datepicker( "setDate" , date.substr(5,2)+"/"+date.substr(8,2)+"/"+date.substr(0,4));
+
+  });
+</script>
+
+<span id="module_result_root_id" module_result_root_id="<%= @processing.results_root_id %>">
@@ -0,0 +1,12 @@
+<h3><%= _('ERROR') %></h3>
+<p>
+  <%= "State when error ocurred: #{@processing.state}" %>
+  <br/>
+  <% error = @processing.error %>
+  <%= error.message %>
+<ul>
+  <% error.stack_trace.each do |trace| %>
+    <li><%= "#{trace.declaring_class}.#{trace.method_name}(#{trace.file_name}:#{trace.line_number})" %></li>
+  <% end %>
+</ul>
+</p>
@@ -1,2 +0,0 @@
-<h2> An error occured: </h2>
-<%= @message %>
@@ -1,12 +0,0 @@
-<h3><%= _('ERROR') %></h3>
-<p>
-  <%= "State when error ocurred: #{@project.state}" %>
-  <br/>
-  <% error = @project.kalibro_error %>
-  <%= error.message %>
-<ul>
-  <% error.stack_trace.each do |trace| %>
-    <li><%= "#{trace.declaring_class}.#{trace.method_name}(#{trace.file_name}:#{trace.line_number})" %></li>
-  <% end %>
-</ul>
-</p>
@@ -1,41 +0,0 @@
-<% unless @content.errors[:base].nil? %>
-  <%= @content.errors[:base] %>
-<% else %>
-  <div id="current_project_date" data-date="<%= @project_result.date %>"/>
-
-  <h4><%= _('Last Result') %></h4>
-
-  <table>
-    <tr>
-      <td><%= _('Date') %></td>
-      <td><%= @project_result.date %></td>
-    </tr>
-    <tr>
-      <td><%= _('Load time') %></td>
-      <td><%= @project_result.formatted_load_time %></td>
-    </tr>
-    <tr>
-      <td><%= _('Analysis time') %></td>
-      <td><%= @project_result.formatted_analysis_time %></td>
-    </tr>
-    <tr>
-      <td>Click to choose specific date:</td>
-      <td><%= link_to(image_tag('/images/calendar_date_select/calendar.png', :width => 20, :height => 20, :onClick => "$( 'datepicker' ).toggle();"), "javascript:void(0)") %></td>
-    </tr>
-  </table>
-
-  <div id="datepicker"></div>
-
-  <script>
-    jQuery(document).ready(function($) {
-      $("#datepicker").datepicker({
-  	  								onSelect: function(dateText, inst) {
-  	  									reloadProjectWithDate(dateText) } });
-      $("#datepicker").toggle();
-      var date = jQuery("#current_project_date").attr('data-date').substr(0,10);
-	  $("#datepicker").datepicker( "setDate" , date );
-
-    });
-  </script>
-
-<% end %>
@@ -1,45 +0,0 @@
-<% unless @content.errors[:base].nil? %>
-  <%= @content.errors[:base] %>
-<% else %>
-  <h4><%= _('Source tree') %></h4>
-  <% module_name = @source_tree.module.name %>
-  <% module_label = "#{module_name} (#{@source_tree.module.granularity})" %>
-
-  <p><h2 class="path">
-    <% if module_name != @project_name %>
-      <a href="#" class="source-tree-link" data-module-name="<%= @project_name %>">
-        <%= @project_name %>
-      </a>
-    <% end %>
-
-
-    <% split_link = @source_tree.module.ancestor_names %>
-    <% split_link.each do |link| %>
-      /<a href="#" class="source-tree-link" data-module-name="<%= link %>">
-        <%= link.split(".").last %>
-      </a>
-    <% end %>
-  </h2></p>
-    
-  <% if @source_tree.children %>
-    <table border="0" class="source-tree">
-      <% @source_tree.children.each do |child| %>
-        <% if child.module.granularity=='PACKAGE' %>
-          <tr>
-	          <td class="icon"><%= image_tag('/plugins/mezuro/images/folder.png')%></td>
-	          <td class="source-tree-text"><a href='#' class="source-tree-link" data-module-name="<%= child.module.name %>"><%= child.module.name %></a></td>
-          </tr>
-        <% else %>
-          <tr>
-	          <td class="icon"><%= image_tag('/plugins/mezuro/images/file.png') %></td>
-	          <td class="source-tree-text">
-                    <a href='#' class="source-tree-link" data-module-name="<%= child.module.name %>">
-                      <%= child.module.name %>
-                    </a>
-                  </td>
-          </tr>
-        <% end %>
-      <% end %>  
-    </table>
-  <% end %>
-<% end %>
@@ -0,0 +1,4 @@
+<% remote_form_for :range, :url => {:action =>"update", :controller => "mezuro_plugin_range"}, :method => :get do |f| %>
+  <%= hidden_field_tag :beginning_id, @beginning_id %>
+  <%= render :partial => "form", :locals => {:f => f} %>
+<% end %>
@@ -1,4 +0,0 @@
-<% remote_form_for :range, :url => {:action =>"update_range", :controller => "mezuro_plugin_range"}, :method => :get do |f| %>
-  <%= hidden_field_tag :beginning_id, @beginning_id %>
-  <%= render :partial => "range_form", :locals => {:f => f} %>
-<% end %>
@@ -0,0 +1,37 @@
+<%= hidden_field_tag :id, @content_id %>
+<%= hidden_field_tag :metric_configuration_id, @metric_configuration_id %>
+<%= hidden_field_tag :reading_group_id, @reading_group_id %>
+<%= hidden_field_tag :compound, @compound %>
+
+<%= f.hidden_field :id %>
+
+  <%= required labelled_form_field _('Label'),
+  f.select(:reading_id, @reading_labels_and_ids) %><br/>
+<table>
+  <tr>
+    <td>
+      <%= f.label :beginning, "(*) Beginning:" %>
+    </td>
+    <td>
+      <%= required f.text_field :beginning, :id => "range_beginning" %>&nbsp;<%= link_to('-&#8734', 'javascript:void(0)', :onClick => "jQuery( '#range_beginning' ).val('-INF');") %>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <%= f.label :end, "(*) End:" %>
+    </td>
+    <td>
+      <%= required f.text_field(:end, :id => "range_end") %>&nbsp;<%= link_to('+&#8734', 'javascript:void(0)', :onClick => "jQuery( '#range_end' ).val('+INF');") %>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <%= f.label :comments, "(*) Comments:" %>
+    </td>
+    <td>
+      <%= required f.text_area :comments, :rows => 3 %>
+    </td>
+  </tr>
+</table>
+<br/>
+<%= f.submit "Save Range" %>
@@ -0,0 +1,3 @@
+<% remote_form_for :range, :url => {:action =>"create", :controller => "mezuro_plugin_range"}, :method => :get do |f| %>
+  <%= render :partial => "form", :locals => {:f => f} %>
+<% end %>
@@ -1,3 +0,0 @@
-<% remote_form_for :range, :url => {:action =>"create_range", :controller => "mezuro_plugin_range"}, :method => :get do |f| %>
-  <%= render :partial => "range_form", :locals => {:f => f} %>
-<% end %>
@@ -13,9 +13,9 @@
   </td>
   <td bgcolor="#<%= range.color %>"></td>
   <% if (not user.nil?) && user.id == @profile.id %>
-  <td><%= link_to_remote "Edit", :url => {:action =>"edit_range", :controller => "mezuro_plugin_range", :id => params[:id], :metric_name => params[:metric_name], :beginning_id => range.beginning} %>
+  <td><%= link_to_remote "Edit", :url => {:action =>"edit", :controller => "mezuro_plugin_range", :id => params[:id], :metric_configuration_id => params[:metric_configuration_id], :range_id => range.id, :reading_group_id => reading_group_id} %>
   </td>
-    <td><%= link_to "Remove", :action =>"remove_range", :controller => "mezuro_plugin_range", :id => params[:id], :metric_name => params[:metric_name], :beginning_id => range.beginning %>
+    <td><%= link_to "Remove", :action =>"remove", :controller => "mezuro_plugin_range", :id => params[:id], :metric_configuration_id => params[:metric_configuration_id], :range_id => range.id, :compound => compound %>
     </td>
   <% else %>
     <td></td>
@@ -1,54 +0,0 @@
-<%= hidden_field_tag :id, @content_id %>
-<%= hidden_field_tag :metric_name, @metric_name %>
-
-<table>
-  <tr>
-    <td>
-      <%= f.label :label, "(*) Label:" %>
-    </td>
-    <td>
-      <%= f.text_field :label %>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <%= f.label :beginning, "(*) Beginning:" %>
-    </td>
-    <td>
-      <%= f.text_field :beginning, :id => "range_beginning" %>&nbsp;<%= link_to('-&#8734', 'javascript:void(0)', :onClick => "jQuery( '#range_beginning' ).val('-INF');") %>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <%= f.label :end, "(*) End:" %>
-    </td>
-    <td>
-      <%= f.text_field(:end, :id => "range_end") %>&nbsp;<%= link_to('+&#8734', 'javascript:void(0)', :onClick => "jQuery( '#range_end' ).val('+INF');") %>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <%= f.label :grade, "(*) Grade:" %>
-    </td>
-    <td>
-      <%= f.text_field :grade %>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <%= f.label :color, "(*) Color:" %>
-    </td>
-    <td>
-      <%= colorpicker_field(:range, :color, :value => @range.mezuro_color) %>Click in the field to change Color
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <%= f.label :comments, "Comments:" %>
-    </td>
-    <td>
-      <%= f.text_area :comments, :rows => 3 %>
-    </td>
-  </tr>
-</table>
-<%= f.submit "Save Range" %>
@@ -0,0 +1,31 @@
+<h5> Ranges </h5><br/>
+
+<table id="ranges">
+  <tr>
+    <td>
+      Label
+    </td>
+    <td>
+      Beginning
+    </td>
+    <td>
+      End
+    </td>
+    <td>
+      Grade
+    </td>
+    <td>
+      Color
+    </td>       
+  </tr>
+  <% @ranges.each do |range| %>
+      <%= render :partial => "mezuro_plugin_range/range", :locals => {:range => range, :id => @configuration_content.id, 
+          :metric_configuration_id => @metric_configuration.id, :reading_group_id => @metric_configuration.reading_group_id, :compound => @metric_configuration.metric.compound} %>
+  <% end %>
+</table>
+
+<br/>
+<% if owner %>
+  <%= link_to_remote "New Range", :url => {:action =>"new", :controller => "mezuro_plugin_range", :id => @configuration_content.id, :metric_configuration_id => @metric_configuration.id, :reading_group_id => @metric_configuration.reading_group_id, :compound => @metric_configuration.metric.compound} %>
+<% end %>
+<div id="form" style="display:none"></div>
@@ -0,0 +1,6 @@
+if @error.nil?
+  page.visual_effect :toggle_slide, "form"
+  page.insert_html :bottom, "ranges", :partial => "range", :locals => {:range => @range, :reading_group_id => @reading_group_id, :compound => @compound}
+else
+  page.alert @error
+end
@@ -1,6 +0,0 @@
-if @error.nil?
-  page.visual_effect :toggle_slide, "range_form"
-  page.insert_html :bottom, "ranges", :partial => "range", :locals => {:range => @range}
-else
-  page.alert @error
-end
@@ -0,0 +1,3 @@
+page.replace_html 'form', :partial => "edit", :locals => {:range => @range}
+page.visual_effect :slide_down, "form"
+
@@ -1,3 +0,0 @@
-page.replace_html 'range_form', :partial => "edit_range", :locals => {:range => @range}
-page.visual_effect :slide_down, "range_form"
-
@@ -0,0 +1,3 @@
+page.replace_html 'form', :partial => "new"
+page.visual_effect :slide_down, "form"
+
@@ -1,3 +0,0 @@
-page.replace_html 'range_form', :partial => "new_range"
-page.visual_effect :slide_down, "range_form"
-
@@ -0,0 +1,5 @@
+if @error.nil?
+  page.reload()
+else
+  page.alert @error
+end
@@ -1,5 +0,0 @@
-if @error.nil?
-  page.reload()
-else
-  page.alert @error
-end
@@ -0,0 +1,11 @@
+<%= hidden_field_tag :id, @reading_group_content.id %>
+
+<%= required labelled_form_field _('label:'), f.text_field(:label) %> 
+
+<%= required labelled_form_field _('grade:'),
+f.text_field(:grade) %>
+
+<%= required labelled_form_field _('color:'),
+colorpicker_field(:reading, :color) %>Click in the field to change Color
+
+<p><%= f.submit "Save" %></p>
@@ -0,0 +1,8 @@
+<script src="/javascripts/colorpicker.js" type="text/javascript"></script>
+<script src="/javascripts/colorpicker-noosfero.js" type="text/javascript"></script>
+<h2><%= link_to("#{@reading_group_content.name} Reading Group", @reading_group_content.view_url) %></h2>
+
+<% form_for :reading, :url => {:action =>"save", :controller => "mezuro_plugin_reading"},  :method => :get do |f| %>
+  <%= f.hidden_field :id %>
+  <%= render :partial => "form", :locals => {:f => f} %>
+<% end %>
@@ -0,0 +1,7 @@
+<script src="/javascripts/colorpicker.js" type="text/javascript"></script>
+<script src="/javascripts/colorpicker-noosfero.js" type="text/javascript"></script>
+<h2><%= link_to("#{@reading_group_content.name} Reading Group", @reading_group_content.view_url) %></h2>
+
+<% form_for :reading, :url => {:action =>"save", :controller => "mezuro_plugin_reading"},  :method => :get do |f| %>
+  <%= render :partial => "form", :locals => {:f => f} %>
+<% end %>
@@ -0,0 +1,2 @@
+<h2> An error occured: </h2>
+<%= @message %>
@@ -0,0 +1,28 @@
+<h2><%= link_to("#{@project_content.name} Project", @project_content.view_url) %></h2>
+
+<% form_for :repository, :url => {:action =>"save", :controller => "mezuro_plugin_repository"},  :method => :get do |f| %>
+  <%= f.hidden_field :id %>
+  <%= hidden_field_tag :id, @project_content.id %>
+
+  <%= required labelled_form_field _('Name'), f.text_field(:name) %> 
+
+  <%= labelled_form_field _("Description"), f.text_field(:description) %>
+
+  <%= required labelled_form_field _('License'),
+  f.select(:license, MezuroPlugin::Helpers::ContentViewerHelper.license_options) %>
+
+  <%= required labelled_form_field _('Process Period'),
+  f.select(:process_period, MezuroPlugin::Helpers::ContentViewerHelper.periodicity_options) %>
+
+  <%= required labelled_form_field _('Type'),
+  f.select(:type, @repository_types) %>
+
+  <%= required labelled_form_field _('Address'),
+  f.text_field(:address) %>
+
+  <%= required labelled_form_field _('Configuration'),
+  f.select(:configuration_id, @configuration_select) %>
+
+  <p> <%= f.submit "Add" %> </p>
+
+<% end %>
@@ -0,0 +1 @@
+<%= render :partial => "form" %>
@@ -0,0 +1 @@
+<%= render :partial => "form" %>
@@ -0,0 +1,45 @@
+<script src="/plugins/mezuro/javascripts/processing.js" type="text/javascript"></script>
+<h2><%= link_to("#{@project_content.name} Project", @project_content.view_url) %></h2>
+
+<table>
+  <tr>
+    <td><%= _('Name') %></td>
+    <td><%= @repository.name %></td>
+  </tr>
+  <tr>
+    <td><%= _('Description') %></td>
+    <td><%= @repository.description %></td>
+  </tr>
+  <tr>
+    <td><%= _('License') %></td>
+    <td><%= @repository.license %></td>
+  </tr>
+  <tr>
+    <td><%= _('Process Period') %></td>
+    <td><%= MezuroPlugin::Helpers::ContentViewerHelper.periodicity_option(@repository.process_period.to_i) %></td>
+  </tr>
+  <tr>
+    <td><%= _('Type') %></td>
+    <td><%= @repository.type %></td>
+  </tr>
+  <tr>
+    <td><%= _('Address') %></td>
+    <td><%= @repository.address %></td>
+  </tr>
+  <tr>
+    <td><%= _('Configuration') %></td>
+    <td><%= @configuration_name %></td>
+  </tr>
+  <tr>
+    <td><%= _('Status')%></td>
+    <td>
+      <div id="processing-state" style="color:DarkGoldenRod">Retrieving</div>
+      <div id="msg-time"></div>
+    </td>
+  </tr>
+</table>
+<br />
+
+<div id="processing" data-profile="<%= @project_content.profile.identifier %>" data-content="<%= @project_content.id %>"
+     data-repository-id="<%= @repository.id %>"></div>
+<div id="module-result"></div>
...	...	@@ -32,3 +32,17 @@ Then /^I should see "([^\"]*)" inside an alert$/ do \|message\|
32	32	selenium.get_alert.should eql(message)
33	33	selenium.chooseOkOnNextConfirmation();
34	34	end
	35	+
	36	+When /^I have a Mezuro project with the following data$/ do \|fields\|
	37	+ item = {}
	38	+ fields.rows_hash.each do \|name, value\|
	39	+ if(name=="community")
	40	+ item.merge!(:profile=>Profile[value])
	41	+ else
	42	+ item.merge!(name => value)
	43	+ end
	44	+ end
	45	+ result = MezuroPlugin::ProjectContent.new(item)
	46	+ result.save!
	47	+end
	48	+
...	...
...	...	@@ -761,3 +761,9 @@ Given /^there are no pending jobs$/ do
761	761	Delayed::Worker.new.work_off
762	762	end
763	763	end
	764	+
	765	+When /^I confirm the "(.*)" dialog$/ do \|confirmation\|
	766	+ a = page.driver.browser.switch_to.alert
	767	+ assert_equal confirmation, a.text
	768	+ a.accept
	769	+end
...	...
...	...	@@ -1,4 +0,0 @@
1		-Before('@mezuro') do \|scenario\|
2		- command = "#{RAILS_ROOT}/plugins/mezuro/features/initialize_monkey_server.sh \"#{scenario.name}\""
3		- system command
4		-end
...	...	@@ -1,10 +0,0 @@
1		-class MezuroPluginBaseToolController < MezuroPluginMyprofileController
2		-
3		- append_view_path File.join(File.dirname(__FILE__) + '/../../views')
4		-
5		- def choose_metric
6		- @configuration_content = profile.articles.find(params[:id])
7		- @base_tools = Kalibro::BaseTool.all
8		- end
9		-
10		-end
...	...	@@ -2,96 +2,108 @@ class MezuroPluginMetricConfigurationController < MezuroPluginMyprofileControlle
2	2
3	3	append_view_path File.join(File.dirname(__FILE__) + '/../../views')
4	4
5		- def new_metric_configuration
	5	+ def choose_metric
6	6	@configuration_content = profile.articles.find(params[:id])
7		- @metric = Kalibro::BaseTool.find_by_name(params[:base_tool]).metric params[:metric_name]
	7	+ @base_tools = Kalibro::BaseTool.all
8	8	end
9	9
10		- def new_compound_metric_configuration
	10	+ def new_native
11	11	@configuration_content = profile.articles.find(params[:id])
12		- @metric_configurations = @configuration_content.metric_configurations
13		- if configuration_content_has_errors?
14		- redirect_to_error_page @configuration_content.errors[:base]
15		- end
	12	+ @reading_group_names_and_ids = reading_group_names_and_ids
	13	+ @metric = Kalibro::BaseTool.find_by_name(params[:base_tool_name]).metric params[:metric_name]
	14	+ @metric_configuration = Kalibro::MetricConfiguration.new :base_tool_name => params[:base_tool_name], :metric => @metric
16	15	end
17	16
18		- def edit_metric_configuration
19		- @configuration_content = profile.articles.find(params[:id])
20		- @metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, params[:metric_name])
21		- @metric = @metric_configuration.metric
	17	+ def edit_native
	18	+ params_to_edit_view
22	19	end
23	20
24		- def edit_compound_metric_configuration
	21	+ def new_compound
25	22	@configuration_content = profile.articles.find(params[:id])
26		- @metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, params[:metric_name])
27	23	@metric_configurations = @configuration_content.metric_configurations
28		- @metric = @metric_configuration.metric
29		- end
30		-
31		- def create_metric_configuration
32		- id = params[:id]
33		- metric_name = params[:metric_configuration][:metric][:name]
34		- metric_configuration = Kalibro::MetricConfiguration.new(params[:metric_configuration])
35		- metric_configuration.save
36		- if metric_configuration_has_errors? metric_configuration
37		- redirect_to_error_page metric_configuration.errors[0].message
38		- else
39		- redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/metric_configuration/edit_metric_configuration?id=#{id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
	24	+ @reading_group_names_and_ids = reading_group_names_and_ids
	25	+ metric = Kalibro::Metric.new :compound => true
	26	+ @metric_configuration = Kalibro::MetricConfiguration.new :metric => metric
	27	+ if configuration_content_has_errors?
	28	+ redirect_to_error_page @configuration_content.errors[:base]
40	29	end
41	30	end
42	31
43		- def create_compound_metric_configuration
44		- id = params[:id]
45		- metric_name = params[:metric_configuration][:metric][:name]
46		- metric_configuration = Kalibro::MetricConfiguration.new(params[:metric_configuration])
47		- metric_configuration.save
48		- if metric_configuration_has_errors? metric_configuration
49		- redirect_to_error_page metric_configuration.errors[0].message
50		- else
51		- redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/metric_configuration/edit_compound_metric_configuration?id=#{id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
52		- end
	32	+ def edit_compound
	33	+ params_to_edit_view
53	34	end
54	35
55		- def update_metric_configuration
56		- @configuration_content = profile.articles.find(params[:id])
57		- metric_name = params[:metric_configuration][:metric][:name]
58		- metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
59		- metric_configuration.update_attributes params[:metric_configuration]
	36	+ def create
	37	+ configuration_content = profile.articles.find(params[:id])
	38	+ metric_configuration = Kalibro::MetricConfiguration.create(params[:metric_configuration])
	39	+
60	40	if metric_configuration_has_errors? metric_configuration
61	41	redirect_to_error_page metric_configuration.errors[0].message
62	42	else
63		- redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
	43	+ redirect_to(metric_configuration_url(configuration_content, metric_configuration.id))
64	44	end
65	45	end
66	46
67		- def update_compound_metric_configuration
	47	+ def update
68	48	@configuration_content = profile.articles.find(params[:id])
69		- metric_name = params[:metric_configuration][:metric][:name]
70		- metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
	49	+ metric_configurations = @configuration_content.metric_configurations
	50	+ metric_configuration = find_metric_configuration(metric_configurations, params[:metric_configuration][:id].to_i)
71	51	metric_configuration.update_attributes params[:metric_configuration]
72	52	if metric_configuration_has_errors? metric_configuration
73	53	redirect_to_error_page metric_configuration.errors[0].message
74	54	else
75		- redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
	55	+ redirect_to @configuration_content.view_url
76	56	end
77	57	end
78	58
79		- def remove_metric_configuration
	59	+ def remove
80	60	configuration_content = profile.articles.find(params[:id])
81		- metric_name = params[:metric_name]
82		- metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
	61	+ configuration_id = configuration_content.configuration_id
	62	+ metric_configuration = Kalibro::MetricConfiguration.new({:id => params[:metric_configuration_id].to_i})
83	63	metric_configuration.destroy
84	64	if metric_configuration_has_errors? metric_configuration
85	65	redirect_to_error_page metric_configuration.errors[0].message
86	66	else
87		- redirect_to "/#{profile.identifier}/#{configuration_content.slug}"
	67	+ redirect_to configuration_content.view_url
88	68	end
89	69	end
90		-
	70	+
91	71	private
92		-
	72	+
	73	+ def find_metric_configuration (metric_configurations, metric_configuration_id)
	74	+ metric_configurations.select {\|metric_configuration\| metric_configuration.id == metric_configuration_id }.first
	75	+ end
	76	+
	77	+ def reading_group_names_and_ids
	78	+ array = Kalibro::ReadingGroup.all.map { \|reading_group\| [reading_group.name, reading_group.id] }
	79	+ array.sort { \|x,y\| x.first.downcase <=> y.first.downcase }
	80	+ end
	81	+
	82	+ def metric_configuration_has_errors? metric_configuration
	83	+ not metric_configuration.errors.empty?
	84	+ end
	85	+
93	86	def configuration_content_has_errors?
94	87	not @configuration_content.errors[:base].nil?
95	88	end
96		-
	89	+
	90	+ def metric_configuration_url(configuration_content, metric_configuration_id)
	91	+ url = configuration_content.view_url
	92	+ url[:controller] = controller_name
	93	+ url[:id] = configuration_content.id
	94	+ url[:metric_configuration_id] = metric_configuration_id
	95	+ url[:action] = (params[:metric_configuration][:metric][:compound] == "true" ? "edit_compound" : "edit_native")
	96	+ url
	97	+ end
	98	+
	99	+ def params_to_edit_view
	100	+ @configuration_content = profile.articles.find(params[:id])
	101	+ @metric_configurations = @configuration_content.metric_configurations
	102	+ @metric_configuration = find_metric_configuration(@metric_configurations, params[:metric_configuration_id].to_i)
	103	+ @metric = @metric_configuration.metric
	104	+ @reading_group_names_and_ids = reading_group_names_and_ids
	105	+ @ranges = Kalibro::Range.ranges_of(@metric_configuration.id)
	106	+ end
	107	+
97	108	end
	109	+
...	...
...	...	@@ -2,27 +2,15 @@ class MezuroPluginMyprofileController < ProfileController #MyprofileController?
2	2
3	3	append_view_path File.join(File.dirname(__FILE__) + '/../../views')
4	4
5		- rescue_from Exception do \|exception\|
6		- @message = process_error_message exception.message
7		- render :partial => "error_page"
8		- end
	5	+# rescue_from Exception do \|exception\|
	6	+# @message = process_error_message exception.message
	7	+# render :partial => "error_page"
	8	+# end
9	9
10	10	def error_page
11	11	@message = params[:message]
12	12	end
13	13
14		- def choose_base_tool
15		- @configuration_content = profile.articles.find(params[:id])
16		- @base_tools = Kalibro::BaseTool.all_names
17		- end
18		-
19		- def choose_metric
20		- @configuration_content = profile.articles.find(params[:id])
21		- @base_tool = params[:base_tool]
22		- base_tool = Kalibro::BaseTool.find_by_name(@base_tool)
23		- @supported_metrics = base_tool.nil? ? [] : base_tool.supported_metrics
24		- end
25		-
26	14	protected
27	15
28	16	def redirect_to_error_page(message)
...	...	@@ -30,11 +18,7 @@ class MezuroPluginMyprofileController < ProfileController #MyprofileController?
30	18	redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/error_page?message=#{message}"
31	19	end
32	20
33		- def metric_configuration_has_errors? metric_configuration
34		- not metric_configuration.errors.empty?
35		- end
36		-
37		- def process_error_message message
	21	+ def process_error_message message #FIXME
38	22	if message =~ /bla/
39	23	message
40	24	else
...	...
...	...	@@ -2,65 +2,65 @@ class MezuroPluginRangeController < MezuroPluginMyprofileController
2	2
3	3	append_view_path File.join(File.dirname(__FILE__) + '/../../views')
4	4
5		- def new_range
6		- @content_id = params[:id]
7		- @metric_name = params[:metric_name]
8		- @range = Kalibro::Range.new
9		- @range_color = "#000000"
	5	+ def new
	6	+ params_to_range_form
	7	+ params_to_redirect
10	8	end
11	9
12		- def edit_range
13		- @beginning_id = params[:beginning_id]
14		- @content_id = params[:id]
15		- configuration_name = profile.articles.find(@content_id).name
16		- @metric_name = params[:metric_name]
17		- metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_name, @metric_name)
18		- @range = metric_configuration.ranges.find{\|range\| range.beginning == @beginning_id.to_f \|\| @beginning_id =="-INF" }
19		- @range_color = "#" + @range.color.to_s.gsub(/^ff/, "")
	10	+ def edit
	11	+ params_to_range_form
	12	+ ranges = Kalibro::Range.ranges_of params[:metric_configuration_id].to_i
	13	+ @range = (ranges.select { \|range\| range.id == params[:range_id].to_i }).first
20	14	end
21	15
22		- def create_range
23		- @configuration_content = profile.articles.find(params[:id])
24		- @range = Kalibro::Range.new params[:range]
25		- metric_name = params[:metric_name]
26		- metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
27		- metric_configuration.add_range(@range)
28		- metric_configuration.save
29		- if metric_configuration_has_errors? metric_configuration
30		- @error = metric_configuration.errors[0].message
31		- end
	16	+ def create
	17	+ params_to_redirect
	18	+ save_range
32	19	end
33	20
34		- def update_range
35		- configuration_content = profile.articles.find(params[:id])
36		- metric_name = params[:metric_name]
37		- beginning_id = params[:beginning_id]
38		- metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
39		- index = metric_configuration.ranges.index{ \|range\| range.beginning == beginning_id.to_f \|\| beginning_id == "-INF" }
40		- metric_configuration.ranges[index] = Kalibro::Range.new params[:range]
41		- metric_configuration.save
42		- if metric_configuration_has_errors? metric_configuration
43		- @error = metric_configuration.errors[0].message
44		- end
	21	+ def update
	22	+ save_range
45	23	end
46	24
47		- def remove_range
	25	+ def remove
48	26	configuration_content = profile.articles.find(params[:id])
49		- metric_name = params[:metric_name]
50		- beginning_id = params[:beginning_id]
51		- metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
52		- metric_configuration.ranges.delete_if { \|range\| range.beginning == beginning_id.to_f \|\| beginning_id == "-INF" }
53		- metric_configuration.save
54		- if metric_configuration_has_errors? metric_configuration
55		- redirect_to_error_page metric_configuration.errors[0].message
56		- else
57		- formatted_metric_name = metric_name.gsub(/\s/, '+')
58		- if metric_configuration.metric.class == Kalibro::CompoundMetric
59		- redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/metric_configuration/edit_compound_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
60		- else
61		- redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/metric_configuration/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
62		- end
	27	+ Kalibro::Range.new({:id => params[:range_id].to_i}).destroy
	28	+ redirect_to(metric_configuration_url(configuration_content))
	29	+ end
	30	+
	31	+ private
	32	+
	33	+ def metric_configuration_url configuration_content
	34	+ url = configuration_content.view_url
	35	+ url[:controller] = "mezuro_plugin_metric_configuration"
	36	+ url[:id] = configuration_content.id
	37	+ url[:metric_configuration_id] = params[:metric_configuration_id].to_i
	38	+ url[:action] = (params[:compound] ? "edit_compound" : "edit_native")
	39	+ url
	40	+ end
	41	+
	42	+ def reading_labels_and_ids
	43	+ Kalibro::Reading.readings_of(params[:reading_group_id].to_i).map { \|reading\| [reading.label, reading.id] }
	44	+ end
	45	+
	46	+ def save_range
	47	+ metric_configuration_id = params[:metric_configuration_id].to_i
	48	+ @range = Kalibro::Range.new params[:range]
	49	+ @range.save metric_configuration_id
	50	+ if !@range.errors.empty?
	51	+ @error = @range.errors[0].message
63	52	end
64	53	end
65	54
	55	+ def params_to_range_form
	56	+ @content_id = params[:id].to_i
	57	+ @metric_configuration_id = params[:metric_configuration_id].to_i
	58	+ @reading_labels_and_ids = reading_labels_and_ids
	59	+ end
	60	+
	61	+ def params_to_redirect
	62	+ @reading_group_id = params[:reading_group_id].to_i
	63	+ @compound = params[:compound]
	64	+ end
	65	+
66	66	end
...	...
...	...	@@ -0,0 +1,36 @@
	1	+class MezuroPluginReadingController < MezuroPluginMyprofileController
	2	+
	3	+ append_view_path File.join(File.dirname(__FILE__) + '/../../views')
	4	+
	5	+ def new
	6	+ @reading_group_content = profile.articles.find(params[:id])
	7	+ end
	8	+
	9	+ def save
	10	+ reading_group_content = profile.articles.find(params[:id])
	11	+ reading = Kalibro::Reading.new params[:reading]
	12	+
	13	+ if( reading.save(reading_group_content.reading_group_id) )
	14	+ redirect_to reading_group_content.view_url
	15	+ else
	16	+ redirect_to_error_page reading.errors[0].message
	17	+ end
	18	+ end
	19	+
	20	+ def edit
	21	+ @reading_group_content = profile.articles.find(params[:id])
	22	+ @reading = Kalibro::Reading.find params[:reading_id]
	23	+ end
	24	+
	25	+ def destroy
	26	+ reading_group_content = profile.articles.find(params[:id])
	27	+ reading = Kalibro::Reading.find params[:reading_id]
	28	+ reading.destroy
	29	+ if( reading.errors.empty? )
	30	+ redirect_to reading_group_content.view_url
	31	+ else
	32	+ redirect_to_error_page reading.errors[0].message
	33	+ end
	34	+ end
	35	+
	36	+end
...	...
...	...	@@ -1,62 +0,0 @@
1		-class MezuroPluginModuleController < MezuroPluginProfileController
2		-
3		- append_view_path File.join(File.dirname(__FILE__) + '/../../views')
4		-
5		- def module_result
6		- @content = profile.articles.find(params[:id])
7		- @module_result = @content.module_result(params)
8		- @module = @module_result.module
9		- @module_label = "#{@module.name} (#{@module.granularity})"
10		- if project_content_has_errors?
11		- redirect_to_error_page(@content.errors[:base])
12		- else
13		- render :partial => 'module_result'
14		- end
15		- end
16		-
17		- def module_metrics_history
18		- metric_name = params[:metric_name]
19		- @content = profile.articles.find(params[:id])
20		- module_history = @content.result_history(params[:module_name])
21		- if project_content_has_errors?
22		- redirect_to_error_page(@content.errors[:base])
23		- else
24		- @score_history = filtering_metric_history(metric_name, module_history)
25		- render :partial => 'score_history'
26		- end
27		- end
28		-
29		- def module_grade_history
30		- @content = profile.articles.find(params[:id])
31		- modules_results = @content.result_history(params[:module_name])
32		- if project_content_has_errors?
33		- redirect_to_error_page(@content.errors[:base])
34		- else
35		- @score_history = modules_results.map do \|module_result\|
36		- [module_result.grade, format_date_to_simple_form(module_result.date)]
37		- end
38		- render :partial => 'score_history'
39		- end
40		- end
41		-
42		- private
43		-
44		- def filtering_metric_history(metric_name, module_history)
45		- metrics_history = module_history.map do \|module_result\|
46		- [module_result.metric_results, format_date_to_simple_form(module_result.date)]
47		- end
48		- metric_history = metrics_history.map do \|metric_results_with_date\|
49		- [(metric_results_with_date.first.select do \|metric_result\|
50		- metric_result.metric.name.delete("() ") == metric_name
51		- end).first, metric_results_with_date.last]
52		- end
53		- metric_history.map do \|metric_result_with_date\|
54		- [metric_result_with_date.first.value, metric_result_with_date.last]
55		- end
56		- end
57		-
58		- def format_date_to_simple_form date
59		- date.to_s[0..9]
60		- end
61		-
62		-end
...	...	@@ -0,0 +1,21 @@
	1	+class MezuroPluginModuleResultController < MezuroPluginProfileController
	2	+
	3	+ append_view_path File.join(File.dirname(__FILE__) + '/../../views')
	4	+
	5	+ def module_result
	6	+ @module_result = Kalibro::ModuleResult.find(params[:module_result_id].to_i)
	7	+ @metric_results = Kalibro::MetricResult.metric_results_of(@module_result.id)
	8	+ render :partial => 'module_result'
	9	+ end
	10	+
	11	+ def metric_result_history
	12	+ @history = Kalibro::MetricResult.history_of(params[:metric_name], params[:module_result_id].to_i)
	13	+ render :partial => 'score_history'
	14	+ end
	15	+
	16	+ def module_result_history
	17	+ @history = Kalibro::ModuleResult.history_of(params[:module_result_id].to_i)
	18	+ render :partial => 'score_history'
	19	+ end
	20	+
	21	+end
...	...