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
+
...	...	@@ -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
...	...