momomoto 0.1.7 → 0.1.8

data/lib/momomoto/base.rb

@@ -126,29 +126,41 @@ module Momomoto
       end
 
       # construct the Row class for the table
-      def initialize_row( row, table )
+      def initialize_row( row, table, columns = table.columns )
 
         const_set( :Methods, Module.new ) if not const_defined?( :Methods )
-        const_set( :StandardMethods, Module.new ) if not const_defined?( :StandardMethods )
+        row.const_set( :StandardMethods, Module.new ) if not row.const_defined?( :StandardMethods )
 
         if not row.ancestors.member?( Momomoto::Row )
           raise CriticalError, "Row is not inherited from Momomoto::Row"
         end
 
         row.instance_eval do instance_variable_set( :@table, table ) end
+        row.instance_eval do instance_variable_set( :@columns, columns ) end
+        row.instance_eval do instance_variable_set( :@column_order, columns.keys ) end
 
-        define_row_accessors( const_get( :StandardMethods ), table )
+        define_row_accessors( row.const_get( :StandardMethods ), table, columns )
 
         row.instance_eval do
-          include table.const_get( :StandardMethods )
+          include row.const_get( :StandardMethods )
           include table.const_get( :Methods )
         end
 
+        if table.columns.keys.length != columns.keys.length
+          unused = table.columns.keys - columns.keys
+          unused.each do | field |
+            row.class_eval do
+              undef_method field if row.instance_methods.member?( "#{field}" )
+              undef_method "#{field}=" if row.instance_methods.member?( "#{field}=" )
+            end
+          end
+        end
+
       end
 
       # defines row setter and getter in the module StandardMethods which
       # is later included in the Row class
-      def define_row_accessors( method_module, table, columns = self.columns )
+      def define_row_accessors( method_module, table, columns )
         columns.each_with_index do | ( field_name, data_type ), index |
           method_module.instance_eval do
             # define getter for row class

data/lib/momomoto/row.rb

@@ -10,6 +10,14 @@ module Momomoto
       @table
     end
 
+    def self.columns
+      @columns
+    end
+
+    def self.column_order
+      @column_order
+    end
+
     def []( fieldname )
       get_column( fieldname )
     end
@@ -66,7 +74,7 @@ module Momomoto
     # convert row to hash
     def to_hash
       hash = {}
-      self.class.table.columns.keys.each do | key |
+      self.class.columns.keys.each do | key |
         hash[key] = self[key]
       end
       hash
@@ -79,7 +87,7 @@ module Momomoto
         raise Error, "Setting primary keys(#{column}) is only allowed for new records"
       end
       value = table.columns[column.to_sym].filter_set( value )
-      index = table.column_order.index( column.to_sym )
+      index = self.class.column_order.index( column.to_sym )
       if !table.columns[column.to_sym].equal( value, @data[index] )
         mark_dirty( column )
         @data[index] = value
@@ -89,7 +97,7 @@ module Momomoto
     # generic getter for column values
     def get_column( column )
       table = self.class.table
-      index = table.column_order.index( column.to_sym )
+      index = self.class.column_order.index( column.to_sym )
       if table.columns[column.to_sym].respond_to?( :filter_get )
         table.columns[column.to_sym].filter_get( @data[index] )
       else

data/lib/momomoto/table.rb

@@ -23,7 +23,6 @@ module Momomoto
         # we store the order separate because it's quite important 
         # that it's constant otherwise get_column and set_column 
         # on the row class might stop working 
-        @column_order = columns.keys
         @columns = columns
       end
 
@@ -36,11 +35,6 @@ module Momomoto
         @columns
       end
 
-      # get the columns of this table
-      def column_order #:nodoc:
-        @column_order
-      end
-
       def initialize_table # :nodoc:
 
         @table_name ||= construct_table_name( self.name )
@@ -57,6 +51,7 @@ module Momomoto
 
         const_set( :Row, Class.new( Momomoto::Row ) ) if not const_defined?( :Row )
         initialize_row( const_get( :Row ), self )
+        @row_cache = {}
 
         # mark class as initialized
         self.initialized = true
@@ -118,16 +113,7 @@ module Momomoto
       # Searches for records and returns an array containing the records
       def select( conditions = {}, options = {} )
         initialize_table unless initialized
-        if options[:columns]
-          row_class = Class.new( Momomoto::Row )
-          cols = {}
-          columns.each do | key, value |
-            cols[key] = value if options[:columns].member?( key )
-          end
-          define_row_accessors( row_class, self, cols )
-        else
-          row_class = const_get(:Row)
-        end
+        row_class = build_row_class( options )
         sql = compile_select( conditions, options )
         data = []
         database.execute( sql ).each do | row |
@@ -136,6 +122,25 @@ module Momomoto
         data
       end
 
+      def build_row_class( options )
+        if options[:columns]
+          options[:columns] += primary_keys
+          options[:columns].uniq!
+          if not @row_cache[options[:columns]]
+            row_class = Class.new( Momomoto::Row )
+            cols = {}
+            columns.each do | key, value |
+              cols[key] = value if options[:columns].member?( key )
+            end
+            initialize_row( row_class, self, cols )
+            @row_cache[options[:columns]] = row_class
+          end
+          return @row_cache[options[:columns]]
+        else
+          return const_get(:Row)
+        end
+      end
+
       # Searches for records and returns an array containing the records
       def select_outer_join( conditions = {}, options = {} )
         initialize_table unless initialized
@@ -236,7 +241,6 @@ module Momomoto
 
       # write row back to database
       def write( row ) # :nodoc:
-        raise CriticalError unless row.class == const_get(:Row)
         if row.new_record?
           insert( row )
         else
@@ -274,7 +278,7 @@ module Momomoto
       def update( row ) # :nodoc:
         raise CriticalError, 'Updating is only allowed for tables with primary keys' if primary_keys.empty?
         setter, conditions = [], {}
-        columns.each do | field_name, data_type |
+        row.class.columns.each do | field_name, data_type |
           next if not row.dirty.member?( field_name )
           setter << field_name.to_s + ' = ' + data_type.escape(row.get_column(field_name))
         end

data/test/test_datatype.rb

@@ -1,22 +1,18 @@
 
 class TestDatatype < Test::Unit::TestCase
 
-  DATATYPES = Momomoto::Datatype.constants.map do | t | 
-    Momomoto::Datatype.const_get( t ) 
-  end
+  Momomoto::Datatype.constants.each do | type_name | 
+    type = Momomoto::Datatype.const_get( type_name ) 
 
-  def test_default
-    DATATYPES.each do | type |
+    define_method( "test_default_#{type_name}" ) do
       row = Momomoto::Information_schema::Columns.new
       row.column_default = 'default-value'
       a = type.new( row )
       assert_equal( 'default-value', a.default )
       assert_equal( false, type.new.default )
     end
-  end
 
-  def test_not_null
-    DATATYPES.each do | type |
+    define_method( "test_not_null_#{type_name}" ) do
       row = Momomoto::Information_schema::Columns.new
       row.is_nullable = "YES"
       assert_equal( false, type.new( row ).not_null? )
@@ -25,10 +21,8 @@ class TestDatatype < Test::Unit::TestCase
       row.is_nullable = nil
       assert_equal( false, type.new( row ).not_null? )
     end
-  end
 
-  def test_compile_rule
-    DATATYPES.each do | type |
+    define_method( "test_compile_rule_#{type_name}" ) do
       t = type.new
       tests = [ nil, [], [nil], [nil,nil], {}, {:eq=>nil}, {nil=>nil}]
       tests.each do | test |
@@ -37,18 +31,14 @@ class TestDatatype < Test::Unit::TestCase
         end
       end
     end
-  end
 
-  def test_compile_rule_null
-    DATATYPES.each do | type |
+    define_method( "test_compile_rule_null_#{type_name}" ) do
       t = type.new
       assert_equal( "field_name IS NULL", t.compile_rule( :field_name, :NULL) )
       assert_equal( "field_name IS NOT NULL", t.compile_rule( :field_name, :NOT_NULL) )
     end
-  end
 
-  def test_operator_sign
-    DATATYPES.each do | type |
+    define_method( "test_operator_sign_#{type_name}" ) do
       assert_equal( '<=', type.operator_sign( :le ) )
       assert_equal( '<', type.operator_sign( :lt ) )
       assert_equal( '>=', type.operator_sign( :ge ) )
@@ -57,10 +47,8 @@ class TestDatatype < Test::Unit::TestCase
       assert_equal( '<>', type.operator_sign( :ne ) )
       assert_raise( Momomoto::CriticalError ) { type.operator_sign( :foo ) }
     end
-  end
 
-  def test_escape
-    DATATYPES.each do | type |
+    define_method( "test_escape_#{type_name}" ) do
       t = type.new
       assert_equal( 'NULL', t.escape( nil ))
     end

data/test/test_row.rb

@@ -56,6 +56,12 @@ class TestRow < Test::Unit::TestCase
     assert( b == a )
   end
 
+  def test_columns
+    a = Person.new
+    assert_equal( Person.columns, a.class.columns )
+    assert_equal( Person.columns, Person::Row.columns )
+  end
+
   def test_primary_key_setting
     a = Person.select_single( nil, {:limit=>1})
     assert_raise( Momomoto::Error ) do

data/test/test_table.rb

@@ -132,14 +132,28 @@ class TestTable < Test::Unit::TestCase
   end
 
   def test_select_columns
-    p = Person.select({},{:columns=>[:person_id,:first_name],:limit=>1})[0]
+    p = Person.select({},{:columns=>[:first_name,:nick_name],:limit=>1})[0]
     assert( p.respond_to?( :person_id ))
     assert( p.respond_to?( :first_name ))
+    assert( p.respond_to?( :nick_name ))
+    p.first_name = 'bacon'
+    p.nick_name = 'abc'
+    assert_equal( p.first_name + 'abc', p.nick_name )
     assert_raise( NoMethodError ) do
-      p.nick_name
+      p.last_name
     end
   end
 
+  def test_write_columns
+    p = Person.select({},{:columns=>[:first_name],:limit=>1})[0]
+    p.first_name = 'test_write_columns'
+    p.write
+    p2 = Person.select_single(:person_id=>p.person_id)
+    assert_equal( 'test_write_columns', p2.first_name )
+    p2.first_name = 'chunky'
+    p2.write
+  end
+
   def test_select
     r = Person.select( nil, {:limit => 3})
     assert_equal( 3, r.length )

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: momomoto
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
-date: 2007-10-07 00:00:00 +02:00
+  version: 0.1.8
+date: 2007-10-15 00:00:00 +02:00
 summary: Momomoto is an object relational mapper for PostgreSQL.
 require_paths: 
 - lib