Merge commit 'refs/merge-requests/199' of git://gitorious.org/noosfero/noosfero …

…into merge-requests/199

Merge commit 'refs/merge-requests/199' of git://gitorious.org/noosfero/noosfero …
…into merge-requests/199
Daniela Feitosa
2 parents d65fa49c f1bbe72d
Showing 160 changed files with 4111 additions and 1926 deletions Show diff stats
config/initializers/mezuro_plugin.rb
features/step_definitions/mezuro_steps.rb
plugins/mezuro/AUTHORS
plugins/mezuro/README
plugins/mezuro/TODO
plugins/mezuro/controllers/mezuro_plugin_myprofile_controller.rb
plugins/mezuro/controllers/mezuro_plugin_profile_controller.rb
plugins/mezuro/features/mezuro.feature
plugins/mezuro/lib/kalibro/base_tool.rb
plugins/mezuro/lib/kalibro/client/base_tool_client.rb
plugins/mezuro/lib/kalibro/client/configuration_client.rb
plugins/mezuro/lib/kalibro/client/kalibro_client.rb
plugins/mezuro/lib/kalibro/client/module_result_client.rb
plugins/mezuro/lib/kalibro/client/port.rb
plugins/mezuro/lib/kalibro/client/project_client.rb
plugins/mezuro/lib/kalibro/client/project_result_client.rb
plugins/mezuro/lib/kalibro/compound_metric.rb
plugins/mezuro/lib/kalibro/compound_metric_with_error.rb
plugins/mezuro/lib/kalibro/configuration.rb
plugins/mezuro/lib/kalibro/entities/base_tool.rb
@@ -0,0 +1,6 @@
+require 'savon'
+require 'yaml'
+
+Savon.configure do |config|
+  config.log = HTTPI.log = (RAILS_ENV == 'development')
+end
@@ -0,0 +1,14 @@
+Then /^I directly delete content with name "([^\"]*)" for testing purposes$/ do |content_name|
+  Article.find_by_name(content_name).destroy
+end
+
+Then /^I should be at the url "([^\"]*)"$/ do |url|
+  if response.class.to_s == 'Webrat::SeleniumResponse'
+    URI.parse(response.selenium.get_location).path.should == url
+  else
+    URI.parse(current_url).path.should == url
+  end
+end
+
+Then /^I don't fill anything$/ do
+end
-KALIBRO PLUGIN AUTHORS
-=====================
+Mezuro Authors
+==============
  
-Copyright 2010-2011
-        Almir Alves Pereira (almir.sne at gmail.com)
-        Andre Casimiro (ah.casimiro at gmail.com)
-        Carlos Morais (carlos88morais at gmail.com)
-        Everton Santos (everton2x4 at gmail.com)
-        Paulo Meirelles (paulo at softwarelivre.org)
-        Rafael Messias (rmmartins at gmail.com)
+Copyright 2010-2012
+-------------------
  
-Collaborators:
-- Ana Paula Oliveira dos Santos (ana at ime.usp.br)
-- Lucianna Almeida (lucianna.th at gmail.com)
-- Joao Machini (joao.machini at gmail.com)
-- Rodrigo Souto (rodrigo@colivre.coop.br)
-- Thiago Colucci (ticolucci at gmail.com)
-- Vinicius Daros (vinicius.k.daros at gmail.com)
-- Viviane Almeida Santos (viviane.almeida at gmail.com)
+ Almir Alves Pereira (almir.sne at gmail.com)
+ Alessandro Palmeira (alessandro.palmeira at gmail.com)
+ Andre Casimiro (ah.casimiro at gmail.com)
+ Antonio Terceiro (terceiro at colivre.coop.br)
+ Caio Salgado (caio.csalgado at gmail.com)
+ Carlos Morais (carlos88morais at gmail.com)
+ Diego Araújo (diegoamc90 at gmail.com)
+ Everton Santos (everton2x4 at gmail.com)
+ Jefferson Fernandes (jeffs.fernandes at gmail.com) 
+ Joao Machini (joao.machini at gmail.com)
+ João da Silva (jaodsilv@linux.ime.usp.br)
+ Paulo Meirelles (paulo at softwarelivre.org)
+ Rafael Manso (rr.manzo at gmail.com)
+ Rafael Messias (rmmartins at gmail.com)
+ Renan Teruo (renanteruoc at gmail.com)
+ Rodrigo Souto (rodrigo at colivre.coop.br)
+
+Collaborators (from USP Lab XP course 2010 on another code)
+-----------------------------------------------------------
+
+ Ana Paula Oliveira dos Santos (anapaulao.santos at gmail.com)
+ Lucianna Almeida (lucianna.th at gmail.com)
+ Thiago Colucci (ticolucci at gmail.com)
+ Vinicius Daros (vinicius.k.daros at gmail.com)
+ Viviane Almeida Santos (viviane.almeida at gmail.com)
+
+Advisors
+--------
+
+ Fabio Kon (fabio.kon at ime.usp.br)
+ Alfredo Goldman (gold at ime.usp.br)
  
-README - Mezuro (Kalibro Plugin)
+README - Mezuro (Mezuro Plugin)
 ================================
  
-Mezuro is source code tracking network based on Noosfero Platform with Kalibro Plugin to access Kalibro Web Service.
+Mezuro is a source code tracking platform based on Noosfero social networking
+platform with Mezuro Plugin actived to access Kalibro Web Service.
+
  
 INSTALL
 =======
  
-See the Noosfero install file and include Ruby gem Savon:
+Dependences
+-----------
+
+See the Noosfero install file. After install Noosfero, install Mezuro dependences:
  
-gem install savon
+$ gem install nokogiri -v 1.5.0
+$ gem install savon -v 0.9.7
+$ gem install googlecharts
  
-Also, you need to enable Mezuro Plugin in the Noosfero:
+Enable Plugin
+-------------
+
+Also, you need to enable Mezuro Plugin at you Noosfero:
  
 cd <your_noosfero_dir>
 ./script/noosfero-plugins enable mezuro
  
-To run Mezuro (kalibro Plugin) and its acceptance tests, you need to install the Kalibro Service. 
+
+Install Service
+---------------
+
+To run Mezuro (Noosfero with Mezuro Plugin), you need to install the Kalibro
+Service. 
+
 For that, access https://gitorious.org/kalibro/kalibro/blobs/master/INSTALL
  
  
-SOURCE CODE
+Configure Service Address
+-------------------------
+
+Finally, copy service.yaml.example to service.yaml and define your Kalibro
+Service address:
+
+$ cd <your_noosfero_dir>/plugin/mezuro
+$ cp service.yaml.example service.yaml
+
+If you install Kalibro Service at localhost, just keep the default
+adress:
+
+http://localhost:8080/KalibroService/
+
+Applying Mezuro Theme
+---------------------
+
+$ cd public/designs/themes && rm -f default
+$ git clone git://gitorious.org/mezuro/mezuro-theme.git
+$ ln -s mezuro-theme/ default && cd ../../../
+
+Active Plugin
+-------------
+
+As a Noosfero administrator user, go to administrator panel:
+
+- Click on "Enable/disable plugins" option
+- Click on "Mezuro Plugin" check-box
+
+
+DEVELOPMENT
 ===========
  
-To get the Mezuro (Noosfero with Kalibro Plugin) development repository:
+Get the Mezuro (Noosfero with Mezuro Plugin) development repository:
  
-git clone https://gitorious.org/+mezuro/noosfero/mezuro-noosfero-plugin
-cd mezuro-noosfero-plugin
-git checkout mezuro
+$ git clone https://gitorious.org/+mezuro/noosfero/mezuro
+$ cd mezuro
+$ git checkout mezuro
  
-AUTHORS
-=======
+Running Mezuro tests
+--------------------
  
-Please see the file AUTHORS.
+$ rake test:noosfero_plugins:mezuro
  
-BUGS
-====
  
-If you found any bug, please report at mezuro@listas.softwarelivre.org
-(http://listas.softwarelivre.org/cgi-bin/mailman/listinfo/mezuro)
+Get Involved
+============
+
+If you found any bug and/or want to collaborate, please send an e-mail to
+paulo@softwarelivre.org
+
  
 LICENSE
 =======
-Copyright (c) The Authors developers.
+
+Copyright (c) The Author developers.
  
 See Noosfero license.
  
  
+AUTHORS
+=======
+
+Please, see the Mezuro AUTHORS file.
+
+
 ACKNOWLEDGMENTS
 ===============
  
 The authors have been supported by organizations:
  
+University of São Paulo (USP)
+FLOSS Competence Center
+http://ccsl.ime.usp.br
+
 Brazilian National Research Council (CNPQ)
 http://www.cnpq.br/
-
-USP FLOSS Competence Center
-http://ccsl.ime.usp.br/
@@ -0,0 +1,73 @@
+README/TODO do branch cucumber_tests
+
+Tarefas:
+- Escrever uma história (procurar uma já escrita) para isso
+- Descobrir o porquê dos erros nos testes do mezuro (repository_url)
+- Dar rebase com o mezuro-dev (os tais testes passam no mezuro-dev)
+- Fazer mais testes
+- Ver como/quando o selenium pode ser integrado ao projeto (conversar com noosfero/ talvez até tentar implementar alguma coisa??)
+
+
+Testes de aceitação a serem feitos: (* já feito)
+
+Projetos:
+  Criar
+    * correto
+    * errado
+    duplicado
+  Editar
+    correto
+    errado
+  Deletar(não precisa fazer - problema do noosfero)
+
+Configurações:
+  criar
+    *correta
+    *errado (sem titulo)
+    *duplicada
+  editar - verificar se mantem as metricas
+    correto
+    não é possível mudar o titulo
+  deletar (não precisa fazer - problema do noosfero)
+  metricas:
+    criar
+      nativa:
+        *correta
+        *errada
+        duplicada (é pra funcionar?)
+      composta:
+        *correta
+        errada
+        duplicada
+    editar
+      para metrica correta
+      para metrica errada
+    *deletar
+    ranges:
+      criar
+        *range correto
+        range errado
+          todos os casos
+      editar
+        para range correto
+        para range errado
+      deletar
+      
+Testes falhando:
+
+Arquivo adding_metric_configuration.feature:
+  Scenario: adding a native metric configuration without code
+    Precisa do selenium para ver em qual página está.
+  Scenario: adding a compound metric configuration
+  Scenario: adding a compound metric configuration with invalid script
+    As métricas compostas não estão salvando direito.
+  
+
+Arquivo creating_project.feature:
+  Scenario: I create a Kalibro project with valid attributes
+    ás vezes falha por erro de já existir na Kalibro. Esse erro teóricamente já havia sido resolvido. 
+
+
+Arquivo adding_ranges.feature:
+  Scenario: adding a range to a metric configuration
+    Precisa do selenium para esperar a página carregar.
@@ -0,0 +1,126 @@
+class MezuroPluginMyprofileController < ProfileController
+
+  append_view_path File.join(File.dirname(__FILE__) + '/../views')
+
+ 
+  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]
+    @supported_metrics = Kalibro::BaseTool.find_by_name(@base_tool).supported_metrics
+  end
+  
+  def new_metric_configuration
+    @configuration_content = profile.articles.find(params[:id])
+    @metric = Kalibro::BaseTool.find_by_name(params[:base_tool]).metric params[:metric_name]
+  end
+  
+  def new_compound_metric_configuration
+    @configuration_content = profile.articles.find(params[:id])
+    @metric_configurations = @configuration_content.metric_configurations
+  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
+  end
+
+  def edit_compound_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_configurations = @configuration_content.metric_configurations
+    @metric = @metric_configuration.metric
+  end
+  
+  def create_metric_configuration
+    id = params[:id]
+    metric_name = params[:metric_configuration][:metric][:name]
+    (Kalibro::MetricConfiguration.new(params[:metric_configuration])).save
+    redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
+  end
+  
+  def create_compound_metric_configuration
+    id = params[:id]
+    metric_name = params[:metric_configuration][:metric][:name]
+    Kalibro::MetricConfiguration.new(params[:metric_configuration]).save
+    redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?id=#{id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
+  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]
+    redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
+  end
+
+  def update_compound_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]
+    redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
+  end
+
+  def remove_metric_configuration
+    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)
+    metric_configuration.destroy
+    redirect_to "/#{profile.identifier}/#{configuration_content.slug}"
+  end
+  
+  def new_range
+    @configuration_content = profile.articles.find(params[:id])
+    @metric_name = params[:metric_name]
+    @range = Kalibro::Range.new
+  end
+  
+  def edit_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)
+    @range = metric_configuration.ranges.find{|range| range.beginning == @beginning_id.to_f || @beginning_id =="-INF" }
+  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
+  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
+  end
+  
+  def remove_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)
+    metric_configuration.ranges.delete_if { |range| range.beginning == beginning_id.to_f || beginning_id == "-INF" }
+    metric_configuration.save
+    formatted_metric_name = metric_name.gsub(/\s/, '+')
+    if metric_configuration.metric.class == Kalibro::CompoundMetric
+      redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
+    else
+      redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
+    end
+  end
+
+end
 class MezuroPluginProfileController < ProfileController
  
-  def metrics
-    project_content = profile.articles.find(params[:id])
-    module_name = params[:module_name]
-    render :partial => 'content_viewer/module_result', :locals => { :module_result => project_content.module_result(module_name) }
+  append_view_path File.join(File.dirname(__FILE__) + '/../views')
+  
+  def project_state
+    @content = profile.articles.find(params[:id])
+    project = @content.project
+    state = project.error.nil? ? project.state : "ERROR"
+    render :text => state
   end
  
+  def project_error
+    @content = profile.articles.find(params[:id])
+    @project = @content.project
+    render :partial => 'content_viewer/project_error'
+  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)
+    render :partial => 'content_viewer/project_result'
+  end 	
+
+  def module_result
+    @content = profile.articles.find(params[:id])
+    @module_result = @content.module_result(params)
+    render :partial => 'content_viewer/module_result'
+  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
+    @source_tree = project_result.node_of(params[:module_name])
+    render :partial =>'content_viewer/source_tree'
+  end
+
+  def module_metrics_history
+    metric_name = params[:metric_name]
+    @content = profile.articles.find(params[:id])
+    module_history = @content.result_history(params[:module_name])
+    @score_history = filtering_metric_history(metric_name, module_history)
+    render :partial => 'content_viewer/score_history'
+  end
+
+  def module_grade_history
+    @content = profile.articles.find(params[:id])
+    modules_results = @content.result_history(params[:module_name])
+    @score_history = modules_results.collect { |module_result| module_result.grade }
+    render :partial => 'content_viewer/score_history'
+  end
+  
+  private
+  
+  def filtering_metric_history(metric_name, module_history)
+    metrics_history = module_history.map do |module_result|
+      module_result.metric_results
+    end
+    metric_history =  metrics_history.map do |array_of_metric_result|
+      (array_of_metric_result.select do |metric_result|
+        metric_result.metric.name.delete("() ") == metric_name
+      end).first
+    end
+    metric_history.map do |metric_result|
+      metric_result.value
+    end
+  end
 end
@@ -1,69 +0,0 @@
-Feature: mezuro content
-  As a noosfero user
-  I want to create a Kalibro 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 Kalibro project as an option to new content
-    Given I am on My Community's cms
-    When I follow "New content"
-    Then I should see "Kalibro project"
-
-  Scenario: I see Kalibro project's input form
-    Given I am on My Community's cms
-    When I follow "New content"
-    And I follow "Kalibro 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 sample mezuro content
-    Given I am on My Community's cms
-    When I create a content of type "Kalibro project" with the following data
-      | Title           | Sample project          |
-      | License         | BSD                     |
-      | Repository type | GIT                     |
-      | Repository url  | git://example           |
-    Then I should see "Sample project"
-    And I should see "Viewed one time"
-    And I should see "BSD"
-
-  Scenario: I create a real mezuro content
-    Given I am on My Community's cms
-    When I create a content of type "Kalibro project" with the following data
-      | Title           | Qt-Calculator           |
-      | License         | GPL 2.0                 |
-      | Repository type | SUBVERSION              |
-      | Repository url  | https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator |
-    Then I should see "Qt-Calculator"
-
-  Scenario: I see results from a real Kalibro project
-    Given I am on My Community's cms
-    When I create a content of type "Kalibro project" with the following data
-      | Title           | Qt-Calculator           |
-      | License         | GPL                     |
-      | Repository type | SUBVERSION              |
-      | Repository url  | https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator |
-      | Configuration   | Kalibro for Java        |
-   Then I should see "Qt-Calculator"
-   And I should see "GPL"
-   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"
-   And I should see "Kalibro Service is loading the source code"
@@ -0,0 +1,29 @@
+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
+
+  def self.find_by_name(base_tool_name)
+    new request("BaseTool", :get_base_tool, {:base_tool_name => base_tool_name})[:base_tool]
+  end
+
+  def supported_metric=(value)
+    @supported_metric = Kalibro::NativeMetric.to_objects_array value
+  end
+
+  def supported_metrics
+    @supported_metric
+  end
+
+  def supported_metrics=(supported_metrics)
+    @supported_metric = supported_metrics
+  end
+
+  def metric(name)
+    supported_metrics.find {|metric| metric.name == name}
+  end
+
+end
@@ -1,16 +0,0 @@
-class Kalibro::Client::BaseToolClient
-  
-  def initialize
-    @port = Kalibro::Client::Port.new('BaseTool')
-  end
-
-  def base_tool_names
-    @port.request(:get_base_tool_names)[:base_tool_name].to_a
-  end
-
-  def base_tool(name)
-    hash = @port.request(:get_base_tool, {:base_tool_name => name})[:base_tool]
-    Kalibro::Entities::BaseTool.from_hash(hash)
-  end
-
-end
 \ No newline at end of file
@@ -1,31 +0,0 @@
-class Kalibro::Client::ConfigurationClient
-
-  def initialize
-    @port = Kalibro::Client::Port.new('Configuration')
-  end
-
-  def save(configuration)
-    @port.request(:save_configuration, {:configuration => configuration.to_hash})
-  end
-
-  def self.save(configuration)
-    new.save(configuration)
-  end
-
-  def configuration_names
-    @port.request(:get_configuration_names)[:configuration_name].to_a
-  end
-
-  def configuration(name)
-    hash = @port.request(:get_configuration, {:configuration_name => name})[:configuration]
-    Kalibro::Entities::Configuration.from_hash(hash)
-  end
-
-  def remove(configuration_name)
-    @port.request(:remove_configuration, {:configuration_name => configuration_name})
-  end
-
-  def self.remove(configuration_name)
-    new.remove(configuration_name)
-  end
-end
@@ -1,19 +0,0 @@
-class Kalibro::Client::KalibroClient
-  
-  def initialize
-    @port = Kalibro::Client::Port.new('Kalibro')
-  end
-
-  def supported_repository_types
-    @port.request(:get_supported_repository_types)[:repository_type].to_a
-  end
-
-  def process_project(project_name)
-    @port.request(:process_project, {:project_name => project_name})
-  end
-
-  def self.process_project(project_name)
-    new.process_project(project_name)
-  end
-
-end
@@ -1,27 +0,0 @@
-class Kalibro::Client::ModuleResultClient
-  
-  def initialize
-    @port = Kalibro::Client::Port.new('ModuleResult')
-  end
-
-  def module_result(project_name, module_name, date)
-    hash = @port.request(:get_module_result,
-      {:project_name => project_name, :module_name => module_name,
-       :date => date_with_milliseconds(date)})[:module_result]
-    Kalibro::Entities::ModuleResult.from_hash(hash)
-  end
-
-  def result_history(project_name, module_name)
-    value = @port.request(:get_result_history,
-      {:project_name => project_name, :module_name => module_name})[:module_result]
-    Kalibro::Entities::Entity.new.to_entity_array(value, Kalibro::Entities::ModuleResult)
-  end
-
-  private
-
-  def 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
-
-end
 \ No newline at end of file
@@ -1,26 +0,0 @@
-require 'savon'
-
-Savon.configure do |config|
-  config.log = HTTPI.log = (RAILS_ENV == 'development')
-end
-
-class Kalibro::Client::Port
-
-  def initialize(endpoint)
-    @client = Savon::Client.new("#{service_address}#{endpoint}Endpoint/?wsdl")
-  end
-
-  def service_address
-    if @service_address.nil?
-      service_file = "#{RAILS_ROOT}/plugins/mezuro/SERVICE"
-      File.open(service_file).each_line{ | line | @service_address = line }
-    end
-    @service_address
-  end
-
-  def request(action, request_body = nil)
-    response = @client.request(:kalibro, action) { soap.body = request_body }
-    response.to_hash["#{action}_response".to_sym]
-  end
-
-end
@@ -1,31 +0,0 @@
-class Kalibro::Client::ProjectClient
-
-  def initialize
-    @port = Kalibro::Client::Port.new('Project')
-  end
-
-  def save(project)
-    @port.request(:save_project, {:project => project.to_hash})
-  end
-
-  def self.save(project)
-    new.save(project)
-  end
-
-  def project_names
-    @port.request(:get_project_names)[:project_name].to_a
-  end
-
-  def project(name)
-    hash = @port.request(:get_project, {:project_name => name})[:project]
-    Kalibro::Entities::Project.from_hash(hash)
-  end
-
-  def remove(project_name)
-    @port.request(:remove_project, {:project_name => project_name})
-  end
-
-  def self.remove(project_name)
-    new.remove(project_name)
-  end
-end
@@ -1,41 +0,0 @@
-class Kalibro::Client::ProjectResultClient
-
-  def initialize
-    @port = Kalibro::Client::Port.new('ProjectResult')
-  end
-
-  def has_results_for(project_name)
-    @port.request(:has_results_for, {:project_name => project_name})[:has_results]
-  end
-
-  def has_results_before(project_name, date)
-    @port.request(:has_results_before, {:project_name => project_name, :date => date})[:has_results]
-  end
-
-  def has_results_after(project_name, date)
-    @port.request(:has_results_after, {:project_name => project_name, :date => date})[:has_results]
-  end
-
-  def first_result(project_name)
-    hash = @port.request(:get_first_result_of, {:project_name => project_name})[:project_result]
-    Kalibro::Entities::ProjectResult.from_hash(hash)
-  end
-
-  def last_result(project_name)
-    hash = @port.request(:get_last_result_of, {:project_name => project_name})[:project_result]
-    Kalibro::Entities::ProjectResult.from_hash(hash)
-  end
-
-  def first_result_after(project_name, date)
-    request_body = {:project_name => project_name, :date => date}
-    hash = @port.request(:get_first_result_after, request_body)[:project_result]
-    Kalibro::Entities::ProjectResult.from_hash(hash)
-  end
-
-  def last_result_before(project_name, date)
-    request_body = {:project_name => project_name, :date => date}
-    hash = @port.request(:get_last_result_before, request_body)[:project_result]
-    Kalibro::Entities::ProjectResult.from_hash(hash)
-  end
-
-end
 \ No newline at end of file
@@ -0,0 +1,5 @@
+class Kalibro::CompoundMetric < Kalibro::Metric
+
+  attr_accessor :script
+
+end
@@ -0,0 +1,13 @@
+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
@@ -0,0 +1,45 @@
+class Kalibro::Configuration < Kalibro::Model
+
+  attr_accessor :name, :description, :metric_configuration
+
+  def metric_configuration=(value)
+    @metric_configuration = Kalibro::MetricConfiguration.to_objects_array value
+  end
+
+  def metric_configurations
+    if @metric_configuration != nil
+      @metric_configuration
+    else
+      []
+    end
+  end
+
+  def metric_configurations=(metric_configurations)
+    @metric_configuration = metric_configurations
+  end
+
+  def self.find_by_name(configuration_name)
+    begin
+      new request("Configuration", :get_configuration, {:configuration_name => configuration_name})[:configuration]
+    rescue Exception => error
+      nil
+    end
+  end
+
+  def self.all_names
+    begin
+      request("Configuration", :get_configuration_names)[:configuration_name]
+    rescue Exception
+      []
+    end
+  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
@@ -1,17 +0,0 @@
-class Kalibro::Entities::BaseTool < Kalibro::Entities::Entity
-  
-  attr_accessor :name, :description, :supported_metric
-
-  def supported_metric=(value)
-    @supported_metric = to_entity_array(value, Kalibro::Entities::NativeMetric)
-  end
-  
-  def supported_metrics
-    @supported_metric
-  end
-
-  def supported_metrics=(supported_metrics)
-    @supported_metric = supported_metrics
-  end
-
-end
 \ No newline at end of file
@@ -1,5 +0,0 @@
-class Kalibro::Entities::CompoundMetric < Kalibro::Entities::Metric
-
-  attr_accessor :script
-
-end
 \ No newline at end of file
@@ -1,13 +0,0 @@
-class Kalibro::Entities::CompoundMetricWithError < Kalibro::Entities::Entity
-  
-  attr_accessor :metric, :error
-
-  def metric=(value)
-    @metric = to_entity(value, Kalibro::Entities::CompoundMetric)
-  end
-  
-  def error=(value)
-    @error = to_entity(value, Kalibro::Entities::Error)
-  end
-
-end
 \ No newline at end of file
@@ -1,17 +0,0 @@
-class Kalibro::Entities::Configuration < Kalibro::Entities::Entity
-
-  attr_accessor :name, :description, :metric_configuration
-
-  def metric_configuration=(value)
-    @metric_configuration = to_entity_array(value, Kalibro::Entities::MetricConfiguration)
-  end
-
-  def metric_configurations
-    @metric_configuration
-  end
-
-  def metric_configurations=(metric_configurations)
-    @metric_configuration = metric_configurations
-  end
-
-end
@@ -1,53 +0,0 @@
-class Kalibro::Entities::Entity
-
-  def self.from_hash(hash)
-    entity = self.new
-    hash.each { |field, value| entity.set(field, value) }
-    entity
-  end
-
-  def set(field, value)
-    send("#{field}=", value)
-  end
-
-  def to_entity_array(value, entity_class = nil)
-    array = value.kind_of?(Array) ? value : [value]
-    array.each.collect { |element| to_entity(element, entity_class) }
-  end
-
-  def to_entity(value, entity_class)
-    value.kind_of?(Hash) ? entity_class.from_hash(value) : value
-  end
-
-  def to_hash
-    hash = Hash.new
-    fields.each do |field|
-      field_value = self.get(field)
-      hash[field] = convert_to_hash(field_value) if ! field_value.nil?
-    end
-    hash
-  end
-
-  def convert_to_hash(value)
-    return value.collect { |element| convert_to_hash(element) } if value.kind_of?(Array)
-    return value.to_hash if value.kind_of?(Kalibro::Entities::Entity)
-    value
-  end
-
-  def ==(other)
-    begin
-      fields.each.inject(true) { |equal, field| equal && (self.get(field) == other.get(field)) }
-    rescue NoMethodError
-      false
-    end
-  end
-
-  def fields
-    instance_variable_names.each.collect { |variable| variable.to_s.sub(/@/, '').to_sym }
-  end
-
-  def get(field)
-    send("#{field}")
-  end
-  
-end
 \ No newline at end of file
@@ -1,17 +0,0 @@
-class Kalibro::Entities::Error < Kalibro::Entities::Entity
-  
-  attr_accessor :message, :stack_trace_element
-
-  def stack_trace_element=(value)
-    @stack_trace_element = to_entity_array(value, Kalibro::Entities::StackTraceElement)
-  end
-  
-  def stack_trace
-    @stack_trace_element
-  end
-
-  def stack_trace=(stack_trace)
-    @stack_trace_element = stack_trace
-  end
-
-end
 \ No newline at end of file
@@ -1,5 +0,0 @@
-class Kalibro::Entities::Metric < Kalibro::Entities::Entity
-  
-  attr_accessor :name, :scope, :description
-
-end
 \ No newline at end of file
@@ -1,26 +0,0 @@
-class Kalibro::Entities::MetricConfiguration < Kalibro::Entities::Entity
-
-  attr_accessor :metric, :code, :weight, :aggregation_form, :range
-
-  def metric=(value)
-    if value.kind_of?(Hash)
-      @metric = to_entity(value, Kalibro::Entities::CompoundMetric) if value.has_key?(:script)
-      @metric = to_entity(value, Kalibro::Entities::NativeMetric) if value.has_key?(:origin)
-    else
-      @metric = value
-    end
-  end
-
-  def range=(value)
-    @range = to_entity_array(value, Kalibro::Entities::Range)
-  end
-
-  def ranges
-    @range
-  end
-
-  def ranges=(ranges)
-    @range = ranges
-  end
-
-end
 \ No newline at end of file
@@ -1,33 +0,0 @@
-class Kalibro::Entities::MetricResult < Kalibro::Entities::Entity
-
-  attr_accessor :metric, :value, :range, :descendent_result, :weight
-
-  def metric=(value)
-    if value.kind_of?(Hash)
-      if value.has_key?(:script)
-        @metric = to_entity(value, Kalibro::Entities::CompoundMetric)
-      else
-        @metric = to_entity(value, Kalibro::Entities::NativeMetric)
-      end
-    else
-      @metric = value
-    end
-  end
-
-  def range=(value)
-    @range = to_entity(value, Kalibro::Entities::Range)
-  end
-
-  def descendent_result=(value)
-    @descendent_result = to_entity_array(value)
-  end
-
-  def descendent_results
-    @descendent_result
-  end
-
-  def descendent_results=(descendent_results)
-    @descendent_result = descendent_results
-  end
-
-end
@@ -1,5 +0,0 @@
-class Kalibro::Entities::Module < Kalibro::Entities::Entity
-
-  attr_accessor :name, :granularity
-
-end
 \ No newline at end of file
@@ -1,29 +0,0 @@
-class Kalibro::Entities::ModuleNode < Kalibro::Entities::Entity
-
-  attr_accessor :module, :child
-
-  def module=(value)
-    @module = to_entity(value, Kalibro::Entities::Module)
-  end
-
-  def module_name
-    @module.name
-  end
-
-  def granularity
-    @module.granularity
-  end
-
-  def child=(value)
-    @child = to_entity_array(value, Kalibro::Entities::ModuleNode)
-  end
-
-  def children
-    @child
-  end
-
-  def children=(children)
-    @child = children
-  end
-
-end
@@ -1,33 +0,0 @@
-class Kalibro::Entities::ModuleResult < Kalibro::Entities::Entity
-
-  attr_accessor :module, :date, :grade, :metric_result, :compound_metric_with_error
-
-  def module=(value)
-    @module = to_entity(value, Kalibro::Entities::Module)
-  end
-
-  def metric_result=(value)
-    @metric_result = to_entity_array(value, Kalibro::Entities::MetricResult)
-  end
-
-  def metric_results
-    @metric_result
-  end
-
-  def metric_results=(metric_results)
-    @metric_result = metric_results
-  end
-
-  def compound_metric_with_error=(value)
-    @compound_metric_with_error = to_entity_array(value, Kalibro::Entities::CompoundMetricWithError)
-  end
-
-  def compound_metrics_with_error
-    @compound_metric_with_error
-  end
-
-  def compound_metrics_with_error=(compound_metrics_with_error)
-    @compound_metric_with_error = compound_metrics_with_error
-  end
-  
-end
 \ No newline at end of file
@@ -1,5 +0,0 @@
-class Kalibro::Entities::NativeMetric < Kalibro::Entities::Metric
-
-  attr_accessor :origin, :language
-
-end
 \ No newline at end of file
@@ -1,13 +0,0 @@
-class Kalibro::Entities::Project < Kalibro::Entities::Entity
-
-	attr_accessor :name, :license, :description, :repository, :configuration_name, :state, :error
-
-  def repository=(value)
-    @repository = to_entity(value, Kalibro::Entities::Repository)
-  end
-
-  def error=(value)
-    @error = to_entity(value, Kalibro::Entities::Error)
-  end
-
-end
 \ No newline at end of file
@@ -1,34 +0,0 @@
-class Kalibro::Entities::ProjectResult < Kalibro::Entities::Entity
-  
-  attr_accessor :project, :date, :load_time, :analysis_time, :source_tree
-
-  def project=(value)
-    @project = to_entity(value, Kalibro::Entities::Project)
-  end
-
-  def source_tree=(value)
-    @source_tree = to_entity(value, Kalibro::Entities::ModuleNode)
-  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
-
-end
 \ No newline at end of file
@@ -1,5 +0,0 @@
-class Kalibro::Entities::Range < Kalibro::Entities::Entity
-  
-  attr_accessor :beginning, :end, :label, :grade, :color, :comments
-
-end
 \ No newline at end of file
@@ -1,5 +0,0 @@
-class Kalibro::Entities::Repository < Kalibro::Entities::Entity
-  
-  attr_accessor :type, :address, :username, :password
-
-end
 \ No newline at end of file
@@ -1,5 +0,0 @@
-class Kalibro::Entities::StackTraceElement < Kalibro::Entities::Entity
-  
-  attr_accessor :declaring_class, :method_name, :file_name, :line_number
-
-end
 \ No newline at end of file
@@ -0,0 +1,21 @@
+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,5 @@
+class Kalibro::Metric < Kalibro::Model
+  
+  attr_accessor :name, :scope, :description
+
+end
@@ -0,0 +1,72 @@
+class Kalibro::MetricConfiguration < Kalibro::Model
+
+  NATIVE_TYPE='native'
+  COMPOUND_TYPE='compound'
+  
+  attr_accessor :metric, :code, :weight, :aggregation_form, :range, :configuration_name
+
+  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
+  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
+  end
+
+  def destroy
+    self.class.request("MetricConfiguration", :remove_metric_configuration, {
+        :configuration_name => configuration_name,
+        :metric_name=> metric.name
+      })
+  end
+  
+  def to_hash
+    super :except => [:configuration_name]
+  end
+
+  private
+  
+  def native?(value)
+    value.has_key?(:origin) ? true : false
+  end
+  
+  def save_params
+    {:metric_configuration => to_hash, :configuration_name => configuration_name}
+  end
+  
+end
@@ -0,0 +1,40 @@
+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
+    end
+  end
+
+  def value=(value)
+    @value = value.to_f
+  end
+
+  def range=(value)
+    @range = Kalibro::Range.to_object value
+  end
+
+  def descendent_result=(value)
+    array = value.kind_of?(Array) ? value : [value]
+    @descendent_result = array.collect {|element| element.to_f}
+  end
+
+  def descendent_results
+    @descendent_result
+  end
+
+  def descendent_results=(descendent_results)
+    @descendent_result = descendent_results
+  end
+  
+  private
+  
+  def native?(value)
+    value.has_key?(:origin) ? true : false
+  end
+
+end
@@ -0,0 +1,126 @@
+class Kalibro::Model
+
+  def initialize(attributes={})
+    attributes.each { |field, value| send("#{field}=", value) if self.class.is_valid?(field) }
+  end
+
+  def to_hash(options={})
+    hash = Hash.new
+    excepts = !options[:except].nil? ? options[:except] : []
+    fields.each do |field|
+      if(!excepts.include?(field))
+        field_value = send(field)
+        hash[field] = convert_to_hash(field_value) if ! field_value.nil?
+        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)  }
+        end
+      end
+    end
+    hash
+  end
+
+  def self.request(endpoint, 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
+
+  def self.to_objects_array value
+    array = value.kind_of?(Array) ? value : [value]
+    array.each.collect { |element| to_object(element) }
+  end
+
+  def self.to_object value
+    value.kind_of?(Hash) ? new(value) : value
+  end 
+  
+  def self.create(attributes={})
+    new_model = new attributes
+    new_model.save
+    new_model
+  end
+
+  def save
+    begin
+      self.class.request(save_endpoint, save_action, save_params)
+	    true
+	  rescue Exception => error
+		  false
+	  end
+  end
+
+  def destroy
+    begin
+      self.class.request(destroy_endpoint, destroy_action, destroy_params)
+    rescue Exception
+    end
+  end
+
+  protected
+
+  def fields
+    instance_variable_names.each.collect { |variable| variable.to_s.sub(/@/, '').to_sym }
+  end
+
+  def convert_to_hash(value)
+    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 'INF' if value.is_a?(Float) and value.infinite? == 1
+    return '-INF' if value.is_a?(Float) and value.infinite? == -1
+    value
+  end
+
+  def xml_class_name(object)
+    xml_name = object.class.name
+    xml_name["Kalibro::"] = ""
+    xml_name[0..0] = xml_name[0..0].downcase
+    xml_name + "Xml"
+  end
+
+  def self.client(endpoint)
+    service_address = YAML.load_file("#{RAILS_ROOT}/plugins/mezuro/service.yaml")
+    Savon::Client.new("#{service_address}#{endpoint}Endpoint/?wsdl")
+  end
+
+  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
+    self.class.name.gsub(/Kalibro::/,"")
+  end
+  
+  def save_endpoint
+    class_name
+  end
+  
+  def save_action
+    "save_#{class_name.underscore}".to_sym
+  end
+  
+  def save_params
+    {class_name.underscore.to_sym => self.to_hash}
+  end
+  
+  def destroy_endpoint
+    class_name
+  end
+  
+  def destroy_action
+    "remove_#{class_name.underscore}".to_sym
+  end
+  
+  def destroy_params
+    {"#{class_name.underscore}_name".to_sym => self.name}
+  end
+
+end
@@ -0,0 +1,18 @@
+class Kalibro::Module < 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
@@ -0,0 +1,21 @@
+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
@@ -0,0 +1,63 @@
+class Kalibro::ModuleResult < Kalibro::Model
+
+  attr_accessor :module, :date, :grade, :metric_result, :compound_metric_with_error
+  
+  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]
+  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)
+  end
+  
+  def module=(value)
+    @module = Kalibro::Module.to_object value
+  end
+
+  def date=(value)
+    @date = value.is_a?(String) ? DateTime.parse(value) : value
+  end
+
+  def grade=(value)
+    @grade = value.to_f
+  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
+  end
+
+  def compound_metric_with_error=(value)
+    @compound_metric_with_error = Kalibro::CompoundMetricWithError.to_objects_array value
+  end
+
+  def compound_metrics_with_error
+    @compound_metric_with_error
+  end
+
+  def compound_metrics_with_error=(compound_metrics_with_error)
+    @compound_metric_with_error = compound_metrics_with_error
+  end
+
+end
@@ -0,0 +1,17 @@
+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,37 @@
+class Kalibro::Project < Kalibro::Model
+
+  attr_accessor :name, :license, :description, :repository, :configuration_name, :state, :error
+
+  def self.all_names
+    request("Project", :get_project_names)[:project_name]
+  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
+  end
+
+  def error=(value)
+    @error = Kalibro::Error.to_object value
+  end
+
+  def process_project(days = '0')
+    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
+  end
+
+	def process_period
+    self.class.request("Kalibro", :get_process_period, {:project_name => name})[:period]
+  end
+
+	def cancel_periodic_process
+    self.class.request("Kalibro", :cancel_periodic_process, {:project_name => name})
+  end
+
+end
@@ -0,0 +1,104 @@
+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_of(module_name)
+    if module_name.nil? or module_name == project.name
+      node = source_tree
+    else
+      node = get_node(module_name)
+    end
+  end
+
+  def get_node(module_name)
+    path = Kalibro::Module.parent_names(module_name)
+    parent = @source_tree
+    path.each do |node_name|
+      parent = get_leaf_from(parent, node_name)
+    end
+    return parent
+  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
@@ -0,0 +1,37 @@
+class Kalibro::Range < Kalibro::Model
+  
+  attr_accessor :beginning, :end, :label, :grade, :color, :comments
+
+  def beginning=(value)
+    @beginning = value.to_f
+    @beginning = -1.0/0.0 if value == "-INF"
+  end
+
+  def beginning
+    if !@beginning.nil?
+      case @beginning.to_s
+        when "-Infinity": "-INF"
+        else @beginning
+      end
+    end
+  end
+
+  def end=(value)
+    @end = value.to_f
+    @end = 1.0/0.0 if value == "INF"
+  end
+
+  def end
+    if !@end.nil?
+      case @end.to_s
+        when "Infinity": "INF"
+        else @end
+      end
+    end
+  end
+
+  def grade=(value)
+    @grade = value.to_f
+  end
+
+end
@@ -0,0 +1,9 @@
+class Kalibro::Repository < Kalibro::Model
+  
+  attr_accessor :type, :address, :username, :password
+
+  def self.repository_types
+    request("Kalibro", :get_supported_repository_types)[:repository_type].to_a
+  end
+
+end
@@ -0,0 +1,9 @@
+class Kalibro::StackTraceElement < Kalibro::Model
+  
+  attr_accessor :declaring_class, :method_name, :file_name, :line_number
+
+  def line_number=(value)
+    @line_number = value.to_i
+  end
+
+end
@@ -9,16 +9,11 @@ class MezuroPlugin &lt; Noosfero::Plugin
   end
  
   def content_types
-    [MezuroPlugin::ProjectContent,
-     MezuroPlugin::ConfigurationContent]
+    [MezuroPlugin::ConfigurationContent, MezuroPlugin::ProjectContent]
   end
  
   def stylesheet?
     true
   end
  
-  def js_files
-    ['javascripts/results.js', 'javascripts/toogle.js']
-  end
-
 end
 class MezuroPlugin::ConfigurationContent < Article
+  validate_on_create :validate_kalibro_configuration_name
+
+  settings_items :description, :configuration_to_clone_name
+
+  after_save :send_configuration_to_service
+  after_destroy :remove_configuration_from_service
  
   def self.short_description
     'Kalibro configuration'
   end
  
   def self.description
-    'Kalibro configuration for some project'
+    'Sets of thresholds to interpret metrics'
   end
  
-  settings_items :description
-
   include ActionView::Helpers::TagHelper
   def to_html(options = {})
     lambda do
@@ -18,27 +22,65 @@ class MezuroPlugin::ConfigurationContent &lt; Article
   end
  
   def configuration
-    Kalibro::Client::ConfigurationClient.new.configuration(title)
+    @configuration ||= Kalibro::Configuration.find_by_name(self.name)
+    if @configuration.nil? 
+      errors.add_to_base("Kalibro Configuration not found")
+    end
+    @configuration
   end
  
-  after_save :send_configuration_to_service
-  after_destroy :remove_configuration_from_service
+  def metric_configurations
+    configuration.metric_configurations
+  end
+
+  def configuration_names
+    ["None"] + Kalibro::Configuration.all_names.sort
+  end
  
   private
  
+  def validate_kalibro_configuration_name
+    existing = configuration_names.map { |a| a.downcase}
+
+    if existing.include?(name.downcase)
+      errors.add_to_base("Configuration name already exists in Kalibro")
+    end
+  end
+
   def send_configuration_to_service
-    Kalibro::Client::ConfigurationClient.save(create_configuration)
+    if editing_configuration?
+      configuration.update_attributes({:description => description})
+    else
+      create_kalibro_configuration
+    end
   end
  
   def remove_configuration_from_service
-    Kalibro::Client::ConfigurationClient.remove(title)
+    configuration.destroy
   end
  
-  def create_configuration
-    configuration = Kalibro::Entities::Configuration.new
-    configuration.name = title
-    configuration.description = description
-    configuration
+  def create_kalibro_configuration
+    attributes = {:name => name, :description => description}
+    if cloning_configuration?
+      attributes[:metric_configuration] = configuration_to_clone.metric_configurations_hash
+    end
+    Kalibro::Configuration.create attributes
+  end
+  
+  def editing_configuration?
+    configuration.present?
+  end
+  
+  def configuration_to_clone
+    @configuration_to_clone ||= find_configuration_to_clone
+  end
+  
+  def find_configuration_to_clone
+    configuration_to_clone_name.nil? ? nil : Kalibro::Configuration.find_by_name(configuration_to_clone_name)
+  end
+  
+  def cloning_configuration?
+    configuration_to_clone.present?
   end
  
 end
@@ -0,0 +1,34 @@
+require 'googlecharts'
+
+class MezuroPlugin::Helpers::ContentViewerHelper
+  def self.format_grade(grade)
+    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]]
+  end
+  
+  def self.generate_chart(values)
+    Gchart.line(  
+                :title_color => 'FF0000',
+                :size => '600x180', 
+                :bg => {:color => 'efefef', :type => 'stripes'},
+                :line_colors => 'c4a000',
+                :data => values,
+                :axis_with_labels => 'y',
+                :max_value => values.max,
+                :min_value => values.min
+                )
+  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
+  end
+  
+  def self.format_name(metric_result)
+    metric_result.metric.name.delete("() ")
+  end
+end
-class MezuroPlugin::ProjectContent < Article 
+class MezuroPlugin::ProjectContent < Article
+  include ActionView::Helpers::TagHelper
+
+  settings_items :license, :description, :repository_type, :repository_url, :configuration_name, :periodicity_in_days
+
+  validate_on_create :validate_kalibro_project_name 
+  validate_on_create :validate_repository_url
  
   def self.short_description
     'Kalibro project'
@@ -8,59 +14,98 @@ class MezuroPlugin::ProjectContent &lt; Article
     'Software project tracked by Kalibro'
   end
  
-  settings_items :license, :description, :repository_type, :repository_url, :configuration_name
-
-  include ActionView::Helpers::TagHelper
   def to_html(options = {})
     lambda do
       render :file => 'content_viewer/show_project.rhtml'
     end
   end
  
-  # FIXME is this really needed?
   def project
-    Kalibro::Client::ProjectClient.new.project(title)
+    begin
+      @project ||= Kalibro::Project.find_by_name(name)
+    rescue Exception => error
+      errors.add_to_base(error.message)
+    end
   end
  
   def project_result
-    @project_result ||= Kalibro::Client::ProjectResultClient.new.last_result(title)
+    begin
+      @project_result ||= Kalibro::ProjectResult.last_result(name)
+    rescue Exception => error
+      errors.add_to_base(error.message)
+    end
+  end
+  
+  def project_result_with_date(date)
+    begin
+      @project_result ||= Kalibro::ProjectResult.has_results_before?(name, date) ? Kalibro::ProjectResult.last_result_before(name, date) : 
+Kalibro::ProjectResult.first_result_after(name, date)
+    rescue Exception => error
+      errors.add_to_base(error.message)
+    end
   end
  
-  def module_result(module_name)
-    @module_client ||= Kalibro::Client::ModuleResultClient.new
-    @module_client.module_result(title, module_name, project_result.date)
+  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
+  end
+
+  def result_history(module_name)
+    begin
+      @result_history ||= Kalibro::ModuleResult.all_by_project_name_and_module_name(name, module_name)
+    rescue Exception => error
+      errors.add_to_base(error.message)
+    end
   end
  
   after_save :send_project_to_service
-  after_destroy :remove_project_from_service
+  after_destroy :destroy_project_from_service
  
   private
  
-  def send_project_to_service
-    Kalibro::Client::ProjectClient.save(create_project)
-    Kalibro::Client::KalibroClient.process_project(title)
+  def validate_kalibro_project_name
+    begin
+      existing = Kalibro::Project.all_names
+    rescue Exception => error
+      errors.add_to_base(error.message)
+    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 remove_project_from_service
-    Kalibro::Client::ProjectClient.remove(title)
+  
+  def validate_repository_url
+    if(repository_url.nil? || repository_url == "")
+      errors.add_to_base("Repository URL is mandatory")
+    end
+  end
+  
+  def send_project_to_service
+    created_project = create_kalibro_project
+    created_project.process_project(periodicity_in_days)
   end
  
-  def create_project
-    project = Kalibro::Entities::Project.new
-    project.name = title
-    project.license = license
-    project.description = description
-    project.repository = create_repository
-    project.configuration_name = configuration_name
-    project
+  def create_kalibro_project
+   Kalibro::Project.create(
+      :name => name,
+      :license => license,
+      :description => description,
+      :repository => {
+        :type => repository_type,
+        :address => repository_url
+      },
+      :configuration_name => configuration_name
+    )
   end
  
-  def create_repository
-    repository = Kalibro::Entities::Repository.new
-    repository.type = repository_type
-    repository.address = repository_url
-    repository
+  def destroy_project_from_service
+    project.destroy
   end
  
 end
-
@@ -0,0 +1,150 @@
+var processingTree = false;
+var metricName;
+jQuery(function (){
+  jQuery('.source-tree-link').live("click", reloadModule);
+  jQuery('[data-show]').live("click", toggle_mezuro);
+  jQuery('[show-metric-history]').live("click", display_metric_history);
+  jQuery('[show-grade-history]').live("click", display_grade_history);
+  jQuery('#project_date_submit').live("click", reloadProjectWithDate);
+  showLoadingProcess(true);
+  showProjectContent();
+});
+
+function showProjectContent() {
+  callAction('project_state', {}, showProjectContentFor);
+}
+
+function display_metric_history() {
+  var module_name = jQuery(this).attr('data-module-name');
+  var metric_name = jQuery(this).attr('data-metric-name');
+  metricName = metric_name;
+  callAction('module_metrics_history', {module_name: module_name, metric_name: metric_name}, show_metrics);
+  return false;
+}
+
+function display_grade_history() {
+  var module_name = jQuery(this).attr('data-module-name');
+  callAction('module_grade_history', {module_name: module_name}, 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(){
+  var element = jQuery(this).attr('data-show');
+  jQuery(element).toggle();
+  return false;
+}
+
+function reloadModule(){
+  var module_name = jQuery(this).attr('data-module-name');
+  showLoadingProcess(false);
+  processingTree = true;
+  callAction('project_tree', {module_name: module_name }, showProjectTree);
+  callAction('module_result', {module_name: module_name}, showModuleResult);
+  return false;
+}
+
+function reloadProjectWithDate(){
+	var day = jQuery("#project_date_day").val();
+	var month = jQuery("#project_date_month").val();
+	var year = jQuery("#project_date_year").val();
+
+  if(day.length == 1) 
+    day = "0" + day;
+  if(month.length == 1) 
+    month = "0" + month; 
+	
+	var date = new Date(year + "-" + month + "-" + day + "T00:00:00+00:00");
+	
+	if(isNaN(date)){
+	  alert("Invalid date! " + date);
+	  return false;
+	}
+	reloadProject(date);
+  return false;
+}
+
+function reloadProject(date){
+  showLoadingProcess(true);
+  
+  callAction('project_result', {date: date}, showProjectResult);
+  callAction('project_tree', {date: date}, showProjectTree);
+  callAction('module_result', {date: date}, showModuleResult);
+}
+
+function showProjectContentFor(state){
+  if (state == 'ERROR') {
+    jQuery('#project-state').html('ERROR');
+    callAction('project_error', {}, showProjectResult);
+  }
+  else if (state == 'READY') {
+    jQuery('#msg-time').html('');
+    jQuery('#project-state').html('READY');
+    callAction('project_result', {}, showProjectResult);
+    callAction('project_tree', {}, showProjectTree);
+    var project_name = jQuery("#project-result").attr('data-project-name');
+    callAction('module_result', {module_name: project_name}, showModuleResult);
+  } 
+  else if (state.endsWith("ING")) {
+    jQuery('#project-state').html(state);
+    jQuery('#msg-time').html("The project analysis may take long. <br/> You'll receive an e-mail when it's ready!");
+    showProjectContentAfter(20);
+  }	
+}
+
+function showProjectContentAfter(seconds){
+  if (seconds > 0){
+    setTimeout(function() { showProjectContentAfter(seconds - 10);}, 10000);
+  } else {
+    showProjectContent();
+  }
+}
+
+function showProjectResult(content) {
+  jQuery('#project-result').html(content);
+}
+
+function showProjectTree(content){ 
+  processingTree = false;
+  jQuery('#project-tree').html(content);
+	return false;
+}
+
+function showModuleResult(content){
+  if (processingTree != true){ 
+    jQuery('#module-result').html(content);
+  }
+  return false;
+}
+
+function callAction(action, params, callback){
+  var profile = projectContentData('profile');
+  var content = projectContentData('content');
+  var endpoint = '/profile/' + profile + '/plugins/mezuro/' + action + '/' + content;
+  jQuery.get(endpoint, params, callback);
+}
+
+function projectContentData(data){
+  return jQuery('#project-result').attr('data-' + data);
+}
+
+function showLoadingProcess(firstLoad){
+	if(firstLoad)	
+  	showProjectResult("<img src='/images/loading-small.gif'/>");
+	
+  showProjectTree("<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();
+}
@@ -1,21 +0,0 @@
-function results($) {
-  $('.module-result-link').click(show_module_result);
-}
-
-function show_module_result(){
-  var profile = jQuery('#module-result').attr('data-profile');
-  var project = jQuery('#module-result').attr('data-project-id');
-  var module_name = jQuery(this).attr('data-module-name');
-  var endpoint = '/profile/' + profile + '/plugins/mezuro/metrics/' + project;
-  show_loading_message(module_name);
-  jQuery.get(endpoint, {module_name: module_name}, show_result_table);
-  return false;
-}
-
-function show_loading_message(module_name) {
-  jQuery('#module-result').html("Loading results for " + module_name + "...");
-}
-
-function show_result_table(content){
-  jQuery('#module-result').html(content);
-}
 \ No newline at end of file
@@ -1,6 +0,0 @@
-function toogle(id){
-  var suffixes = ['_hidden', '_plus', '_minus'];
-  for (var i in suffixes){
-    jQuery('#' + id + suffixes[i]).toggle();
-  }
-}
 \ No newline at end of file
@@ -0,0 +1,77 @@
+jQuery(function (){
+  jQuery('#range_submit').live("click", validate_new_range_configuration);
+  jQuery('#metric_configuration_submit').live("click", validate_metric_configuration);
+});
+
+
+
+function validate_metric_configuration(){
+    var code = jQuery('#metric_configuration_code').val();
+    if (is_null(code))
+    {
+        alert("Code must be filled out");
+        return false;
+    }
+    return true;
+}
+
+function is_null(value){
+    if(value == "" || value == null){
+      return true;
+    }
+    return false;
+}
+
+function IsNotNumeric(value){
+    if(value.match(/[0-9]*\.?[0-9]+/))
+    {
+      return false;
+    }
+    return true;
+}
+
+function IsNotInfinite(value){
+    if(value.match(/INF/)){
+      return false;
+    }
+    return true;
+}
+
+function IsNotHexadecimal(value){
+    if(value.match(/^[0-9a-fA-F]{1,8}$/))
+    {
+      return false;
+    }
+    return true;
+}
+
+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))
+    {
+        alert("Please fill all fields marked with (*)");
+        return false;
+    }
+    if ( (IsNotNumeric(beginning) && IsNotInfinite(beginning)) || (IsNotNumeric(end) && IsNotInfinite(end)) || IsNotNumeric(grade))
+    {
+        alert("Beginning, End and Grade must be numeric values");
+        return false;
+    }
+    if (parseInt(beginning) > parseInt(end))
+    {
+        if(IsNotInfinite(beginning) && IsNotInfinite(end)){
+          alert("End must be greater than Beginning");
+          return false;
+        }
+    }
+    if (IsNotHexadecimal(color)){
+        alert("Color must be an hexadecimal value");
+        return false;
+    }
+    return true;
+}
 .link {
     cursor: pointer;
 }
+
+.source-tree{
+	background: #e7e7e7;
+	border: groove 1px #666;
+}
+
+.icon {
+        width: 20px;
+}
+
+.source-tree-text{
+	font-family: Arial, Impact;
+	font-size: 12px;
+	border-left: solid 1px #666;
+}
+
+a:link,active,visited .ancestor{
+        font-family: Arial, Impact;
+        color: #5E5400;
+}
+
+.path{
+	font-family: Arial, Impact;
+	font-size: 14px;
+	font-style: underline;
+	display: inline;
+}
@@ -0,0 +1,2 @@
+http://localhost:8080/KalibroService/
+# http://valinhos.ime.usp.br:50688/KalibroService/
@@ -0,0 +1,67 @@
+Feature: Add metric configuration to a configuration 
+  As a mezuro user
+  I want to add metric configurations to a Kalibro configuration
+
+  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"
+    And I am on My Community's cms
+    And I create a content of type "Kalibro configuration" with the following data
+      | Title           | My Configuration     |
+      | Description     | A sample description |
+      
+  Scenario: adding a native metric configuration
+    When I follow "Add metric"
+    And I follow "Analizo"
+    And I follow "Lines of Code"
+    And I fill in the following:
+      | Code:           | Sample Code           |
+      | Weight:         | 10.0                  |
+    And I select "Average" from "Aggregation Form:"
+    And I press "Add"
+    Then I should see "Lines of Code"
+    And I should see "Analizo"
+    And I should see "Sample Code"
+    
+  Scenario: adding a native metric configuration without code
+    When I follow "Add metric"
+    And I follow "Analizo"
+    And I follow "Number of Children"
+    And I don't fill anything
+    And I press "Add"
+    Then I should be at the url "/myprofile/my-community/plugin/mezuro/new_metric_configuration"
+    
+  Scenario: adding a compound metric configuration
+    When I follow "Add metric"
+    And I follow "New Compound Metric"
+    And I fill in the following:
+      | Name:           | Compound sample   |
+      | Description:    | 10.0              |
+      | Script:         | return 42;        |
+      | Code:           | anyCode           |
+      | Weight:         | 10.0              |
+    And I select "Class" from "Scope:"
+    And I select "Average" from "Aggregation Form:"
+    And I press "Add"
+    Then I should see "Compound sample"
+    
+  Scenario: adding a compound metric configuration with invalid script
+    When I follow "Add metric"
+    And I follow "New Compound Metric"
+    And I fill in the following:
+      | Name:           | Compound sample   |
+      | Description:    | 10.0              |
+      | Script:         | invalid script    |
+      | Code:           | anyCode           |
+      | Weight:         | 10.0              |
+    And I select "Class" from "Scope:"
+    And I select "Average" from "Aggregation Form:"
+    And I press "Add"
+    Then I should see "Compound sample"
@@ -0,0 +1,42 @@
+Feature: Add range to a metric configuration 
+  As a mezuro user
+  I want to add ranges to a Kalibro metric configuration
+
+  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"
+    And I am on My Community's cms
+    And I create a content of type "Kalibro configuration" with the following data
+      | Title           | My Configuration     |
+      | Description     | A sample description |
+    And I follow "Add metric"
+    And I follow "Analizo"
+    And I follow "Lines of Code"
+    And I fill in the following:
+      | Code:           | Sample Code           |
+      | Weight:         | 10.0                  |
+    And I select "Average" from "Aggregation Form:"
+    And I press "Add"
+    Then I should see "Lines of Code"
+    And I should see "Analizo"
+    And I should see "Sample Code"
+    
+  Scenario: adding a range to a metric configuration
+    When I follow "New Range" and wait
+    And I fill in the following:
+      | (*) Label:       | label       |
+      | (*) Beginning:   | 1           |
+      | (*) End:         | 10          |
+      | (*) Grade:       | 100         |
+      | (*) Color:       | FFFF00FF    |
+      | Comments:        | Comentário  |
+    And I press "Save Range" and wait
+    And I should see "label" within "#ranges"
+
@@ -0,0 +1,40 @@
+Feature: Create configuration 
+  As a mezuro user
+  I want to create a Kalibro configuration
+
+  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: creating with valid attributes
+    Given I am on My Community's cms
+    When I create a content of type "Kalibro configuration" with the following data
+      | Title           | Qt_Calculator         |
+      | Description     | A sample description  |
+    Then I should see "Name"
+    And I should see "Qt_Calculator"
+    And I should see "Description"
+    And I should see "A sample description"
+    
+   Scenario: creating with duplicated name
+    Given I am on My Community's cms
+    And I create a content of type "Kalibro configuration" with the following data
+      | Title           | Original Title          |
+    And I am on My Community's cms
+    When I create a content of type "Kalibro configuration" with the following data
+      | Title           | Original Title          |
+    Then I should see "1 error prohibited this article from being saved"  
+    
+  Scenario: creating without title
+    Given I am on My Community's cms
+    When I create a content of type "Kalibro configuration" with the following data
+      | Title           |          |
+    Then I should see "1 error prohibited this article from being saved"
+
@@ -0,0 +1,55 @@
+Feature: Create project
+  As a mezuro user
+  I want to create a Kalibro 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 Kalibro project's input form
+    Given I am on My Community's cms
+    When I follow "New content"
+    And I follow "Kalibro 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 Kalibro project with valid attributes
+    Given I am on My Community's cms
+    When I create a content of type "Kalibro project" with the following data
+      | Title           | Sample Project      |
+      | License         | GPL                 |
+      | 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 "GPL"
+   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"
+   And I directly delete content with name "Sample Project" for testing purposes
+   
+  Scenario: I can't create a Kalibro project with invalid attributes
+    Given I am on My Community's cms
+    When I create a content of type "Kalibro project" with the following data
+      | Title           |                     |
+      | License         | GPL                 |
+      | Repository type | SUBVERSION          |
+      | Repository url  |                     |
+      | Configuration   | Kalibro for Java    |
+   Then I should see "Title can't be blank"
+   And I should see "Missing repository url"
@@ -0,0 +1,90 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
+
+class EchoPortTest < ActiveSupport::TestCase
+
+  def setup
+    @port = Kalibro::Client::Port.new('Echo')
+    address = YAML.load_file("#{RAILS_ROOT}/plugins/mezuro/service.yaml")
+    address['KalibroService'] = 'KalibroFake'
+    @port.service_address=(address);
+  end
+
+  should 'echo base tool' do
+    test BaseToolFixtures.analizo, 'BaseTool' do |base_tool|
+      base_tool.name = "echo " + base_tool.name
+    end
+  end
+  
+  should 'echo configuration' do
+    test ConfigurationFixtures.kalibro_configuration, 'Configuration' do |configuration|
+      configuration.name = "echo " + configuration.name
+    end
+  end
+
+  should 'echo metric configuration' do
+    test_metric_configuration(MetricConfigurationFixtures.amloc_configuration)
+    test_metric_configuration(MetricConfigurationFixtures.sc_configuration)
+  end
+
+  should 'echo module result' do
+    test ModuleResultFixtures.create, 'ModuleResult' do |module_result|
+      module_result.module.name = "echo." + module_result.module.name
+    end
+  end
+
+  should 'echo project' do
+    test(ProjectFixtures.qt_calculator, 'Project') do |project|
+      project.name = "echo " + project.name
+    end
+  end
+
+  should 'echo project result' do
+    test(ProjectResultFixtures.qt_calculator, 'ProjectResult') do |project_result|
+      project_result.project.name = "echo " + project_result.project.name
+    end
+  end
+
+  should 'echo raw project' do
+    project = ProjectFixtures.qt_calculator
+    echoed = @port.request(:echo_raw_project, {:project => project.to_hash})[:project]
+    project.name = "echo " + project.name
+    project.state = nil
+    project.error = nil
+    assert_equal project, Kalibro::Entities::Project.from_hash(echoed)
+  end
+
+  should 'work with enums' do
+    test_granularity("METHOD", "CLASS")
+    test_granularity("CLASS", "PACKAGE")
+    test_granularity("PACKAGE", "PACKAGE")
+    test_granularity("APPLICATION", "APPLICATION")
+  end
+
+  private
+  
+  def test_metric_configuration(fixture)
+    test fixture, 'MetricConfiguration' do |metric_configuration|
+      metric_configuration.code = "echo_" + metric_configuration.code
+    end
+  end
+
+  def test(fixture, entity_name)
+    entity_symbol = entity_name.underscore.to_sym
+    request_body = {entity_symbol => fixture.to_hash}
+    echoed = @port.request("echo_#{entity_symbol}".to_sym, request_body)[entity_symbol]
+    yield fixture
+    entity_class = "Kalibro::Entities::#{entity_name}".constantize
+    assert_equal fixture, entity_class.from_hash(echoed)
+  end
+
+  def test_granularity(granularity, parent)
+    body = {:granularity => granularity}
+    assert_equal parent, @port.request(:infer_parent_granularity, body)[:parent_granularity]
+  end
+
+end
@@ -0,0 +1,49 @@
+Feature: editing a configuration 
+  As a mezuro user
+  I want to edit a Kalibro configuration
+
+  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"
+    And I am on My Community's cms
+    And I create a content of type "Kalibro configuration" with the following data
+      | Title           | My Configuration     |
+      | Description     | A sample description |
+    And I follow "Add metric"
+    And I follow "Analizo"
+    And I follow "Lines of Code"
+    And I fill in the following:
+      | Code:           | SampleCode           |
+      | Weight:         | 10.0                  |
+    And I select "Average" from "Aggregation Form:"
+    And I press "Add"
+    And I press "Save" and wait
+    
+  Scenario: Keep metrics after editing configuration
+    When I follow "Edit" within "article-actions" and wait
+    And I press "Save" 
+    Then I should see "Lines of Code"
+    
+  #FIXME: Create new step for this scenario
+  Scenario: Check if title is edit-disabled
+    When I follow "Edit" within "article-actions" and wait
+    And I fill in the following:
+      | Title           | Some Title     |
+    And I press "Save" and wait
+    Then I should not see "Some Title"
+    
+    
+  Scenario: Check if description is edit-enabled
+    When I follow "Edit" within "article-actions" and wait
+    And I fill in the following:
+      | Description           | Some Description     |
+    And I press "Save" and wait
+    Then I should see "Some Description"
+    And I should see "Lines of Code"
@@ -0,0 +1,32 @@
+Feature: Remove a metric configuration from a configuration 
+  As a mezuro user
+  I want to remove metric configurations from a configuration
+
+  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"
+    And I am on My Community's cms
+    And I create a content of type "Kalibro configuration" with the following data
+      | Title           | My Configuration     |
+      | Description     | A sample description |
+    When I follow "Add metric"
+    And I follow "Analizo"
+    And I follow "Lines of Code"
+    And I fill in the following:
+      | Code:           | Sample Code           |
+      | Weight:         | 10.0                  |
+    And I select "Average" from "Aggregation Form:"
+    And I press "Add"
+    And I press "Save"
+    And I should see "Lines of Code"
+    
+    Scenario: I remove a metric configuration
+    When I follow "Remove"
+    Then I should not see "Lines of Code"
@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/native_metric_fixtures'
+
+class BaseToolFixtures
+    
+  def self.base_tool
+    Kalibro::BaseTool.new base_tool_hash
+  end
+
+  def self.base_tool_hash
+    {:name => 'Analizo', :supported_metric => [
+        NativeMetricFixtures.total_cof_hash,
+        NativeMetricFixtures.amloc_hash]}
+  end
+
+end
@@ -0,0 +1,11 @@
+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
@@ -0,0 +1,20 @@
+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,28 @@
+require File.dirname(__FILE__) + '/metric_configuration_fixtures'
+
+class ConfigurationFixtures
+
+  def self.configuration
+    Kalibro::Configuration.new configuration_hash
+  end
+
+  def self.configuration_hash
+    {
+      :name => 'Sample Configuration',
+      :description => 'Kalibro configuration for Java projects.',
+      :metric_configuration => [
+        MetricConfigurationFixtures.amloc_metric_configuration_hash,
+        MetricConfigurationFixtures.sc_metric_configuration_hash
+      ]
+    }
+  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
+    })
+  end
+
+end
@@ -0,0 +1,20 @@
+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
@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/compound_metric_fixtures'
+require File.dirname(__FILE__) + '/native_metric_fixtures'
+require File.dirname(__FILE__) + '/range_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
+  end
+
+  def self.sc_metric_configuration
+    sc = Kalibro::MetricConfiguration.new sc_metric_configuration_hash
+    sc.configuration_name = "Sample Configuration"
+    sc
+  end
+
+  def self.amloc_metric_configuration_hash
+    {:metric => NativeMetricFixtures.amloc_hash, :code => 'amloc', :weight => 1.0,
+      :aggregation_form => 'AVERAGE',
+      :range => [RangeFixtures.range_excellent_hash, RangeFixtures.range_bad_hash],
+      :attributes! => {:metric => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:nativeMetricXml'  }}}
+  end
+
+  def self.sc_metric_configuration_hash
+    {:metric => CompoundMetricFixtures.compound_metric_hash, :code => 'sc', :weight => 1.0, :aggregation_form => 'AVERAGE',
+      :attributes! => {:metric => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:compoundMetricXml'  }}}
+  end
+    
+end
@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/compound_metric_fixtures'
+require File.dirname(__FILE__) + '/native_metric_fixtures'
+require File.dirname(__FILE__) + '/range_fixtures'
+
+class MetricResultFixtures
+
+  def self.native_metric_result
+    Kalibro::MetricResult.new native_metric_result_hash
+  end
+
+  def self.compound_metric_result
+    Kalibro::MetricResult.new compound_metric_result_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'  }
+      }
+    }
+  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'  }
+      }
+    }
+  end
+
+end
@@ -0,0 +1,14 @@
+class ModuleFixtures
+
+  def self.module
+    Kalibro::Module.new module_hash
+  end
+
+  def self.module_hash
+    {
+      :name => 'Qt-Calculator',
+      :granularity => 'APPLICATION'
+    }
+  end
+    
+end
@@ -0,0 +1,47 @@
+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
@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/module_fixtures'
+require File.dirname(__FILE__) + '/metric_result_fixtures'
+require File.dirname(__FILE__) + '/compound_metric_with_error_fixtures'
+
+class ModuleResultFixtures
+
+  def self.module_result
+    Kalibro::ModuleResult.new module_result_hash
+  end
+
+  def self.module_result_hash
+    {
+      :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'  }
+      }
+    }
+  end
+
+end
@@ -0,0 +1,19 @@
+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,40 @@
+require File.dirname(__FILE__) + '/repository_fixtures'
+
+class ProjectFixtures
+
+  def self.project
+    Kalibro::Project.new project_hash
+  end
+
+  def self.project_hash
+    {
+      :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"
+        }
+      }
+    }
+  end
+    
+  def self.project_content
+    content = MezuroPlugin::ProjectContent.new
+    content.name = 'Qt-Calculator'
+    content.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
@@ -0,0 +1,35 @@
+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
@@ -0,0 +1,21 @@
+class RangeFixtures
+
+  Infinity = 1.0/0.0
+
+  def self.range_excellent
+    Kalibro::Range.new range_excellent_hash
+  end
+
+  def self.range_bad
+    Kalibro::Range.new range_bad_hash
+  end
+
+  def self.range_excellent_hash
+    {:beginning => 0.0, :end => 7.0, :label => 'Excellent', :grade => 10.0, :color => 'ff00ff00'}
+  end
+
+  def self.range_bad_hash
+    {:beginning => 19.5, :end => "INF", :label => 'Bad',:grade => 0.0, :color => 'ffff0000'}
+  end
+
+end
@@ -0,0 +1,11 @@
+class RepositoryFixtures
+
+  def self.repository
+    Kalibro::Repository.new repository_hash
+  end
+
+  def self.repository_hash
+    {:type => 'SUBVERSION', :address => 'https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator'}
+  end
+
+end
@@ -0,0 +1,16 @@
+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)
+  end
+
+  def self.stack_trace_element_hash(method_name = 'my method name', line_number = 42)
+    {
+      :declaring_class => 'my.declaring.Class',
+      :method_name => method_name,
+      :file_name => 'MyFile.java',
+      :line_number => line_number
+    }
+  end
+
+end
@@ -0,0 +1,228 @@
+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"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_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_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!
+    
+    @range = RangeFixtures.range_excellent
+    @range_hash = RangeFixtures.range_excellent_hash
+  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
+
+  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)
+    assert_equal @metric.name, assigns(:metric).name
+    assert_response 200
+  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
+  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
+  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)
+    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
+  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
+  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
+  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
+  end
+
+  should 'test new range' do
+    get :new_range, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
+    assert_equal @content, assigns(:configuration_content)
+    assert_equal @metric.name, assigns(:metric_name)
+    assert_response 200
+  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, assigns(:configuration_content)
+    assert_equal @metric.name, assigns(:metric_name)
+    assert_equal @range.beginning, assigns(:beginning_id)
+    assert_equal @range.end, assigns(:range).end
+    assert_response 200
+  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
+  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
+  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
+  end
+
+end
 require 'test_helper'
  
-class MezuroPluginProfileControllerTest < ActiveSupport::TestCase
+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 MezuroPluginProfileControllerTest < ActionController::TestCase
  
   def setup
     @controller = MezuroPluginProfileController.new
     @request = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
+    @response = ActionController::TestResponse.new
     @profile = fast_create(Community)
-    @profile_id = @profile.identifier
+
+    @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
  
-#  def test_metrics_for_unknown_module
-#    get :metrics, :profile => @profile_id, :id => 0
-#    assert_response 404
-#  end
+  should 'test project state without 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
  
-#  def test_metric_unknown_module
-#  get :metrics, :profile => @profile_id, :id => @project_content.id, :module_name => 'veryunlikelyname'
-#  assert_response 404
-#  end
+  should 'test project state with 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
  
-#  def test_metrics_for_known_module
-#    @project_content = create_project_content(@profile)
-#    get :metrics, :profile => @profile_id, :id => @project_content.id, :module_name => @project_content.name
-#    assert_response 200
-#    # assert_tag # TODO
-#  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
  
-  protected
  
-  # returns a new ProjectContent for the given profile
-  def create_project_content(profile)
-    project_content = MezuroPlugin::ProjectContent.create!(:profile => profile, :name => 'foo') 
+  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
  
-    project = create_project(project_content.name)
-    project_content.license = project.license
-    project_content.description = project.description
-    project_content.repository_type = project.repository.type
-    project_content.repository_url = project.repository.address
-    project_content.configuration_name = project.configuration_name
+  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
  
-    MezuroPlugin::ProjectContent.any_instance.stubs(:project_content).returns(project_content)
-    project_content
+  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
-  
-  def create_project(name)
-    project = Kalibro::Entities::Project.new
-    project.name = name
-    project.license = 'GPL'
-    project.description = 'testing' 
-    project.repository = crieate_repository
-    project.configuration_name = 'Kalibro Default'
-    project
+
+  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
  
-  def create_repository
-    repository = Kalibro::Entities::Repository.new
-    repository.type = 'git'
-    repository.address = 'http://git.git'
-    repository
+  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], assigns(:score_history)
+    assert_response 200
   end
- 
-  #TODO Adicionar module result manualmente
-  #TODO Ver testes do project content, refatorar o project content em cima dos testes
-  #TODO Repensar design OO: nao amarrar o project_content ao webservice. Criar um modelo abstrato do webservice
+  
+  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], assigns(:score_history)
+    assert_response 200
+  end
+
 end
@@ -1,11 +0,0 @@
-require "test_helper"
-require File.dirname(__FILE__) + '/../controllers/mezuro_plugin_myprofile_controller'
-
-class MezuroTest < ActiveSupport::TestCase
-
-  should 'create a mezuro project' do
-    controller = MezuroPluginMyprofileController.new
-    controller.create
-  end
-
-end
@@ -0,0 +1,36 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
+
+class BaseToolTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = BaseToolFixtures.base_tool_hash
+    @base_tool = BaseToolFixtures.base_tool
+  end
+
+  should 'create base tool from hash' do
+    assert_equal @base_tool.name, Kalibro::BaseTool.new(@hash).name
+  end
+
+  should 'convert base tool to hash' do
+    assert_equal @hash, @base_tool.to_hash
+  end
+
+  should 'get base tool names' do
+    names = ['Analizo', 'Checkstyle']
+    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool_names).returns({:base_tool_name => names})
+    assert_equal names, Kalibro::BaseTool.all_names
+  end
+
+  should 'get base tool by name' do
+    request_body = {:base_tool_name => @base_tool.name}
+    Kalibro::BaseTool.expects(:request).with("BaseTool", :get_base_tool, request_body).returns({:base_tool => @hash})
+    assert_equal @base_tool.name, Kalibro::BaseTool.find_by_name(@base_tool.name).name
+  end
+  
+  should 'get base tool metrics' do
+    assert_equal @base_tool.supported_metrics[0].name, @base_tool.metric('Total Coupling Factor').name
+  end
+  
+end
@@ -1,34 +0,0 @@
-require "test_helper"
-class BaseToolClientTest < ActiveSupport::TestCase
-
-  def setup
-    @port = mock
-    Kalibro::Client::Port.expects(:new).with('BaseTool').returns(@port)
-    @client = Kalibro::Client::BaseToolClient.new
-  end
-
-  should 'get base tool names (zero)' do
-    @port.expects(:request).with(:get_base_tool_names).returns({})
-    assert_equal [], @client.base_tool_names
-  end
-
-  should 'get base tool names (one)' do
-    name = 'Analizo'
-    @port.expects(:request).with(:get_base_tool_names).returns({:base_tool_name => name})
-    assert_equal [name], @client.base_tool_names
-  end
-
-  should 'get base tool names' do
-    names = ['Analizo', 'Checkstyle']
-    @port.expects(:request).with(:get_base_tool_names).returns({:base_tool_name => names})
-    assert_equal names, @client.base_tool_names
-  end
-
-  should 'get base tool by name' do
-    analizo = BaseToolTest.analizo
-    request_body = {:base_tool_name => 'Analizo'}
-    @port.expects(:request).with(:get_base_tool, request_body).returns({:base_tool => analizo.to_hash})
-    assert_equal analizo, @client.base_tool('Analizo')
-  end
-
-end
 \ No newline at end of file
@@ -1,47 +0,0 @@
-require "test_helper"
-class ConfigurationClientTest < ActiveSupport::TestCase
-
-  def setup
-    @port = mock
-    Kalibro::Client::Port.expects(:new).with('Configuration').returns(@port)
-    @client = Kalibro::Client::ConfigurationClient.new
-  end
-
-  should 'save configuration' do
-    configuration = ConfigurationTest.kalibro_configuration
-    @port.expects(:request).with(:save_configuration, {:configuration => configuration.to_hash})
-    @client.save(configuration)
-  end
-
-  should 'get configuration names (zero)' do
-    @port.expects(:request).with(:get_configuration_names).returns({})
-    assert_equal [], @client.configuration_names
-  end
-
-  should 'get configuration names (one)' do
-    name = 'Kalibro for Java'
-    @port.expects(:request).with(:get_configuration_names).returns({:configuration_name => name})
-    assert_equal [name], @client.configuration_names
-  end
-
-  should 'get configuration names' do
-    names = ['Kalibro for Java', 'ConfigurationClientTest configuration']
-    @port.expects(:request).with(:get_configuration_names).returns({:configuration_name => names})
-    assert_equal names, @client.configuration_names
-  end
-
-  should 'get configuration by name' do
-    configuration = ConfigurationTest.kalibro_configuration
-    request_body = {:configuration_name => configuration.name}
-    response_hash = {:configuration => configuration.to_hash}
-    @port.expects(:request).with(:get_configuration, request_body).returns(response_hash)
-    assert_equal configuration, @client.configuration(configuration.name)
-  end
-
-  should 'remove configuration by name' do
-    name = 'ConfigurationClientTest'
-    @port.expects(:request).with(:remove_configuration, {:configuration_name => name})
-    @client.remove(name)
-  end
-
-end
 \ No newline at end of file
@@ -1,29 +0,0 @@
-require "test_helper"
-class KalibroClientTest < ActiveSupport::TestCase
-
-  def setup
-    @port = mock
-    Kalibro::Client::Port.expects(:new).with('Kalibro').returns(@port)
-    @client = Kalibro::Client::KalibroClient.new
-  end
-
-  should 'get supported repository types' do
-    types = ['BAZAAR', 'GIT', 'SUBVERSION']
-    @port.expects(:request).with(:get_supported_repository_types).returns({:repository_type => types})
-    assert_equal types, @client.supported_repository_types
-  end
-
-  should 'process project' do
-    name = 'KalibroClientTest'
-    @port.expects(:request).with(:process_project, {:project_name => name})
-    @client.process_project(name)
-  end
-
-  should 'instantiate for processing project' do
-    instance = mock
-    Kalibro::Client::KalibroClient.expects(:new).returns(instance)
-    instance.expects(:process_project).with('myproject')
-    Kalibro::Client::KalibroClient.process_project('myproject')
-  end
-  
-end
@@ -1,27 +0,0 @@
-require "test_helper"
-class ModuleResultClientTest < ActiveSupport::TestCase
-
-  def setup
-    @port = mock
-    Kalibro::Client::Port.expects(:new).with('ModuleResult').returns(@port)
-    @client = Kalibro::Client::ModuleResultClient.new
-    @result = ModuleResultTest.fixture
-  end
-
-  should 'get module result' do
-    date_string = '2012-01-10T16:07:15.442-02:00'
-    date = DateTime.parse(date_string)
-    request_body = {:project_name => 'Qt-Calculator', :module_name => 'main', :date => date_string}
-    response = {:module_result => @result.to_hash}
-    @port.expects(:request).with(:get_module_result, request_body).returns(response)
-    assert_equal @result, @client.module_result('Qt-Calculator', 'main', date)
-  end
-
-  should 'get result history' do
-    request_body = {:project_name => 'Qt-Calculator', :module_name => 'main'}
-    response = {:module_result => @result.to_hash}
-    @port.expects(:request).with(:get_result_history, request_body).returns(response)
-    assert_equal [@result], @client.result_history('Qt-Calculator', 'main')
-  end
-
-end
 \ No newline at end of file
@@ -1,33 +0,0 @@
-require "test_helper"
-class PortTest < ActiveSupport::TestCase
-
-  def setup
-    @client = mock
-    set_default_address
-    Savon::Client.expects(:new).with("#{@default_address}PortTestEndpoint/?wsdl").returns(@client)
-    @port = Kalibro::Client::Port.new('PortTest')
-  end
-
-
-  should 'get default address' do
-    assert_equal @default_address, @port.service_address
-  end
-
-  should 'request action and return response' do
-    response_body = {:port_test_response_key => 'PortTest response value'}
-    response_hash = {:port_test_action_response => response_body}
-    response = mock
-    response.expects(:to_hash).returns(response_hash)
-    @client.expects(:request).with(:kalibro, :port_test_action).returns(response)
-
-    assert_equal response_body, @port.request(:port_test_action)
-  end
-
-  private
-
-  def set_default_address
-    service_file = "#{RAILS_ROOT}/plugins/mezuro/SERVICE"
-    File.open(service_file).each_line{ | line | @default_address = line }
-  end
-
-end
 \ No newline at end of file
@@ -1,55 +0,0 @@
-require "test_helper"
-class ProjectClientTest < ActiveSupport::TestCase
-
-  def setup
-    @port = mock
-    Kalibro::Client::Port.expects(:new).with('Project').returns(@port)
-    @client = Kalibro::Client::ProjectClient.new
-  end
-
-  should 'save project' do
-    project = ProjectTest.qt_calculator
-    @port.expects(:request).with(:save_project, {:project => project.to_hash})
-    @client.save(project)
-  end
-
-  should 'get project names (zero)' do
-    @port.expects(:request).with(:get_project_names).returns({})
-    assert_equal [], @client.project_names
-  end
-
-  should 'get project names (one)' do
-    name = 'Qt-Calculator'
-    @port.expects(:request).with(:get_project_names).returns({:project_name => name})
-    assert_equal [name], @client.project_names
-  end
-
-  should 'get project names' do
-    names = ['Hello World', 'Qt-Calculator']
-    @port.expects(:request).with(:get_project_names).returns({:project_name => names})
-    assert_equal names, @client.project_names
-  end
-
-  should 'get project by name' do
-    project = ProjectTest.qt_calculator
-    request_body = {:project_name => project.name}
-    response_hash = {:project => project.to_hash}
-    @port.expects(:request).with(:get_project, request_body).returns(response_hash)
-    assert_equal project, @client.project(project.name)
-  end
-
-  should 'remove project by name' do
-    name = 'ProjectClientTest'
-    @port.expects(:request).with(:remove_project, {:project_name => name})
-    @client.remove(name)
-  end
-
-  should 'instantiate for saving a project' do
-    project = mock
-    instance = mock
-    Kalibro::Client::ProjectClient.expects(:new).returns(instance)
-    instance.expects(:save).with(project)
-    Kalibro::Client::ProjectClient.save(project)
-  end
-
-end
@@ -1,68 +0,0 @@
-require "test_helper"
-class ProjectResultClientTest < ActiveSupport::TestCase
-
-  def setup
-    @port = mock
-    Kalibro::Client::Port.expects(:new).with('ProjectResult').returns(@port)
-    @client = Kalibro::Client::ProjectResultClient.new
-
-    @result = ProjectResultTest.qt_calculator
-    @project_name = @result.project.name
-    @date = @result.date
-    @flag = DateTime.now.sec % 2 == 0
-  end
-
-  should 'retrieve if project has results' do
-    @port.expects(:request).with(:has_results_for, request).returns(flag_response)
-    assert_equal @flag, @client.has_results_for(@project_name)
-  end
-
-  should 'retrieve if project has results before date' do
-    @port.expects(:request).with(:has_results_before, request_with_date).returns(flag_response)
-    assert_equal @flag, @client.has_results_before(@project_name, @date)
-  end
-
-  should 'retrieve if project has results after date' do
-    @port.expects(:request).with(:has_results_after, request_with_date).returns(flag_response)
-    assert_equal @flag, @client.has_results_after(@project_name, @date)
-  end
-
-  should 'get first result of project' do
-    @port.expects(:request).with(:get_first_result_of, request).returns(result_response)
-    assert_equal @result, @client.first_result(@project_name)
-  end
-
-  should 'get last result of project' do
-    @port.expects(:request).with(:get_last_result_of, request).returns(result_response)
-    assert_equal @result, @client.last_result(@project_name)
-  end
-
-  should 'get first result of project after date' do
-    @port.expects(:request).with(:get_first_result_after, request_with_date).returns(result_response)
-    assert_equal @result, @client.first_result_after(@project_name, @date)
-  end
-
-  should 'get last result of project before date' do
-    @port.expects(:request).with(:get_last_result_before, request_with_date).returns(result_response)
-    assert_equal @result, @client.last_result_before(@project_name, @date)
-  end
-
-  private
-
-  def request
-    {:project_name => @project_name}
-  end
-
-  def request_with_date
-    {:project_name => @project_name, :date => @date}
-  end
-
-  def flag_response
-    {:has_results => @flag}
-  end
-
-  def result_response
-    {:project_result => @result.to_hash}
-  end
-
-end
 \ No newline at end of file
@@ -0,0 +1,20 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/compound_metric_fixtures"
+
+class CompoundMetricTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = CompoundMetricFixtures.compound_metric_hash
+    @metric = CompoundMetricFixtures.compound_metric
+  end
+
+  should 'create compound metric from hash' do
+    assert_equal @hash[:script], Kalibro::CompoundMetric.new(@hash).script
+  end
+
+  should 'convert compound metric to hash' do
+    assert_equal @hash, @metric.to_hash
+  end
+
+end
...	...	@@ -0,0 +1,6 @@
	1	+require 'savon'
	2	+require 'yaml'
	3	+
	4	+Savon.configure do \|config\|
	5	+ config.log = HTTPI.log = (RAILS_ENV == 'development')
	6	+end
...	...
...	...	@@ -0,0 +1,14 @@
	1	+Then /^I directly delete content with name "([^\"]*)" for testing purposes$/ do \|content_name\|
	2	+ Article.find_by_name(content_name).destroy
	3	+end
	4	+
	5	+Then /^I should be at the url "([^\"]*)"$/ do \|url\|
	6	+ if response.class.to_s == 'Webrat::SeleniumResponse'
	7	+ URI.parse(response.selenium.get_location).path.should == url
	8	+ else
	9	+ URI.parse(current_url).path.should == url
	10	+ end
	11	+end
	12	+
	13	+Then /^I don't fill anything$/ do
	14	+end
...	...
1		-KALIBRO PLUGIN AUTHORS
2		-=====================
	1	+Mezuro Authors
	2	+==============
3	3
4		-Copyright 2010-2011
5		- Almir Alves Pereira (almir.sne at gmail.com)
6		- Andre Casimiro (ah.casimiro at gmail.com)
7		- Carlos Morais (carlos88morais at gmail.com)
8		- Everton Santos (everton2x4 at gmail.com)
9		- Paulo Meirelles (paulo at softwarelivre.org)
10		- Rafael Messias (rmmartins at gmail.com)
	4	+Copyright 2010-2012
	5	+-------------------
11	6
12		-Collaborators:
13		-- Ana Paula Oliveira dos Santos (ana at ime.usp.br)
14		-- Lucianna Almeida (lucianna.th at gmail.com)
15		-- Joao Machini (joao.machini at gmail.com)
16		-- Rodrigo Souto (rodrigo@colivre.coop.br)
17		-- Thiago Colucci (ticolucci at gmail.com)
18		-- Vinicius Daros (vinicius.k.daros at gmail.com)
19		-- Viviane Almeida Santos (viviane.almeida at gmail.com)
	7	+ Almir Alves Pereira (almir.sne at gmail.com)
	8	+ Alessandro Palmeira (alessandro.palmeira at gmail.com)
	9	+ Andre Casimiro (ah.casimiro at gmail.com)
	10	+ Antonio Terceiro (terceiro at colivre.coop.br)
	11	+ Caio Salgado (caio.csalgado at gmail.com)
	12	+ Carlos Morais (carlos88morais at gmail.com)
	13	+ Diego Araújo (diegoamc90 at gmail.com)
	14	+ Everton Santos (everton2x4 at gmail.com)
	15	+ Jefferson Fernandes (jeffs.fernandes at gmail.com)
	16	+ Joao Machini (joao.machini at gmail.com)
	17	+ João da Silva (jaodsilv@linux.ime.usp.br)
	18	+ Paulo Meirelles (paulo at softwarelivre.org)
	19	+ Rafael Manso (rr.manzo at gmail.com)
	20	+ Rafael Messias (rmmartins at gmail.com)
	21	+ Renan Teruo (renanteruoc at gmail.com)
	22	+ Rodrigo Souto (rodrigo at colivre.coop.br)
	23	+
	24	+Collaborators (from USP Lab XP course 2010 on another code)
	25	+-----------------------------------------------------------
	26	+
	27	+ Ana Paula Oliveira dos Santos (anapaulao.santos at gmail.com)
	28	+ Lucianna Almeida (lucianna.th at gmail.com)
	29	+ Thiago Colucci (ticolucci at gmail.com)
	30	+ Vinicius Daros (vinicius.k.daros at gmail.com)
	31	+ Viviane Almeida Santos (viviane.almeida at gmail.com)
	32	+
	33	+Advisors
	34	+--------
	35	+
	36	+ Fabio Kon (fabio.kon at ime.usp.br)
	37	+ Alfredo Goldman (gold at ime.usp.br)
20	38
...	...
1		-README - Mezuro (Kalibro Plugin)
	1	+README - Mezuro (Mezuro Plugin)
2	2	================================
3	3
4		-Mezuro is source code tracking network based on Noosfero Platform with Kalibro Plugin to access Kalibro Web Service.
	4	+Mezuro is a source code tracking platform based on Noosfero social networking
	5	+platform with Mezuro Plugin actived to access Kalibro Web Service.
	6	+
5	7
6	8	INSTALL
7	9	=======
8	10
9		-See the Noosfero install file and include Ruby gem Savon:
	11	+Dependences
	12	+-----------
	13	+
	14	+See the Noosfero install file. After install Noosfero, install Mezuro dependences:
10	15
11		-gem install savon
	16	+$ gem install nokogiri -v 1.5.0
	17	+$ gem install savon -v 0.9.7
	18	+$ gem install googlecharts
12	19
13		-Also, you need to enable Mezuro Plugin in the Noosfero:
	20	+Enable Plugin
	21	+-------------
	22	+
	23	+Also, you need to enable Mezuro Plugin at you Noosfero:
14	24
15	25	cd <your_noosfero_dir>
16	26	./script/noosfero-plugins enable mezuro
17	27
18		-To run Mezuro (kalibro Plugin) and its acceptance tests, you need to install the Kalibro Service.
	28	+
	29	+Install Service
	30	+---------------
	31	+
	32	+To run Mezuro (Noosfero with Mezuro Plugin), you need to install the Kalibro
	33	+Service.
	34	+
19	35	For that, access https://gitorious.org/kalibro/kalibro/blobs/master/INSTALL
20	36
21	37
22		-SOURCE CODE
	38	+Configure Service Address
	39	+-------------------------
	40	+
	41	+Finally, copy service.yaml.example to service.yaml and define your Kalibro
	42	+Service address:
	43	+
	44	+$ cd <your_noosfero_dir>/plugin/mezuro
	45	+$ cp service.yaml.example service.yaml
	46	+
	47	+If you install Kalibro Service at localhost, just keep the default
	48	+adress:
	49	+
	50	+http://localhost:8080/KalibroService/
	51	+
	52	+Applying Mezuro Theme
	53	+---------------------
	54	+
	55	+$ cd public/designs/themes && rm -f default
	56	+$ git clone git://gitorious.org/mezuro/mezuro-theme.git
	57	+$ ln -s mezuro-theme/ default && cd ../../../
	58	+
	59	+Active Plugin
	60	+-------------
	61	+
	62	+As a Noosfero administrator user, go to administrator panel:
	63	+
	64	+- Click on "Enable/disable plugins" option
	65	+- Click on "Mezuro Plugin" check-box
	66	+
	67	+
	68	+DEVELOPMENT
23	69	===========
24	70
25		-To get the Mezuro (Noosfero with Kalibro Plugin) development repository:
	71	+Get the Mezuro (Noosfero with Mezuro Plugin) development repository:
26	72
27		-git clone https://gitorious.org/+mezuro/noosfero/mezuro-noosfero-plugin
28		-cd mezuro-noosfero-plugin
29		-git checkout mezuro
	73	+$ git clone https://gitorious.org/+mezuro/noosfero/mezuro
	74	+$ cd mezuro
	75	+$ git checkout mezuro
30	76
31		-AUTHORS
32		-=======
	77	+Running Mezuro tests
	78	+--------------------
33	79
34		-Please see the file AUTHORS.
	80	+$ rake test:noosfero_plugins:mezuro
35	81
36		-BUGS
37		-====
38	82
39		-If you found any bug, please report at mezuro@listas.softwarelivre.org
40		-(http://listas.softwarelivre.org/cgi-bin/mailman/listinfo/mezuro)
	83	+Get Involved
	84	+============
	85	+
	86	+If you found any bug and/or want to collaborate, please send an e-mail to
	87	+paulo@softwarelivre.org
	88	+
41	89
42	90	LICENSE
43	91	=======
44		-Copyright (c) The Authors developers.
	92	+
	93	+Copyright (c) The Author developers.
45	94
46	95	See Noosfero license.
47	96
48	97
	98	+AUTHORS
	99	+=======
	100	+
	101	+Please, see the Mezuro AUTHORS file.
	102	+
	103	+
49	104	ACKNOWLEDGMENTS
50	105	===============
51	106
52	107	The authors have been supported by organizations:
53	108
	109	+University of São Paulo (USP)
	110	+FLOSS Competence Center
	111	+http://ccsl.ime.usp.br
	112	+
54	113	Brazilian National Research Council (CNPQ)
55	114	http://www.cnpq.br/
56		-
57		-USP FLOSS Competence Center
58		-http://ccsl.ime.usp.br/
...	...
...	...	@@ -0,0 +1,73 @@
	1	+README/TODO do branch cucumber_tests
	2	+
	3	+Tarefas:
	4	+- Escrever uma história (procurar uma já escrita) para isso
	5	+- Descobrir o porquê dos erros nos testes do mezuro (repository_url)
	6	+- Dar rebase com o mezuro-dev (os tais testes passam no mezuro-dev)
	7	+- Fazer mais testes
	8	+- Ver como/quando o selenium pode ser integrado ao projeto (conversar com noosfero/ talvez até tentar implementar alguma coisa??)
	9	+
	10	+
	11	+Testes de aceitação a serem feitos: (* já feito)
	12	+
	13	+Projetos:
	14	+ Criar
	15	+ * correto
	16	+ * errado
	17	+ duplicado
	18	+ Editar
	19	+ correto
	20	+ errado
	21	+ Deletar(não precisa fazer - problema do noosfero)
	22	+
	23	+Configurações:
	24	+ criar
	25	+ *correta
	26	+ *errado (sem titulo)
	27	+ *duplicada
	28	+ editar - verificar se mantem as metricas
	29	+ correto
	30	+ não é possível mudar o titulo
	31	+ deletar (não precisa fazer - problema do noosfero)
	32	+ metricas:
	33	+ criar
	34	+ nativa:
	35	+ *correta
	36	+ *errada
	37	+ duplicada (é pra funcionar?)
	38	+ composta:
	39	+ *correta
	40	+ errada
	41	+ duplicada
	42	+ editar
	43	+ para metrica correta
	44	+ para metrica errada
	45	+ *deletar
	46	+ ranges:
	47	+ criar
	48	+ *range correto
	49	+ range errado
	50	+ todos os casos
	51	+ editar
	52	+ para range correto
	53	+ para range errado
	54	+ deletar
	55	+
	56	+Testes falhando:
	57	+
	58	+Arquivo adding_metric_configuration.feature:
	59	+ Scenario: adding a native metric configuration without code
	60	+ Precisa do selenium para ver em qual página está.
	61	+ Scenario: adding a compound metric configuration
	62	+ Scenario: adding a compound metric configuration with invalid script
	63	+ As métricas compostas não estão salvando direito.
	64	+
	65	+
	66	+Arquivo creating_project.feature:
	67	+ Scenario: I create a Kalibro project with valid attributes
	68	+ ás vezes falha por erro de já existir na Kalibro. Esse erro teóricamente já havia sido resolvido.
	69	+
	70	+
	71	+Arquivo adding_ranges.feature:
	72	+ Scenario: adding a range to a metric configuration
	73	+ Precisa do selenium para esperar a página carregar.
...	...
...	...	@@ -0,0 +1,126 @@
	1	+class MezuroPluginMyprofileController < ProfileController
	2	+
	3	+ append_view_path File.join(File.dirname(__FILE__) + '/../views')
	4	+
	5	+
	6	+ def choose_base_tool
	7	+ @configuration_content = profile.articles.find(params[:id])
	8	+ @base_tools = Kalibro::BaseTool.all_names
	9	+ end
	10	+
	11	+ def choose_metric
	12	+ @configuration_content = profile.articles.find(params[:id])
	13	+ @base_tool = params[:base_tool]
	14	+ @supported_metrics = Kalibro::BaseTool.find_by_name(@base_tool).supported_metrics
	15	+ end
	16	+
	17	+ def new_metric_configuration
	18	+ @configuration_content = profile.articles.find(params[:id])
	19	+ @metric = Kalibro::BaseTool.find_by_name(params[:base_tool]).metric params[:metric_name]
	20	+ end
	21	+
	22	+ def new_compound_metric_configuration
	23	+ @configuration_content = profile.articles.find(params[:id])
	24	+ @metric_configurations = @configuration_content.metric_configurations
	25	+ end
	26	+
	27	+ def edit_metric_configuration
	28	+ @configuration_content = profile.articles.find(params[:id])
	29	+ @metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, params[:metric_name])
	30	+ @metric = @metric_configuration.metric
	31	+ end
	32	+
	33	+ def edit_compound_metric_configuration
	34	+ @configuration_content = profile.articles.find(params[:id])
	35	+ @metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, params[:metric_name])
	36	+ @metric_configurations = @configuration_content.metric_configurations
	37	+ @metric = @metric_configuration.metric
	38	+ end
	39	+
	40	+ def create_metric_configuration
	41	+ id = params[:id]
	42	+ metric_name = params[:metric_configuration][:metric][:name]
	43	+ (Kalibro::MetricConfiguration.new(params[:metric_configuration])).save
	44	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
	45	+ end
	46	+
	47	+ def create_compound_metric_configuration
	48	+ id = params[:id]
	49	+ metric_name = params[:metric_configuration][:metric][:name]
	50	+ Kalibro::MetricConfiguration.new(params[:metric_configuration]).save
	51	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?id=#{id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
	52	+ end
	53	+
	54	+ def update_metric_configuration
	55	+ @configuration_content = profile.articles.find(params[:id])
	56	+ metric_name = params[:metric_configuration][:metric][:name]
	57	+ metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
	58	+ metric_configuration.update_attributes params[:metric_configuration]
	59	+ redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
	60	+ end
	61	+
	62	+ def update_compound_metric_configuration
	63	+ @configuration_content = profile.articles.find(params[:id])
	64	+ metric_name = params[:metric_configuration][:metric][:name]
	65	+ metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
	66	+ metric_configuration.update_attributes params[:metric_configuration]
	67	+ redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
	68	+ end
	69	+
	70	+ def remove_metric_configuration
	71	+ configuration_content = profile.articles.find(params[:id])
	72	+ metric_name = params[:metric_name]
	73	+ metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
	74	+ metric_configuration.destroy
	75	+ redirect_to "/#{profile.identifier}/#{configuration_content.slug}"
	76	+ end
	77	+
	78	+ def new_range
	79	+ @configuration_content = profile.articles.find(params[:id])
	80	+ @metric_name = params[:metric_name]
	81	+ @range = Kalibro::Range.new
	82	+ end
	83	+
	84	+ def edit_range
	85	+ @configuration_content = profile.articles.find(params[:id])
	86	+ @metric_name = params[:metric_name]
	87	+ @beginning_id = params[:beginning_id]
	88	+ metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, @metric_name)
	89	+ @range = metric_configuration.ranges.find{\|range\| range.beginning == @beginning_id.to_f \|\| @beginning_id =="-INF" }
	90	+ end
	91	+
	92	+ def create_range
	93	+ @configuration_content = profile.articles.find(params[:id])
	94	+ @range = Kalibro::Range.new params[:range]
	95	+ metric_name = params[:metric_name]
	96	+ metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(@configuration_content.name, metric_name)
	97	+ metric_configuration.add_range(@range)
	98	+ metric_configuration.save
	99	+ end
	100	+
	101	+ def update_range
	102	+ configuration_content = profile.articles.find(params[:id])
	103	+ metric_name = params[:metric_name]
	104	+ beginning_id = params[:beginning_id]
	105	+ metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
	106	+ index = metric_configuration.ranges.index{ \|range\| range.beginning == beginning_id.to_f \|\| beginning_id == "-INF" }
	107	+ metric_configuration.ranges[index] = Kalibro::Range.new params[:range]
	108	+ metric_configuration.save
	109	+ end
	110	+
	111	+ def remove_range
	112	+ configuration_content = profile.articles.find(params[:id])
	113	+ metric_name = params[:metric_name]
	114	+ beginning_id = params[:beginning_id]
	115	+ metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_name_and_metric_name(configuration_content.name, metric_name)
	116	+ metric_configuration.ranges.delete_if { \|range\| range.beginning == beginning_id.to_f \|\| beginning_id == "-INF" }
	117	+ metric_configuration.save
	118	+ formatted_metric_name = metric_name.gsub(/\s/, '+')
	119	+ if metric_configuration.metric.class == Kalibro::CompoundMetric
	120	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
	121	+ else
	122	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
	123	+ end
	124	+ end
	125	+
	126	+end
...	...
1	1	class MezuroPluginProfileController < ProfileController
2	2
3		- def metrics
4		- project_content = profile.articles.find(params[:id])
5		- module_name = params[:module_name]
6		- render :partial => 'content_viewer/module_result', :locals => { :module_result => project_content.module_result(module_name) }
	3	+ append_view_path File.join(File.dirname(__FILE__) + '/../views')
	4	+
	5	+ def project_state
	6	+ @content = profile.articles.find(params[:id])
	7	+ project = @content.project
	8	+ state = project.error.nil? ? project.state : "ERROR"
	9	+ render :text => state
7	10	end
8	11
	12	+ def project_error
	13	+ @content = profile.articles.find(params[:id])
	14	+ @project = @content.project
	15	+ render :partial => 'content_viewer/project_error'
	16	+ end
	17	+
	18	+ def project_result
	19	+ @content = profile.articles.find(params[:id])
	20	+ date = params[:date]
	21	+ @project_result = date.nil? ? @content.project_result : @content.project_result_with_date(date)
	22	+ render :partial => 'content_viewer/project_result'
	23	+ end
	24	+
	25	+ def module_result
	26	+ @content = profile.articles.find(params[:id])
	27	+ @module_result = @content.module_result(params)
	28	+ render :partial => 'content_viewer/module_result'
	29	+ end
	30	+
	31	+ def project_tree
	32	+ @content = profile.articles.find(params[:id])
	33	+ date = params[:date]
	34	+ project_result = date.nil? ? @content.project_result : @content.project_result_with_date(date)
	35	+ @project_name = @content.project.name
	36	+ @source_tree = project_result.node_of(params[:module_name])
	37	+ render :partial =>'content_viewer/source_tree'
	38	+ end
	39	+
	40	+ def module_metrics_history
	41	+ metric_name = params[:metric_name]
	42	+ @content = profile.articles.find(params[:id])
	43	+ module_history = @content.result_history(params[:module_name])
	44	+ @score_history = filtering_metric_history(metric_name, module_history)
	45	+ render :partial => 'content_viewer/score_history'
	46	+ end
	47	+
	48	+ def module_grade_history
	49	+ @content = profile.articles.find(params[:id])
	50	+ modules_results = @content.result_history(params[:module_name])
	51	+ @score_history = modules_results.collect { \|module_result\| module_result.grade }
	52	+ render :partial => 'content_viewer/score_history'
	53	+ end
	54	+
	55	+ private
	56	+
	57	+ def filtering_metric_history(metric_name, module_history)
	58	+ metrics_history = module_history.map do \|module_result\|
	59	+ module_result.metric_results
	60	+ end
	61	+ metric_history = metrics_history.map do \|array_of_metric_result\|
	62	+ (array_of_metric_result.select do \|metric_result\|
	63	+ metric_result.metric.name.delete("() ") == metric_name
	64	+ end).first
	65	+ end
	66	+ metric_history.map do \|metric_result\|
	67	+ metric_result.value
	68	+ end
	69	+ end
9	70	end
...	...
...	...	@@ -1,69 +0,0 @@
1		-Feature: mezuro content
2		- As a noosfero user
3		- I want to create a Kalibro project
4		-
5		- Background:
6		- Given the following users
7		- \| login \| name \|
8		- \| joaosilva \| Joao Silva \|
9		- And I am logged in as "joaosilva"
10		- And "Mezuro" plugin is enabled
11		- And the following community
12		- \| identifier \| name \|
13		- \| mycommunity \| My Community \|
14		- And "Joao Silva" is admin of "My Community"
15		-
16		- Scenario: I see Kalibro project as an option to new content
17		- Given I am on My Community's cms
18		- When I follow "New content"
19		- Then I should see "Kalibro project"
20		-
21		- Scenario: I see Kalibro project's input form
22		- Given I am on My Community's cms
23		- When I follow "New content"
24		- And I follow "Kalibro project"
25		- Then I should see "Title"
26		- And I should see "License"
27		- And I should see "Repository type"
28		- And I should see "GIT"
29		- And I should see "REMOTE_ZIP"
30		- And I should see "REMOTE_TARBALL"
31		- And I should see "SUBVERSION"
32		- And I should see "Repository url"
33		- And I should see "Configuration"
34		- And I should see "Kalibro for Java"
35		-
36		- Scenario: I create a sample mezuro content
37		- Given I am on My Community's cms
38		- When I create a content of type "Kalibro project" with the following data
39		- \| Title \| Sample project \|
40		- \| License \| BSD \|
41		- \| Repository type \| GIT \|
42		- \| Repository url \| git://example \|
43		- Then I should see "Sample project"
44		- And I should see "Viewed one time"
45		- And I should see "BSD"
46		-
47		- Scenario: I create a real mezuro content
48		- Given I am on My Community's cms
49		- When I create a content of type "Kalibro project" with the following data
50		- \| Title \| Qt-Calculator \|
51		- \| License \| GPL 2.0 \|
52		- \| Repository type \| SUBVERSION \|
53		- \| Repository url \| https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator \|
54		- Then I should see "Qt-Calculator"
55		-
56		- Scenario: I see results from a real Kalibro project
57		- Given I am on My Community's cms
58		- When I create a content of type "Kalibro project" with the following data
59		- \| Title \| Qt-Calculator \|
60		- \| License \| GPL \|
61		- \| Repository type \| SUBVERSION \|
62		- \| Repository url \| https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator \|
63		- \| Configuration \| Kalibro for Java \|
64		- Then I should see "Qt-Calculator"
65		- And I should see "GPL"
66		- And I should see "SUBVERSION"
67		- And I should see "https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator"
68		- And I should see "Kalibro for Java"
69		- And I should see "Kalibro Service is loading the source code"
...	...	@@ -0,0 +1,29 @@
	1	+class Kalibro::BaseTool < Kalibro::Model
	2	+
	3	+ attr_accessor :name, :description, :supported_metric
	4	+
	5	+ def self.all_names
	6	+ request("BaseTool", :get_base_tool_names)[:base_tool_name].to_a
	7	+ end
	8	+
	9	+ def self.find_by_name(base_tool_name)
	10	+ new request("BaseTool", :get_base_tool, {:base_tool_name => base_tool_name})[:base_tool]
	11	+ end
	12	+
	13	+ def supported_metric=(value)
	14	+ @supported_metric = Kalibro::NativeMetric.to_objects_array value
	15	+ end
	16	+
	17	+ def supported_metrics
	18	+ @supported_metric
	19	+ end
	20	+
	21	+ def supported_metrics=(supported_metrics)
	22	+ @supported_metric = supported_metrics
	23	+ end
	24	+
	25	+ def metric(name)
	26	+ supported_metrics.find {\|metric\| metric.name == name}
	27	+ end
	28	+
	29	+end
...	...
...	...	@@ -1,16 +0,0 @@
1		-class Kalibro::Client::BaseToolClient
2		-
3		- def initialize
4		- @port = Kalibro::Client::Port.new('BaseTool')
5		- end
6		-
7		- def base_tool_names
8		- @port.request(:get_base_tool_names)[:base_tool_name].to_a
9		- end
10		-
11		- def base_tool(name)
12		- hash = @port.request(:get_base_tool, {:base_tool_name => name})[:base_tool]
13		- Kalibro::Entities::BaseTool.from_hash(hash)
14		- end
15		-
16		-end
17	0	\ No newline at end of file