momomoto 0.1.1 → 0.1.2

data/Rakefile

@@ -1,6 +1,5 @@
 
 require 'rake/testtask'
-require 'rcov/rcovtask'
 
 task(:default => :test)
 
@@ -13,17 +12,20 @@ Rake::TestTask.new do | t |
   t.warning = true
 end
 
-Rcov::RcovTask.new do | t |
-  t.libs << 'test_setup.rb'
-  t.rcov_opts << '--xrefs'
-  t.rcov_opts << '--comments'
-  t.rcov_opts << '-x test_setup.rb'
-  t.test_files = FileList['test/test*.rb'].unshift( 'test_setup.rb' )
-end
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do | t |
+    t.libs << 'test_setup.rb'
+#    t.rcov_opts << '--xrefs'
+    t.rcov_opts << '--comments'
+#    t.rcov_opts << '--profile'
+    t.rcov_opts << '-x test_setup.rb'
+    t.rcov_opts << '-x rcov.rb'
+    t.test_files = FileList['test/test*.rb'].unshift( 'test_setup.rb' )
+  end
 
-desc "copy the coverage information to pentabarf.org"
-task :coverage do | t |
-  sh "scp -r coverage pulsar:public_html"
+rescue LoadError
 end
 
 desc "create documentation for ri"

data/lib/momomoto/base.rb

@@ -46,17 +46,16 @@ module Momomoto
 
       # set the schema name of the table this class operates on
       def schema_name=( schema_name )
-        class_variable_set( :@@schema_name, schema_name )
+        @schema_name = schema_name
       end
 
       # get the schema name of the table this class operates on
       def schema_name( schema_name  = nil )
         return self.schema_name=( schema_name ) if schema_name
-        begin
-          class_variable_get( :@@schema_name )
-        rescue NameError
-          construct_schema_name( self.name )
+        if not instance_variable_defined?( :@schema_name )
+          self.schema_name=( construct_schema_name( self.name ) )
         end
+        @schema_name
       end
 
       # get the database connection

data/lib/momomoto/momomoto.rb

@@ -1,7 +1,6 @@
 
 require 'momomoto/base'
 require 'momomoto/table'
-require 'momomoto/join'
 require 'momomoto/procedure'
 require 'momomoto/order'
 require 'momomoto/row'

data/lib/momomoto/procedure.rb

@@ -9,23 +9,10 @@ module Momomoto
 
       def initialize_procedure # :nodoc:
 
-        unless class_variables.member?( '@@procedure_name' )
-          procedure_name( construct_procedure_name( self.name ) )
-        end
-
-        unless class_variables.member?( '@@schema_name' )
-          schema_name( construct_schema_name( self.name ) )
-        end
-
-        unless class_variables.member?( '@@parameters' )
-          parameters( database.fetch_procedure_parameters( procedure_name ) )
-          raise CriticalError if not parameters
-        end
-
-        unless class_variables.member?( '@@columns' )
-          columns( database.fetch_procedure_columns( procedure_name ) )
-          raise CriticalError if not columns
-        end
+        @procedure_name ||= construct_procedure_name( self.name )
+        @schema_name ||= construct_schema_name( self.name )
+        @parameters ||= database.fetch_procedure_parameters( procedure_name )
+        @columns ||= database.fetch_procedure_columns( procedure_name )
 
         const_set( :Row, Class.new( Momomoto::Row ) ) if not const_defined?( :Row )
         initialize_row( const_get( :Row ), self )
@@ -42,17 +29,16 @@ module Momomoto
 
       # set the procedure name
       def procedure_name=( procedure_name )
-        class_variable_set( :@@procedure_name, procedure_name )
+        @procedure_name = procedure_name
       end
 
       # get the procedure name
       def procedure_name( procedure_name = nil )
         return self.procedure_name=( procedure_name ) if procedure_name
-        begin
-          class_variable_get( :@@procedure_name )
-        rescue NameError
-          construct_procedure_name( self.name )
+        if not instance_variable_defined?( :@procedure_name )
+          self.procedure_name = construct_procedure_name( self.name )
         end
+        @procedure_name
       end
 
       # get the full name of the procedure including schema if set
@@ -62,37 +48,28 @@ module Momomoto
 
       # set the parameters this procedures accepts
       # example: parameters = {:param1=>Momomoto::Datatype::Text.new}
-      # example: parameters = {:param1=>Momomoto::Datatype::Text.new}
       def parameters=( *p )
         p = p.flatten
-        class_variable_set( :@@parameters, p )
+        @parameters = p
       end
 
       # get the parameters this procedure accepts
       def parameters( *p )
         return self.send( :parameters=, *p ) if not p.empty?
-        begin
-          class_variable_get( :@@parameters )
-        rescue NameError
-          initialize_procedure
-          class_variable_get( :@@parameters )
-        end
+        initialize_procedure if not instance_variable_defined?( :@parameters )
+        @parameters
       end
 
       # get the columns of the resultset this procedure returns
       def columns=( columns )
-        class_variable_set( :@@columns, columns)
+        @columns = columns
       end
 
       # get the columns of the resultset this procedure returns
       def columns( c = nil )
         return self.columns=( c ) if c
-        begin
-          class_variable_get( :@@columns )
-        rescue NameError
-          initialize_procedure
-          class_variable_get( :@@columns )
-        end
+        initialize_procedure if not instance_variable_defined?( :@columns )
+        @columns
       end
 
       def compile_parameter( params ) # :nodoc:

data/lib/momomoto/table.rb

@@ -9,62 +9,49 @@ module Momomoto
 
       # set the default order for selects
       def default_order=( order )
-        class_variable_set( :@@default_order, order )
+        @default_order = order
       end
 
       # get the columns of the table this class operates on
       def default_order( order = nil )
         return self.default_order=( order ) if order
-        begin
-          class_variable_get( :@@default_order )
-        rescue NameError
-          class_variable_set( :@@default_order, nil )
-        end
+        @default_order
       end
 
       # set the columns of the table this class operates on
       def columns=( columns )
-        class_variable_set( :@@columns, columns)
         # we store the order separate because it's quite important 
         # that it's constant otherwise get_colum and set_column 
         # on the row class might stop working 
-        class_variable_set( :@@column_order, columns.keys )
-      end
-
-      # get the columns of this table
-      def column_order
-        class_variable_get( :@@column_order )
+        @column_order = columns.keys
+        @columns = columns
       end
 
       # get the columns of the table this class operates on
       def columns( columns = nil )
         return self.columns=( columns ) if columns
-        begin
-          class_variable_get( :@@columns )
-        rescue NameError
+        if not instance_variable_defined?( :@columns )
           initialize_table
-          class_variable_get( :@@columns )
         end
+        @columns
       end
 
-      def initialize_table # :nodoc:
+      # get the columns of this table
+      def column_order #:nodoc:
+        @column_order
+      end
 
-        unless class_variables.member?( '@@table_name' )
-          table_name( construct_table_name( self.name ) )
-        end
+      def initialize_table # :nodoc:
 
-        unless class_variables.member?( '@@schema_name' )
-          schema_name( construct_schema_name( self.name ) )
-        end
+        @table_name ||= construct_table_name( self.name )
+        @schema_name ||= construct_schema_name( self.name )
 
-        unless class_variables.member?( '@@columns' )
-          columns( database.fetch_table_columns( table_name(), schema_name() ) )
-        end
+        @columns ||= database.fetch_table_columns( table_name(), schema_name() ) 
         raise CriticalError, "No fields in table #{table_name}" if columns.keys.empty?
 
-        unless class_variables.member?( '@@primary_keys' )
-          primary_keys( database.fetch_primary_keys( table_name(), schema_name() ) )
-        end
+        @primary_keys ||= database.fetch_primary_keys( table_name(), schema_name() )
+        @column_order = @columns.keys
+        @default_order ||= nil
 
         const_set( :Row, Class.new( Momomoto::Row ) ) if not const_defined?( :Row )
         initialize_row( const_get( :Row ), self )
@@ -81,17 +68,13 @@ module Momomoto
 
       # set the table_name of the table this class operates on
       def table_name=( table_name )
-        class_variable_set( :@@table_name, table_name )
+        @table_name = table_name
       end
 
       # get the table_name of the table this class operates on
       def table_name( table_name = nil )
         return self.table_name=( table_name ) if table_name
-        begin
-          class_variable_get( :@@table_name )
-        rescue NameError
-          construct_table_name( self.name )
-        end
+        @table_name
       end
 
       # get the full name of a table including schema if set
@@ -101,17 +84,16 @@ module Momomoto
 
       # set the primary key fields of the table
       def primary_keys=( keys ) # :nodoc:
-        class_variable_set( :@@primary_keys, keys )
+        @primary_keys = keys
       end
 
       # get the primary key fields of the table
       def primary_keys( keys = nil )
         return self.primary_keys=( keys ) if keys
-        begin
-          class_variable_get( :@@primary_keys )
-        rescue
+        if not instance_variable_defined?( :@primary_keys )
           self.primary_keys=( database.fetch_primary_keys( table_name(), schema_name()) )
         end
+        @primary_keys
       end
 
       ## Searches for records and returns an array containing the records

data/test/test_database.rb

@@ -13,6 +13,21 @@ class TestDatabase < Test::Unit::TestCase
     assert_raise( Momomoto::Error ) do db.commit end
   end
 
+  def test_config
+    db = Momomoto::Database.instance
+    db.disconnect
+    old_config = db.send( :instance_variable_get, :@config )
+    Momomoto::Database.config( :port => 65535 )
+    assert_raise( Momomoto::CriticalError ) do
+      Momomoto::Database.connect
+    end
+    Momomoto::Database.config( old_config )
+    assert_nothing_raised do
+      db.connect
+    end
+    db.connect
+  end
+
   def test_connect
     db = Momomoto::Database.instance
     db.disconnect

data/test/test_row.rb

@@ -43,5 +43,20 @@ class TestRow < Test::Unit::TestCase
     assert_equal( a.person_id, a['person_id'])
   end
 
+  def test_primary_key_setting
+    a = Person.select_single( nil, {:limit=>1})
+    assert_raise( Momomoto::Error ) do
+      a.person_id = 42
+    end
+    assert_raise( Momomoto::Error ) do
+      a.set_column( :person_id, 42 )
+    end
+  end
+
+  def test_to_hash
+    a = Person.new
+    assert_instance_of( Hash, a.to_hash )
+  end
+
 end
 

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: momomoto
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 date: 2007-08-13 00:00:00 +02:00
 summary: Momomoto is an object relational mapper for PostgreSQL.
 require_paths: 
@@ -29,7 +29,6 @@ authors:
 - Sven Klemm
 files: 
 - lib/momomoto.rb
-- lib/momomoto/join.rb
 - lib/momomoto/database.rb
 - lib/momomoto/momomoto.rb
 - lib/momomoto/row.rb
@@ -77,7 +76,6 @@ files:
 - test/test_character.rb
 - test/test_integer.rb
 - test/test_inet.rb
-- test/test_join.rb
 - test/test_timestamp_without_time_zone.rb
 - test/test_numeric.rb
 - test/test_time_with_time_zone.rb

data/lib/momomoto/join.rb

@@ -1,66 +0,0 @@
-
-module Momomoto
-
-  # this class implements the join functionality it is an abstract class
-  # it must not be used directly but you should inherit from this class
-  class Join < Base
-
-    attr_reader :base_table, :join_rules
-
-    # constructor of the join class
-    # base_table is the base table of the join
-    # join_rules is an array of Hashes consisting of the table to join as key
-    # and an symbol or an array of symbols on which fields to join the table
-    # Example: Momomoto::Join.new(Event, {Event_Person=>:event_id},{Person=>:person_id})
-    #          results in SELECT * FROM event INNER JOIN event_person USING (event_id) INNER JOIN Person USING(person_id)
-    # if you leave out the eclipit braces to mark the hash you may get
-    # unexpected results because of the undefined order of hashs
-    def initialize( base_table, *join_rules )
-      @base_table = base_table
-      @join_rules = join_rules
-
-      metaclass.instance_eval do
-        define_method( base_table.table_name ) do base_table end
-      end
-      join_rules.each do | rule |
-        rule.keys.each do | table, join_columns |
-          metaclass.instance_eval do
-            define_method( table.table_name ) do table end
-          end
-        end
-      end
-    end
-
-    def metaclass # :nodoc:
-      class << self; self; end
-    end
-
-    def class_variable_set( variable, value ) # :nodoc:
-      self.class.send( :class_variable_set, variable, value )
-    end
-
-    def select( conditions = {}, options = {} )
-      sql = "SELECT " + base_table.columns.keys.map{ | field | "#{base_table.table_name}.\"#{field}\"" }.join( "," )
-      join_rules.each do | rules |
-        rules.each do | table, fields |
-          sql += ','
-          sql += table.columns.keys.map{ | field | "#{table.table_name}.\"#{field}\"" }.join( ',' )
-        end
-      end
-      sql += " FROM "
-      sql += base_table.full_name
-      join_rules.each do | rules |
-        rules.each do | table_name, fields |
-          fields = fields.class === Array ? fields : [fields]
-          sql += " INNER JOIN #{table_name} USING(#{fields.join(', ')})"
-        end
-      end
-      sql += self.class.compile_where( conditions )
-      @data = []
-      self.class.database.execute( sql )
-    end
-
-  end
-
-end
-

data/test/test_join.rb

@@ -1,19 +0,0 @@
-
-class Person < Momomoto::Table; end
-class Event_Person < Momomoto::Table; end
-
-class TestJoin < Test::Unit::TestCase
-
-  def test_initialize
-    a = Momomoto::Join.new( Person, {Event_Person=>:person_id})
-    assert_equal( true, a.respond_to?( :event_person ) )
-    assert_equal( true, a.respond_to?( :person ) )
-  end
-
-  def test_select
-    a = Momomoto::Join.new( Person, {Event_Person=>:person_id})
-    a.select
-  end
-
-end
-