imparcial 0.0.4 → 0.0.5

data/lib/imparcial/exception.rb

@@ -0,0 +1,71 @@
+module Imparcial
+  
+    # Main class
+  
+    class ImparcialError < StandardError; end
+  
+    # Adapter
+  
+    class AdapterError           < ImparcialError; end
+    class AdapterNotFound        < AdapterError; end
+    class AdapterConnectionError < AdapterError; end
+    
+    # Expression
+    
+    class ExpressionError < ImparcialError; end
+
+    class FeatureNotFound < ExpressionError; end  
+    class ConditionError  < ExpressionError; end
+    class OptionError     < ExpressionError; end         
+    class ResultError     < ExpressionError; end      
+
+    # Table
+
+    class TableError       < ExpressionError; end
+    class TableCreateError < TableError; end
+    class TableDropError   < TableError; end
+    class TableListError   < TableError; end
+    class TableUpdateError < TableError; end
+    
+    # Column  
+      
+    class ColumnError           < ExpressionError; end
+    class ColumnListError       < ColumnError; end
+    class ColumnUpdateError     < ColumnError; end
+    class ColumnCreateError     < ColumnError; end
+    class ColumnDropError       < ColumnError; end
+    class ColumnConstraintError < ColumnError; end
+    class ColumnRenameError     < ColumnError; end
+    
+    # Crud
+
+    class SelectError < ExpressionError; end  
+    class InsertError < ExpressionError; end
+    class DeleteError < ExpressionError; end
+    class UpdateError < ExpressionError; end
+
+    # Sequence
+  
+    class SequenceError       < ExpressionError; end
+    class SequenceCreateError < SequenceError; end
+    class SequenceDropError   < SequenceError; end
+    class SequenceListError   < SequenceError; end
+    class SequenceUpdateError < SequenceError; end
+  
+    # Transaction
+  
+    class TransactionError < ExpressionError; end
+    
+    # Lock
+    
+    class LockError < ExpressionError; end
+  
+    # Index
+
+    class IndexError       < ExpressionError; end
+    class IndexCreateError < IndexError; end
+    class IndexDropError   < IndexError; end
+    class IndexListError   < IndexError; end
+    class IndexUpdateError < IndexError; end
+    
+end

data/lib/imparcial/extension.rb

@@ -0,0 +1,90 @@
+module Kernel
+    
+  def check_options ( expected_options , user_options )
+
+    # Let's iterate over all user options.
+
+    user_options.each do |user_option, content|
+            
+      confirmed = false
+            
+      # Let's iterate over expected options.
+            
+      expected_options.each_key do |name|
+                        
+        if name.to_s == user_option.to_s
+              
+          # Let's verify if content is a collection.
+              
+          if content.class == Array || content.class == Hash
+                  
+            # If so, we need to check out for content.
+                   
+            raise StandardError.new('Option ' + name.to_s + ' needs content') if content.length == 0
+                  
+          end
+              
+          # Yeah, user option matches with expected option.
+              
+          confirmed = true
+          break
+              
+        end            
+            
+      end
+            
+      # If there's a match, we move forward.
+            
+      if confirmed
+            
+        confirmed = false
+        next
+              
+      end
+            
+      # Opss. user has entered with an unknown option.
+            
+      raise StandardError.new('Cannot find option ' + user_option.to_s)
+            
+    end
+          
+    # Let's iterate over all expected and required options.
+          
+    for name, condition in expected_options
+ 
+      # If this option is not required, we can move forward.
+ 
+      next unless condition == :required
+      confirmed = false            
+                        
+      # Over user's.            
+                        
+      user_options.each_key do |user_option|
+
+        if name.to_s == user_option.to_s
+                
+          confirmed = true
+          break
+                
+        end
+              
+      end
+          
+      # Alright, user has entered with a necessary option.
+          
+      if confirmed
+            
+        confirmed = false
+        next
+              
+      end
+            
+      # Opss... user need to provide a required option.
+            
+      raise StandardError.new('Option ' + name.to_s + ' is necessary')
+                    
+    end        
+              
+  end        
+  
+end

data/lib/imparcial/initializer.rb

@@ -0,0 +1,30 @@
+module Imparcial
+ 
+  class Initializer
+    
+    def self.get_adapter ( name )
+      
+      name = name.to_s          
+          
+      require "imparcial/driver/#{name}"
+                
+      ("Imparcial::Driver::#{name.camelize}Adapter").to_const
+   
+    end
+                                            
+    def self.adapter ( name )
+          
+      adapter = (get_adapter name).new
+
+      yield adapter
+
+      adapter
+      
+    rescue LoadError
+  
+      raise AdapterNotFound.new(driver + ' cannot be found')
+        
+    end 
+      
+  end
+end

data/lib/imparcial.rb

@@ -11,6 +11,6 @@ require 'imparcial/initializer'
 
 module Imparcial
   
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
   
 end

data/test/unit/base/common/tc_quote.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../../helper'
+ 
+context 'Unquoting Values' do
+  
+  specify 'should do with integer' do
+    
+    assert_equal 1, abstract_adapter.unquote_value('1')
+    
+  end
+  
+  specify 'should do with float' do
+    
+    assert_equal 0.99, abstract_adapter.unquote_value('0.99')
+    assert_equal 1.99, abstract_adapter.unquote_value('1.99')
+    
+  end
+  
+  specify 'should do with zero' do
+    
+    assert_equal 0, abstract_adapter.unquote_value('0')
+    
+  end
+  
+  specify 'should do with nil' do
+    
+    assert_equal nil, abstract_adapter.unquote_value(nil)
+    
+  end
+  
+end

data/test/unit/base/expression/tc_column.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/../../helper'
+
+context 'Abstract Adapter Columns' do
+
+  def setup
+    
+    abstract_adapter.drop_all_tables
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string, :size => 50}
+    abstract_adapter.create_table :table_name => 'bla',:fields => fields
+
+  end
+
+  specify 'should get columns information' do
+    
+    columns = abstract_adapter.get_columns_information(:table_name=>'bla')
+    
+    assert_equal 'id', columns[0][:name]
+    assert_equal :integer, columns[0][:type]
+    assert_equal nil, columns[0][:size]
+    
+    assert_equal 'name', columns[1][:name]
+    assert_equal :string, columns[1][:type]
+    assert_equal 50, columns[1][:size]
+    
+  end
+  
+  specify 'should get info about one column' do
+    
+    column = abstract_adapter.get_column_information(:table_name => 'bla', :field_name => 'id')
+    assert_equal 'id', column[:name]
+    assert_equal :integer, column[:type]
+    assert_equal nil, column[:size]
+    
+  end
+
+end
+
+
+context 'Abstract Adapter Table Update' do
+  
+  def setup
+  
+    abstract_adapter.drop_all_tables
+    abstract_adapter.create_table :table_name => 'bla',:fields => [
+    {:name => :id, :type => :integer}, {:name => :age, :type => :integer},
+    {:name => :salary,:type => :float}
+    ]
+    
+  end
+    
+  specify 'should add a column' do
+    
+    assert_equal 3, abstract_adapter.get_columns_information(:table_name => 'bla').length    
+    abstract_adapter.add_columns :table_name => 'bla', :fields => [{:name => :name, :type => :string},{:name => :some, :type => :integer}]
+    assert_equal 5, abstract_adapter.get_columns_information(:table_name => 'bla').length
+    
+  end
+
+  specify 'should drop a column' do
+    
+    assert_equal 3, abstract_adapter.get_columns_information(:table_name => 'bla').length    
+    abstract_adapter.drop_columns :table_name => 'bla', :fields => ['id','age']
+    assert_equal 1, abstract_adapter.get_columns_information(:table_name => 'bla').length    
+    
+  end
+
+  specify 'should rename a column' do
+    
+    abstract_adapter.rename_column :table_name => 'bla', :field => {:id => :idx}
+    abstract_adapter.rename_columns :table_name => 'bla', :fields => {:idx => :id, :age => :agex}      
+    
+  end
+  
+  specify 'should modify a column' do
+    
+    assert_nothing_raised do
+      abstract_adapter.modify_columns :table_name => 'bla', :fields => [{:name => :id, :type => :string, :size => 10},{:name => :age, :type => :float}]
+    end
+    
+  end
+
+end

data/test/unit/base/expression/tc_constraint.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../../helper'
+
+context 'Abstract Adapter Constraints' do
+
+  def setup
+    
+    abstract_adapter.drop_all_tables
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string, :size => 50}
+    abstract_adapter.create_table :table_name => 'bla',:fields => fields
+      
+  end
+
+  specify 'should add primary key' do
+    
+    assert_nothing_raised do
+      abstract_adapter.add_primary_key :table_name => 'bla', :fields => ['id']
+    end    
+    
+  end
+  
+  specify 'should add auto inc' do
+    
+    assert_nothing_raised do
+      abstract_adapter.add_auto_increment :table_name => 'bla', :field => 'id'
+    end
+    
+  end
+  
+  specify 'should add default value' do
+    
+    assert_nothing_raised do
+      abstract_adapter.add_default_value :table_name => 'bla', :fields => {:id => 1}
+    end
+    
+  end
+
+end

data/test/unit/base/expression/tc_delete.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../helper'
+
+context 'Abstract Adapter' do
+  
+  def setup
+    
+    abstract_adapter.drop_all_tables 
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string}    
+    abstract_adapter.create_table :table_name => 'bla', :fields => fields
+    abstract_adapter.insert :table_name => 'bla', :values => {:id => 1, :name => 'jota'}
+    abstract_adapter.insert :table_name => 'bla', :values => {:id => 2, :name => 'mauricio'}       
+    
+  end
+  
+  specify 'should not delete without conditions' do
+    
+    assert_raise Imparcial::OptionError do
+      abstract_adapter.delete :table_name => 'bla'
+    end
+    
+  end
+  
+  specify 'should not delete all with conditions' do
+    
+    assert_raise Imparcial::OptionError do
+      abstract_adapter.delete_all :table_name => 'bla', :conditions => ['id = 1']
+    end
+    
+  end
+  
+  specify 'should delete some records' do
+    
+    assert_nothing_raised do
+      abstract_adapter.delete :table_name => 'bla', :conditions => ['id = 1']      
+    end
+    assert_equal 1, abstract_adapter.total_of_records(:table_name=>'bla')    
+    
+  end
+  
+  specify 'should delete all records' do
+    
+    assert_nothing_raised do
+      abstract_adapter.delete_all :table_name => 'bla'
+    end
+    assert_equal 0, abstract_adapter.total_of_records(:table_name=>'bla')   
+    
+  end
+  
+end

data/test/unit/base/expression/tc_index.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../helper'
+
+context 'Abstract Adapter' do
+  
+  def setup
+    
+    abstract_adapter.drop_all_tables  
+    abstract_adapter.drop_all_indexes :table_name => 'bla'
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string}    
+    abstract_adapter.create_table :table_name => 'bla', :fields => fields
+    
+  end
+
+  specify 'should create an index' do
+    
+    abstract_adapter.create_index :index_name => 'i_id', :table_name => 'bla', :column_name => 'id'
+    assert_equal true, abstract_adapter.index_exists?(:index_name => 'i_id', :table_name => 'bla')
+    
+  end
+
+  specify 'should retrieve all indexes' do
+    
+    abstract_adapter.create_index :index_name => 'i_id', :table_name => 'bla', :column_name => 'id'
+    abstract_adapter.create_index :index_name => 'i_id2', :table_name => 'bla', :column_name => 'id'
+    
+    assert_equal 2, abstract_adapter.get_indexes(:table_name => 'bla').length
+    
+  end
+  
+  specify 'should retrieve indexes for a table' do
+    
+    abstract_adapter.create_index :index_name => 'i_id', :table_name => 'bla', :column_name => 'id'    
+    indexes = abstract_adapter.get_indexes(:table_name => 'bla')
+    assert_equal 1, indexes.length
+    assert_equal 'bla', indexes[0][:table]
+    assert_equal 'i_id', indexes[0][:name]
+    assert_equal 'id', indexes[0][:column]
+    
+  end
+  
+end

data/test/unit/base/expression/tc_insert.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../../helper'
+
+context 'Abstract Adapter' do
+  
+  def setup
+    
+    abstract_adapter.drop_all_tables  
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string}    
+    abstract_adapter.create_table :table_name => 'bla', :fields => fields
+    
+  end
+  
+  specify 'should insert with everything ok' do
+    
+    assert_nothing_raised do
+      abstract_adapter.insert :table_name => 'bla',:values => {:id => 10, :name => 'pedro'}
+    end
+    
+  end
+  
+  specify 'should not insert when trying to insert non avaliable fields' do
+    
+    assert_raise Imparcial::InsertError do
+      abstract_adapter.insert :table_name => 'bla',:values => {:idx => 10, :name => 'pedro'}    
+    end
+    
+  end
+  
+  specify 'should automagically increment id' do
+
+    fields = []
+    fields << {:name => :id, :type => :integer, :auto_increment => true, :pk => true, :allow_null => false}
+    fields << {:name => :name, :type => :string}
+
+    abstract_adapter.create_table :table_name => 'bla2', :fields => fields
+    assert_nothing_raised do
+      abstract_adapter.insert :table_name => 'bla2',:values => { :name => 'pedro'}    
+    end
+    
+  end
+  
+end

data/test/unit/base/expression/tc_select.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/../../helper'
+
+context 'Abstract Adapter' do
+  
+  def setup
+    
+    abstract_adapter.drop_all_tables    
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string}    
+    abstract_adapter.create_table :table_name => 'bla', :fields => fields
+    abstract_adapter.insert :table_name => 'bla', :values => {:id => 1, :name => 'jota'}
+    abstract_adapter.insert :table_name => 'bla', :values => {:id => 2, :name => 'mauricio'}    
+    
+  end  
+  
+  specify 'should select with defined fields' do
+    
+    abstract_adapter.select :table_name => 'bla', :fields => [:name]
+    
+    a = abstract_adapter.result.fetch_in_array
+    assert_equal 'jota', a[0][0].value
+    assert_equal 'mauricio', a[1][0].value
+    
+  end
+  
+  specify 'should select with all fields' do
+    
+    abstract_adapter.select :table_name => 'bla'
+    
+    a = abstract_adapter.result.fetch_in_array
+    assert_equal 1, a[0][0].value
+    assert_equal 'jota', a[0][1].value
+    assert_equal 2, a[1][0].value
+    assert_equal 'mauricio', a[1][1].value        
+    
+  end
+  
+  specify 'should select with conditions' do
+    
+    abstract_adapter.select :table_name => 'bla', :conditions => ['name = ?','mauricio']
+    a = abstract_adapter.result.fetch_in_array
+    assert_equal 2, a[0][0].value
+    assert_equal 'mauricio', a[0][1].value
+    
+  end
+  
+  specify 'should select with limits' do
+    
+    abstract_adapter.select :table_name => 'bla', :limit => 1
+    a = abstract_adapter.result.fetch_first_row
+    assert_equal 1, a[0].column_value
+    assert_equal 'jota', a[1].column_value
+    
+  end
+  
+  specify 'should select ordering desc' do
+
+    abstract_adapter.select :table_name => 'bla', :order_desc => :id    
+    a = abstract_adapter.result.fetch_in_array
+    assert_equal 2, a[0][0].column_value
+    
+  end
+  
+  specify 'should select ordering asc' do
+
+    abstract_adapter.select :table_name => 'bla', :order_asc => :name   
+    a = abstract_adapter.result.fetch_in_array
+    assert_equal 1, a[0][0].column_value
+    
+  end  
+  
+end
+
+context 'Abstract Adapter Advanced' do
+  
+  def setup
+
+    abstract_adapter.drop_table_if_necessary :table_name => 'person'    
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string}    
+    abstract_adapter.create_table :table_name => 'person', :fields => fields
+    abstract_adapter.insert :table_name => 'person', :values => {:id => 1, :name => 'jota'}
+    abstract_adapter.insert :table_name => 'person', :values => {:id => 2, :name => 'mauricio'}    
+
+    abstract_adapter.drop_table_if_necessary :table_name => 'telephone'    
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :number, :type => :integer}    
+    fields << {:name => :person_id, :type => :integer}
+    abstract_adapter.create_table :table_name => 'telephone', :fields => fields
+    abstract_adapter.insert :table_name => 'telephone', :values => {:id => 1, :number => 42442, :person_id => 1}
+
+
+    abstract_adapter.drop_table_if_necessary :table_name => 'person_to_group'
+    fields = []
+    fields << {:name => :person_id, :type => :integer}
+    fields << {:name => :group_id, :type => :integer}
+    abstract_adapter.create_table :table_name => 'person_to_group', :fields => fields
+    abstract_adapter.insert :table_name => 'person_to_group', :values => {:person_id => 1, :group_id => 1}
+    abstract_adapter.insert :table_name => 'person_to_group', :values => {:person_id => 1, :group_id => 2}
+    abstract_adapter.insert :table_name => 'person_to_group', :values => {:person_id => 2, :group_id => 1}    
+    
+    abstract_adapter.drop_table_if_necessary :table_name => 'group'
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string}
+    abstract_adapter.create_table :table_name => 'group', :fields => fields
+    abstract_adapter.insert :table_name => 'group', :values => {:id => 1, :name => 'los iluminados'}
+    abstract_adapter.insert :table_name => 'group', :values => {:id => 2, :name => 'los desulididos'}        
+    
+    abstract_adapter.drop_table_if_necessary :table_name => 'leader'    
+    fields = []
+    fields << {:name => :id, :type => :integer}
+    fields << {:name => :name, :type => :string} 
+    fields << {:name => :group_id, :type => :integer}
+    abstract_adapter.create_table :table_name => 'leader', :fields => fields
+    abstract_adapter.insert :table_name => 'leader', :values => {:id => 1, :name => 'orson', :group_id => 1}       
+    
+  end
+  
+  
+  specify 'should select complex' do
+    
+    person          = {:name => 'person', :key_for_telephone => 'id', :key_for_person_to_group => 'id'}
+    person_to_group = {:name => 'person_to_group', :relkind => :left_join, :key_for_person => 'person_id', :key_for_group => 'group_id' }
+    group           = {:name => 'group', :relkind => :left_join, :key_for_person_to_group => 'id', :key_for_leader => 'id'}
+    telephone       = {:name => 'telephone', :relkind => :left_join, :key_for_person => 'person_id'}
+    leader          = {:name => 'leader', :relkind => :left_join, :key_for_group => 'group_id'}
+     
+    abstract_adapter.select :joins => 
+    [ person =>
+      [  person_to_group => [group => [leader => nil]],
+         telephone       => nil
+      ] 
+    ]
+     
+  end
+  
+  
+end

data/test/unit/base/expression/tc_sequence.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../../helper'
+if $ADAPTER != 'mysql'
+context 'Abstract Adapter' do
+
+  def setup
+    
+    abstract_adapter.drop_all_sequences
+
+  end
+
+  specify 'should create a sequence' do
+  
+    assert_nothing_raised do
+       abstract_adapter.create_sequence :sequence_name => 'seq_id'
+    end
+  
+  end
+
+  specify 'should drop a sequence' do
+  
+    assert_nothing_raised do
+      abstract_adapter.create_sequence :sequence_name => 'seq_id'
+      abstract_adapter.drop_sequence :sequence_name => 'seq_id'
+      abstract_adapter.create_sequence :sequence_name => 'seq_id'
+    end
+  
+  end
+  
+  specify 'should verify if a given sequence exists' do
+
+     assert_equal false, abstract_adapter.sequence_exists?(:sequence_name => 'seq_id')
+     abstract_adapter.create_sequence :sequence_name => 'seq_id'
+     assert_equal true, abstract_adapter.sequence_exists?(:sequence_name => 'seq_id')
+       
+  end
+  
+  specify 'should list sequences' do
+  
+     abstract_adapter.create_sequence :sequence_name => 'seq_id'
+     abstract_adapter.create_sequence :sequence_name => 'seq_id2'     
+    
+     seqs = abstract_adapter.get_sequences
+     assert_equal 2, seqs.length    
+  
+  end
+
+end
+end