datamapper 0.1.1 → 0.2.0

data/lib/data_mapper/adapters/sqlite3_adapter.rb

@@ -1,66 +1,18 @@
-require 'data_mapper/adapters/sql_adapter'
-require 'data_mapper/support/connection_pool'
-
-require 'sqlite3'
+require 'data_mapper/adapters/data_object_adapter'
+begin
+  require 'do_sqlite3'
+rescue
+  STDERR.puts <<-EOS
+You must install the DataObjects::SQLite3 driver.
+  rake dm:install:sqlite3
+EOS
+  exit
+end
 
 module DataMapper
   module Adapters
     
-    class Sqlite3Adapter < SqlAdapter
-      
-      def initialize(configuration)
-        super
-        @connections = Support::ConnectionPool.new do
-          dbh = SQLite3::Database.new(configuration.database)
-          dbh.results_as_hash = true
-          dbh
-        end
-      end
-      
-      def connection
-        raise ArgumentError.new('Sqlite3Adapter#connection requires a block-parameter') unless block_given?
-        begin
-          @connections.hold { |connection| yield connection }
-        rescue SQLite3::Exception => sle
-          
-          @configuration.log.fatal(sle)
-          
-          @connections.available_connections.each do |sock|
-            begin
-              sock.close
-            rescue => se
-              @configuration.log.error(se)
-            end
-          end
-          
-          @connections.available_connections.clear
-          raise sle
-        end
-      end
-      
-      def query(*args)
-        reader = connection { |db| db.query(escape_sql(*args)) }
-        
-        fields = nil
-        rows = []
-        
-        until reader.eof?
-          hash = reader.next
-          break if hash.nil?
-          
-          fields = hash.keys.select { |field| field.is_a?(String) } unless fields
-          
-          rows << fields.map { |field| hash[field] }
-        end
-        
-        reader.close
-        
-        struct = Support::Struct::define(fields)
-        
-        rows.map do |row|
-          struct.new(row)
-        end
-      end
+    class Sqlite3Adapter < DataObjectAdapter
       
       TYPES.merge!({
         :integer => 'INTEGER'.freeze,
@@ -72,155 +24,34 @@ module DataMapper
       TABLE_QUOTING_CHARACTER = '"'.freeze
       COLUMN_QUOTING_CHARACTER = '"'.freeze
       
-      def type_cast_boolean(value)
-        case value
-          when TrueClass, FalseClass then value
-          when "1", "true", "TRUE" then true
-          when "0", nil then false
-          else "Can't type-cast #{value.inspect} to a boolean"
-        end
-      end
-
-      def type_cast_datetime(value)
-        case value
-          when DateTime then value
-          when Date then DateTime.new(value)
-          when String then DateTime::parse(value)
-          else "Can't type-cast #{value.inspect} to a datetime"
-        end
+      def create_connection
+        conn = DataObject::Sqlite3::Connection.new("dbname=#{@configuration.database}")
+        conn.open
+        return conn
       end
-    
-      module Commands
-        
-        class TableExistsCommand
-          def to_sql
-            "SELECT name FROM sqlite_master WHERE type = \"table\" AND name = #{table_name}"
-          end
           
-          def call
-            reader = @adapter.connection { |db| db.query(to_sql) }
-            result = reader.entries.size > 0
-            reader.close
-            result
+      module Mappings
+        class Table
+          def to_exists_sql
+            @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
+              SELECT "name"
+              FROM "sqlite_master"
+              WHERE "type" = "table"
+                AND "name" = #{@adapter.quote_value(name)}
+            EOS
           end
-        end # class TableExistsCommand
-         
-        class SaveCommand
-          def to_create_table_sql
-            table = @adapter[@instance]
-
-            sql = "CREATE TABLE " << table.to_sql
-
-            sql << " (" << table.columns.map do |column|
-              column_long_form(column)
-            end.join(', ') << ")"
-
-            return sql
-          end
-
-          def column_long_form(column)
-            long_form = "#{column.to_sql} #{@adapter.class::TYPES[column.type] || column.type}"
-
-            long_form << " NOT NULL" unless column.nullable?
-            long_form << " PRIMARY KEY" if column.key?
-            long_form << " default #{column.options[:default]}" if column.options.has_key?(:default)
-
-            return long_form
-          end
-          
-          def execute_insert(sql)
-            @adapter.connection do |db|
-              db.query(sql)
-              db.last_insert_row_id
-            end
-          end
-          
-          def execute_update(sql)
-            @adapter.connection do |db|
-              db.query(sql)
-              db.total_changes > 0
-            end
-          end
-          
-          def execute_create_table(sql)
-            @adapter.connection { |db| db.query(sql) }
-            true
-          end
-        end # class SaveCommand
+        end # class Table
         
-        class DeleteCommand
-          def to_truncate_sql
-            "DELETE FROM " << @adapter[@klass_or_instance].to_sql
-          end
-          
-          def execute(sql)
-            @adapter.connection do |db|
-              db.query(sql)
-              db.total_changes > 0
-            end
+        class Column
+          def serial_declaration
+            "AUTOINCREMENT"
           end
           
-          def execute_drop(sql)
-            @adapter.connection { |db| db.query(sql) }
-            true
+          def size
+            nil
           end
-        end # class DeleteCommand
-         
-        class LoadCommand
-          def eof?(reader)
-            reader.eof?
-          end
-          
-          def close_reader(reader)
-            reader.close
-          end
-          
-          def execute(sql)
-            @adapter.connection { |db| db.query(to_sql) }
-          end
-          
-          def fetch_one(reader)
-            load(reader.next)
-          end
-          
-          def fetch_all(reader)
-            fields = nil
-            rows = []
-            
-            until reader.eof?
-              hash = reader.next
-              break if hash.nil?
-              
-              fields = hash.keys.select { |field| field.is_a?(String) } unless fields
-              
-              rows << fields.map { |name| hash[name] }
-            end
-            
-            load_instances(fields, rows)
-          end
-          
-          def fetch_structs(reader)
-            fields = nil
-            rows = []
-            
-            until reader.eof?
-              hash = reader.next
-              break if hash.nil?
-              
-              fields = hash.keys.select { |field| field.is_a?(String) } unless fields
-              
-              rows << fields.map { |name| hash[name] }
-            end
-            
-            fields = fields.inject({}) do |h,f|
-              h[f] = fields.index(f); h
-            end
-            
-            load_structs(fields, rows)
-          end
-        end
-        
-      end # module Commands
+        end # class Column
+      end # module Mappings
       
     end # class Sqlite3Adapter
     

data/lib/data_mapper/associations.rb

@@ -1,5 +1,5 @@
+require 'data_mapper/associations/reference'
 require 'data_mapper/associations/has_many_association'
-require 'data_mapper/associations/advanced_has_many_association'
 require 'data_mapper/associations/belongs_to_association'
 require 'data_mapper/associations/has_one_association'
 require 'data_mapper/associations/has_and_belongs_to_many_association'
@@ -8,13 +8,27 @@ module DataMapper
   module Associations
   
     def self.included(base)
-      base.class_eval do
-        include DataMapper::Associations::HasMany
-        include DataMapper::Associations::AdvancedHasMany
-        include DataMapper::Associations::BelongsTo
-        include DataMapper::Associations::HasOne
-        include DataMapper::Associations::HasAndBelongsToMany
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      
+      def has_many(association_name, options = {})
+        database.schema[self].associations << HasManyAssociation.new(self, association_name, options)
+      end
+      
+      def belongs_to(association_name, options = {})
+        database.schema[self].associations << BelongsToAssociation.new(self, association_name, options)
+      end
+      
+      def has_and_belongs_to_many(association_name, options = {})
+        database.schema[self].associations << HasAndBelongsToManyAssociation.new(self, association_name, options)
+      end
+      
+      def has_one(association_name, options = {})
+        database.schema[self].associations << HasOneAssociation.new(self, association_name, options)
       end
+      
     end
     
   end

data/lib/data_mapper/associations/belongs_to_association.rb

@@ -1,110 +1,126 @@
+require 'data_mapper/associations/has_n_association'
+
 module DataMapper
   module Associations
     
-    class BelongsToAssociation
-      
-      def initialize(instance, association_name, options)
-        @instance = instance
-        @association_name = association_name
-        @options = options
-        
-        @associated_class = if options.has_key?(:class) || options.has_key?(:class_name)
-          associated_class_name = (options[:class] || options[:class_name])
-          if associated_class_name.kind_of?(String)
-            Kernel.const_get(Inflector.classify(associated_class_name))
-          else
-            associated_class_name
-          end
-        else
-          Kernel.const_get(Inflector.classify(association_name))
-        end
-      end
-      
-      def self.setup(klass, association_name, options)
-        foreign_key = options[:foreign_key] || ("#{association_name}_id")
-        klass.property foreign_key.to_sym, :integer
+    class BelongsToAssociation < HasNAssociation
+
+      def define_accessor(klass)
+        klass.property((@options[:foreign_key] || "#{name}_id").to_sym, :integer)
         
-        # Define the association instance method (i.e. Exhibit#zoo)
         klass.class_eval <<-EOS
-          def create_#{association_name}(options = {})
-            #{association_name}_association.create(options)
+          
+          def create_#{@association_name}(options = {})
+            #{@association_name}_association.create(options)
           end
           
-          def build_#{association_name}(options = {})
-            #{association_name}_association.build(options)
+          def build_#{@association_name}(options = {})
+            #{@association_name}_association.build(options)
           end
           
-          def #{association_name}
-            # Let the BelongsToAssociation do the finding, just to keep things neat around here...
-            #{association_name}_association.find
+          def #{@association_name}
+            #{@association_name}_association.instance
           end
           
-          def #{association_name}=(value)
-            #{association_name}_association.set(value)
+          def #{@association_name}=(value)
+            #{@association_name}_association.set(value)
           end
           
           private
-            def #{association_name}_association
-              @#{association_name} || (@#{association_name} = BelongsToAssociation.new(self, "#{association_name}", #{options.inspect}))
+            def #{@association_name}_association
+              @#{@association_name} || (@#{@association_name} = DataMapper::Associations::BelongsToAssociation::Instance.new(self, #{@association_name.inspect}))
             end
         EOS
-        
       end
       
-      def find
-        return @result unless @result.nil?
-        
-        unless @instance.loaded_set.nil?
-          
-          # Temp variable for the instance variable name.
-          setter_method = "#{@association_name}=".to_sym
-          instance_variable_name = "@#{foreign_key}".to_sym
-          
-          set = @instance.loaded_set.group_by { |instance| instance.instance_variable_get(instance_variable_name) }
-          
-          # Fetch the foreign objects for all instances in the current object's loaded-set.
-          @instance.session.all(@associated_class, :id => set.keys).each do |owner|
-            set[owner.key].each do |instance|
-              instance.send(setter_method, owner)
-            end
-          end
+      def foreign_key
+        @foreign_key || @foreign_key = begin
+          table[@options[:foreign_key] || "#{name}_id".to_sym]
         end
-        
-        return @result
       end
 
-      def create(options = {})
-        associated = @associated_class.new(options)
-        if associated.save
-          @instance.send("#{@associated_class.foreign_key}=", associated.id)
-          @result = associated
+      class Instance < Associations::Reference
+         
+        def instance
+          @associated || @associated = begin                    
+            if @instance.loaded_set.nil?
+              nil
+            else
+              
+              # Temp variable for the instance variable name.
+              fk = association.foreign_key.to_sym
+              
+              set = @instance.loaded_set.group_by { |instance| instance.send(fk) }
+
+              @instance.session.all(association.constant, association.association_table.key.to_sym => set.keys).each do |assoc|
+                set[assoc.key].each do |primary_instance|
+                  primary_instance.send(setter_method, assoc)
+                end
+              end
+
+              @associated
+            end
+          end
         end
-      end
       
-      def build(options = {})
-        @result = @associated_class.new(options)
-      end
+        def create(options)
+          @associated = association.constant.create(options)
+        end
       
-      def set(val)
-        @result = val
-      end
+        def build(options)
+          @associated = association.constant.new(options)
+        end
       
-      def foreign_key
-        @foreign_key ||= (@options[:foreign_key] || @instance.session.schema[@associated_class].default_foreign_key)
-      end
+        def setter_method
+          "#{@association_name}=".to_sym
+        end
+        
+        def set(val)
+          @instance.instance_variable_set(association.foreign_key.instance_variable_name, val.key)
+          @associated = val
+        end
             
-    end
-    
-    module BelongsTo
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
+      end # class Instance
       
-      module ClassMethods
-        def belongs_to(association_name, options = {})
-          BelongsToAssociation.setup(self, association_name, options)
-        end
-      end
+      
+      # def find
+      #   return @result unless @result.nil?
+      #   
+      #   unless @instance.loaded_set.nil?
+      #     
+      #     # Temp variable for the instance variable name.
+      #     setter_method = "#{@association_name}=".to_sym
+      #     instance_variable_name = "@#{foreign_key}".to_sym
+      #     
+      #     set = @instance.loaded_set.group_by { |instance| instance.instance_variable_get(instance_variable_name) }
+      #     
+      #     # Fetch the foreign objects for all instances in the current object's loaded-set.
+      #     @instance.session.all(constant, :id => set.keys).each do |owner|
+      #       set[owner.key].each do |instance|
+      #         instance.send(setter_method, owner)
+      #       end
+      #     end
+      #   end
+      #   
+      #   return @result
+      # end
+
+      # def create(options = {})
+      #   associated = constant.new(options)
+      #   if associated.save
+      #     @instance.send("#{constant.foreign_key}=", associated.id)
+      #     @result = associated
+      #   end
+      # end
+      # 
+      # def build(options = {})
+      #   @result = constant.new(options)
+      # end
+      # 
+      # def set(val)
+      #   @result = val
+      # end
+            
     end
     
   end