diff --git a/plugins/mezuro/lib/kalibro/processing.rb b/plugins/mezuro/lib/kalibro/processing.rb
new file mode 100644
index 0000000..cf11e8d
--- /dev/null
+++ b/plugins/mezuro/lib/kalibro/processing.rb
@@ -0,0 +1,49 @@
+class Kalibro::Processing < Kalibro::Model
+
+  attr_accessor :id, :date, :state, :error, :process_times, :results_root_id
+
+  def self.has_processing(repository_id)
+    request('Processing', :has_processing, {:repository_id => repository_id})[:exists]
+  end
+  
+  def self.has_ready_processing(repository_id)
+    request('Processing', :has_ready_processing, {:repository_id => repository_id})[:exists]
+  end
+  
+  def self.has_processing_after(repository_id, date)
+    request('Processing', :has_processing_after, {:repository_id => repository_id, :date => date})[:exists]
+  end
+
+  def self.has_processing_before(repository_id, date)
+    request('Processing', :has_processing_before, {:repository_id => repository_id, :date => date})[:exists]
+  end
+
+  def self.last_processing_state_of(repository_id)
+    request('Processing', :last_processing_state, {:repository_id => repository_id})[:process_state]
+  end
+  
+  def self.last_ready_processing_of(repository_id)
+    new request('Processing', :last_ready_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.first_processing_of(repository_id)
+    new request('Processing', :first_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.last_processing_of(repository_id)
+    new request('Processing', :last_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.first_processing_after(repository_id, date)
+    new request('Processing', :first_processing_after, {:repository_id => repository_id, :date => date})[:processing]
+  end
+
+  def self.last_processing_before(repository_id, date)
+    new request('Processing', :last_processing_before, {:repository_id => repository_id, :date => date})[:processing]
+  end
+
+  def date=(value)
+    @date = value.is_a?(String) ? DateTime.parse(value) : value
+  end
+
+end
diff --git a/plugins/mezuro/lib/kalibro/project_result.rb b/plugins/mezuro/lib/kalibro/project_result.rb
deleted file mode 100644
index 244e947..0000000
--- a/plugins/mezuro/lib/kalibro/project_result.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-class Kalibro::ProjectResult < Kalibro::Model
-
-  attr_accessor :project, :date, :load_time, :analysis_time, :source_tree, :collect_time
-
-  def self.last_result(project_name)
-    new request('ProjectResult', :get_last_result_of, {:project_name => project_name})[:project_result]
-  end
-  
-  def self.first_result(project_name)
-    new request('ProjectResult', :get_first_result_of, {:project_name => project_name})[:project_result]
-  end
-
-  def self.first_result_after(project_name, date)
-    new request('ProjectResult', :get_first_result_after, {:project_name => project_name, :date => date})[:project_result]
-  end
-
-  def self.last_result_before(project_name, date)
-    new request('ProjectResult', :get_last_result_before, {:project_name => project_name, :date => date})[:project_result]
-  end
-
-  def self.has_results?(project_name)
-    request('ProjectResult', :has_results_for, {:project_name => project_name})[:has_results]
-  end
-  
-  def self.has_results_before?(project_name, date)
-    request('ProjectResult', :has_results_before, {:project_name => project_name, :date => date})[:has_results]
-  end
-
-  def self.has_results_after?(project_name, date)
-    request('ProjectResult', :has_results_after, {:project_name => project_name, :date => date})[:has_results]
-  end
-  
-  def project=(value)
-    @project = (value.kind_of?(Hash)) ? Kalibro::Project.new(value) : value
-  end
-  
-  def date=(value)
-    @date = value.is_a?(String) ? DateTime.parse(value) : value
-  end
-
-  def load_time=(value)
-    @load_time = value.to_i
-  end
-
-  def collect_time=(value)
-    @collect_time = value.to_i
-  end
-
-  def analysis_time=(value)
-    @analysis_time = value.to_i
-  end
-  
-  def source_tree=(value)
-    @source_tree = value.kind_of?(Hash) ? Kalibro::ModuleNode.new(value) : value
-  end
-  
-  def formatted_load_time
-    format_milliseconds(@load_time)
-  end
-
-  def formatted_analysis_time
-     format_milliseconds(@analysis_time)
-  end
-
-  def format_milliseconds(value)
-    seconds = value.to_i/1000
-    hours = seconds/3600
-    seconds -= hours * 3600
-    minutes = seconds/60
-    seconds -= minutes * 60
-    "#{format(hours)}:#{format(minutes)}:#{format(seconds)}"
-  end
-
-  def format(amount)
-    ('%2d' % amount).sub(/\s/, '0')
-  end
-  
-  def node(module_name)
-    if module_name.nil? or module_name == project.name
-      node = source_tree
-    else
-		path = Kalibro::Module.parent_names(module_name)
-		parent = @source_tree
-		path.each do |node_name|
-		  parent = get_leaf_from(parent, node_name)
-		end
-		parent
-	end
-  end
-  
-  private
-
-  def get_leaf_from(node, module_name) 
-    node.children.each do |child_node|
-      return child_node if child_node.module.name == module_name
-    end
-    nil
-  end
-
-end
diff --git a/plugins/mezuro/test/fixtures/processing_fixtures.rb b/plugins/mezuro/test/fixtures/processing_fixtures.rb
new file mode 100644
index 0000000..806ae77
--- /dev/null
+++ b/plugins/mezuro/test/fixtures/processing_fixtures.rb
@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/process_time_fixtures'
+
+class ProcessingFixtures
+
+  def self.processing
+    Kalibro::Processing.new processing_hash  
+  end
+
+  def self.processing_hash
+    {
+      :id => 31,
+      :date => '2011-10-20T18:26:43.151+00:00',
+      :state => 'READY',
+      :process_times => [ProcessTimeFixtures.process_time_hash],
+      :results_root_id => 13  
+    }
+  end
+    
+end
diff --git a/plugins/mezuro/test/fixtures/project_result_fixtures.rb b/plugins/mezuro/test/fixtures/project_result_fixtures.rb
deleted file mode 100644
index e9f2be4..0000000
--- a/plugins/mezuro/test/fixtures/project_result_fixtures.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-require File.dirname(__FILE__) + '/project_fixtures'
-require File.dirname(__FILE__) + '/module_node_fixtures'
-require File.dirname(__FILE__) + '/module_result_fixtures'
-
-class ProjectResultFixtures
-
-  def self.project_result
-    Kalibro::ProjectResult.new project_result_hash  
-  end
-
-  def self.project_result_hash
-    {
-      :project => ProjectFixtures.project_hash,
-      :date => ModuleResultFixtures.module_result_hash[:date],
-      :load_time => 14878,
-      :analysis_time => 1022,
-      :source_tree => ModuleNodeFixtures.module_node_hash, 
-      :collect_time => 14878,
-      :attributes! =>
-      {
-        :source_tree =>
-        {
-          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
-          "xsi:type"=>"kalibro:moduleNodeXml"
-        },
-        :project =>
-        {
-          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
-          "xsi:type"=>"kalibro:projectXml"
-        }
-      }
-    }
-  end
-    
-end
diff --git a/plugins/mezuro/test/unit/kalibro/processing_test.rb b/plugins/mezuro/test/unit/kalibro/processing_test.rb
new file mode 100644
index 0000000..21afecc
--- /dev/null
+++ b/plugins/mezuro/test/unit/kalibro/processing_test.rb
@@ -0,0 +1,133 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/processing_fixtures"
+
+class ProcessingTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = ProcessingFixtures.processing_hash
+    @processing = ProcessingFixtures.processing
+    
+    @repository_id = 31
+    
+=begin
+    @project_name = @processing.project.name
+    @date = @processing.date
+    @flag = DateTime.now.sec % 2 == 0 #random choose between true or false
+
+    @request = {:project_name => @project_name}
+    @request_with_date = {:project_name => @project_name, :date => @date}
+    @flag_response = {:has_results => @flag}
+    @result_response = {:processing => @processing.to_hash}
+=end
+  end
+
+  should 'create project result from hash' do
+    assert_equal @processing.results_root_id, Kalibro::Processing.new(@hash).results_root_id
+  end
+
+  should 'convert project result to hash' do
+    assert_equal @hash, @processing.to_hash
+  end
+
+  should 'verify if a repository has a processing' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing, {:repository_id => true_repository_id}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing, {:repository_id => false_repository_id}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing(true_repository_id)
+    assert !Kalibro::Processing.has_processing(false_repository_id)
+  end
+  
+  should 'verify if a repository has a ready processing' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with('Processing',:has_ready_processing, {:repository_id => true_repository_id}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with('Processing',:has_ready_processing, {:repository_id => false_repository_id}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_ready_processing(true_repository_id)
+    assert !Kalibro::Processing.has_ready_processing(false_repository_id)
+  end
+  
+  should 'verify if a repository has a processing after a date' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing_after, {:repository_id => true_repository_id, :date => @processing.date}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing_after, {:repository_id => false_repository_id, :date => @processing.date}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing_after(true_repository_id, @processing.date)
+    assert !Kalibro::Processing.has_processing_after(false_repository_id, @processing.date)
+  end  
+  
+  should 'verify if a repository has a processing before a date' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing_before, {:repository_id => true_repository_id, :date => @processing.date}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing_before, {:repository_id => false_repository_id, :date => @processing.date}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing_before(true_repository_id, @processing.date)
+    assert !Kalibro::Processing.has_processing_before(false_repository_id, @processing.date)
+  end  
+  
+  should 'get last processing state of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing',:last_processing_state, {:repository_id => @repository_id}).returns({:process_state => @processing.state})
+    assert_equal @processing.state, Kalibro::Processing.last_processing_state_of(@repository_id)
+  end
+  
+  should 'get last ready processing of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :last_ready_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_ready_processing_of(@repository_id).id
+  end
+
+  should 'get first processing of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :first_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.first_processing_of(@repository_id).id
+  end
+  
+  should 'get last processing of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :last_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_processing_of(@repository_id).id
+  end
+  
+  should 'get first processing after a date of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :first_processing_after, {:repository_id => @repository_id, :date => @processing.date}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.first_processing_after(@repository_id, @processing.date).id
+  end
+  
+  should 'get last processing before a date of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :last_processing_before, {:repository_id => @repository_id, :date => @processing.date}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_processing_before(@repository_id, @processing.date).id
+  end
+  
+=begin
+
+  should 'retrieve formatted load time' do
+    assert_equal '00:00:14', @processing.formatted_load_time
+  end
+
+  should 'retrieve formatted analysis time' do
+    assert_equal '00:00:01', @processing.formatted_analysis_time
+  end
+
+  should 'retrive complex module' do
+    assert_equal @hash[:source_tree][:child][0][:child].first, @processing.node("org.Window").to_hash
+  end
+
+  should 'return source tree node when nil is given' do
+    assert_equal @hash[:source_tree], @processing.node(nil).to_hash 
+  end
+  
+  should 'return source tree node when project name is given' do
+    assert_equal @hash[:source_tree], @processing.node(@processing.project.name).to_hash 
+  end
+
+  should 'return correct node when module name is given' do
+    assert_equal @hash[:source_tree][:child][2], @processing.node("main").to_hash
+  end
+=end
+end
diff --git a/plugins/mezuro/test/unit/kalibro/project_result_test.rb b/plugins/mezuro/test/unit/kalibro/project_result_test.rb
deleted file mode 100644
index 12dc082..0000000
--- a/plugins/mezuro/test/unit/kalibro/project_result_test.rb
+++ /dev/null
@@ -1,88 +0,0 @@
-require "test_helper"
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
-
-class ProjectResultTest < ActiveSupport::TestCase
-
-  def setup
-    @hash = ProjectResultFixtures.project_result_hash
-    @project_result = ProjectResultFixtures.project_result
-    
-    @project_name = @project_result.project.name
-    @date = @project_result.date
-    @flag = DateTime.now.sec % 2 == 0 #random choose between true or false
-
-    @request = {:project_name => @project_name}
-    @request_with_date = {:project_name => @project_name, :date => @date}
-    @flag_response = {:has_results => @flag}
-    @result_response = {:project_result => @project_result.to_hash}
-  end
-
-  should 'create project result from hash' do
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.new(@hash).analysis_time
-  end
-
-  should 'convert project result to hash' do
-    assert_equal @hash, @project_result.to_hash
-  end
-
-  should 'get last result' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_last_result_of, @request).returns(@result_response)
-    assert_equal @project_result.analysis_time , Kalibro::ProjectResult.last_result(@project_name).analysis_time
-  end
-
-  should 'get first result' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_first_result_of, @request).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.first_result(@project_name).analysis_time
-  end
-
-  should 'get first result after date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_first_result_after, @request_with_date).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.first_result_after(@project_name, @date).analysis_time
-  end
-  
-  should 'get last result before date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_last_result_before, @request_with_date).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.last_result_before(@project_name, @date).analysis_time
-  end
-  
-  should 'verify if project has results' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_for, @request).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results?(@project_name)
-  end
-  
-  should 'verify if project has results before date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_before, @request_with_date).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results_before?(@project_name, @date)
-  end
-  
-  should 'verify if project has results after date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_after, @request_with_date).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results_after?(@project_name, @date)
-  end
-
-  should 'retrieve formatted load time' do
-    assert_equal '00:00:14', @project_result.formatted_load_time
-  end
-
-  should 'retrieve formatted analysis time' do
-    assert_equal '00:00:01', @project_result.formatted_analysis_time
-  end
-
-  should 'retrive complex module' do
-    assert_equal @hash[:source_tree][:child][0][:child].first, @project_result.node("org.Window").to_hash
-  end
-
-  should 'return source tree node when nil is given' do
-    assert_equal @hash[:source_tree], @project_result.node(nil).to_hash 
-  end
-  
-  should 'return source tree node when project name is given' do
-    assert_equal @hash[:source_tree], @project_result.node(@project_result.project.name).to_hash 
-  end
-
-  should 'return correct node when module name is given' do
-    assert_equal @hash[:source_tree][:child][2], @project_result.node("main").to_hash
-  end
-
-end
--
libgit2 0.21.2