datamapper 0.1.0

data/lib/data_mapper/adapters/sqlite3_adapter.rb

@@ -0,0 +1,189 @@
+require 'data_mapper/adapters/abstract_adapter'
+require 'data_mapper/support/connection_pool'
+
+require 'sqlite3'
+
+module DataMapper
+  module Adapters
+    
+    class Sqlite3Adapter < AbstractAdapter
+      
+      def initialize(configuration)
+        super
+        @connections = Support::ConnectionPool.new { Queries::Connection.new(@configuration)  }
+      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
+      
+      TYPES.merge!({
+        :integer => 'INTEGER'.freeze,
+        :string => 'TEXT'.freeze,
+        :text => 'TEXT'.freeze,
+        :class => 'TEXT'.freeze
+      })
+      
+      module Coersion
+
+        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
+        end
+
+      end # module Coersion
+      
+      module Queries
+        
+        class Connection
+      
+          def initialize(database)
+            @database = database
+            @dbh = SQLite3::Database.new(database.database)
+            database.log.debug("Initializing Connection for Database[#{database.name}]")
+            super(database.log)
+          end
+          
+          def execute(statement)
+            send_query(statement)
+            Result.new(@dbh.total_changes, @dbh.last_insert_row_id)
+          end
+      
+          def query(statement)
+            Reader.new(send_query(statement))
+          end
+      
+          def close
+            @dbh.close
+          end
+          
+          private
+          def send_query(statement)
+            sql = statement.respond_to?(:to_sql) ? statement.to_sql : statement
+            log.debug("Database[#{@database.name}] => #{sql}")
+            @dbh.query(sql)
+          end
+          
+        end # class Connection
+        
+        class Reader
+      
+          include Enumerable
+          
+          def initialize(results)
+            @results = results
+            @columns = {}
+            @results.columns.each_with_index do |name, index|
+              @columns[name] = index
+            end
+          end
+          
+          def eof?
+            @results.eof?
+          end
+          
+          def records_affected
+            @results.entries.size
+          end
+          
+          def next
+            @current_row = @results.next
+            self
+          end
+      
+          def each
+            until self.next.eof?
+              yield(self)
+            end
+          end
+      
+          def [](column)
+            index = @columns[column]
+            return nil if index.nil? || @current_row.nil?
+            @current_row[index]
+          end
+          
+          def each_pair            
+            @columns.each_pair do |column_name, index|
+              yield(column_name, @current_row.nil? ? nil : @current_row[index])
+            end
+          end
+          
+          def close
+            @results.close
+          end
+      
+        end # class Reader
+        
+        class TableExistsStatement
+          def to_sql
+            "SELECT name FROM sqlite_master WHERE type = \"table\" AND name = #{@database.quote_value(@database[@klass].name)}"
+          end
+        end # class TableExistsStatement
+         
+        class CreateTableStatement
+          def to_sql
+            table = @database[@klass]
+
+            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} #{@database.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
+        end # class CreateTableStatement
+        
+        class TruncateTableStatement
+          def to_sql
+            "DELETE FROM " << @database[@klass].to_sql
+          end
+        end # class TruncateTableStatement
+        
+      end # module Queries
+        
+    end # class Sqlite3Adapter
+    
+  end # module Adapters
+end # module DataMapper

data/lib/data_mapper/associations.rb

@@ -0,0 +1,19 @@
+require 'data_mapper/associations/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'
+
+module DataMapper
+  module Associations
+  
+    def self.included(base)
+      base.class_eval do
+        include DataMapper::Associations::HasMany
+        include DataMapper::Associations::BelongsTo
+        include DataMapper::Associations::HasOne
+        include DataMapper::Associations::HasAndBelongsToMany
+      end
+    end
+    
+  end
+end

data/lib/data_mapper/associations/belongs_to_association.rb

@@ -0,0 +1,111 @@
+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
+        
+        # Define the association instance method (i.e. Exhibit#zoo)
+        klass.class_eval <<-EOS
+          def create_#{association_name}(options = {})
+            #{association_name}_association.create(options)
+          end
+          
+          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
+          end
+          
+          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}))
+            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.instances.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.find(@associated_class, :all, :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 = @associated_class.new(options)
+        if associated.save
+          @instance.send("#{@associated_class.foreign_key}=", associated.id)
+          @result = associated
+        end
+      end
+      
+      def build(options = {})
+        @result = @associated_class.new(options)
+      end
+      
+      def set(val)
+        @result = val
+      end
+      
+      def foreign_key
+        @foreign_key ||= (@options[:foreign_key] || @instance.session.schema[@associated_class].default_foreign_key)
+      end
+            
+    end
+    
+    module BelongsTo
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def belongs_to(association_name, options = {})
+          BelongsToAssociation.setup(self, association_name, options)
+        end
+      end
+    end
+    
+  end
+end

data/lib/data_mapper/associations/has_and_belongs_to_many_association.rb

@@ -0,0 +1,100 @@
+module DataMapper
+  module Associations
+    
+    class HasAndBelongsToManyAssociation
+      include Enumerable
+      
+      def initialize(instance, association_name, options)
+        @instance = instance
+        @association_name = association_name.to_sym
+        @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
+        
+        @join_table_name = @options.has_key?(:join_table_name) ? @options[:join_table_name] : [Inflector.tableize(@instance.class.name), Inflector.tableize(@associated_class.name)].sort.join('_')
+      end
+      
+      def self.setup(klass, association_name, options)
+        
+        # Define the association instance method (i.e. Project#tasks)
+        klass.class_eval <<-EOS
+          def #{association_name}
+            @#{association_name} || (@#{association_name} = HasAndBelongsToManyAssociation.new(self, "#{association_name}", #{options.inspect}))
+          end
+        EOS
+        
+      end
+      
+      def each
+        find.each { |item| yield item }
+      end
+      
+      def size
+        entries.size
+      end
+      alias length size
+      
+      def [](key)
+        entries[key]
+      end
+      
+      def empty?
+        entries.empty?
+      end
+      
+      def find
+        return @results unless @results.nil?
+        
+        unless @instance.loaded_set.nil?
+          
+          # Temp variable for the instance variable name.
+          instance_variable_name = "@#{foreign_key}".to_sym
+          
+          @results = @instance.session.find(@associated_class, :all,
+            :id.select => { :table => @join_table_name, foreign_key.to_sym => @instance.key }
+          ) do |animal_id, ref|
+            @instance.load_set.find { |x| x.id == animal_id }.exhibits << ref
+          end
+          
+        end
+        
+        return @results || (@results = [])
+      end
+      
+      def set(results)
+        @results = results
+      end
+      
+      def inspect
+        @results.inspect
+      end
+      
+      def foreign_key
+        @foreign_key || (@foreign_key = (@options[:foreign_key] || @instance.session.mappings[@instance.class].default_foreign_key))
+      end
+
+    end
+    
+    module HasAndBelongsToMany
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def has_and_belongs_to_many(association_name, options = {})
+          HasAndBelongsToManyAssociation.setup(self, association_name, options)
+        end
+      end
+    end
+    
+  end
+end

data/lib/data_mapper/associations/has_many_association.rb

@@ -0,0 +1,101 @@
+module DataMapper
+  module Associations
+    
+    class HasManyAssociation
+      include Enumerable
+      
+      def initialize(instance, association_name, options)
+        @instance = instance
+        @association_name = association_name.to_sym
+        @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)
+        
+        # Define the association instance method (i.e. Project#tasks)
+        klass.class_eval <<-EOS
+          def #{association_name}
+            @#{association_name} || (@#{association_name} = HasManyAssociation.new(self, "#{association_name}", #{options.inspect}))
+          end
+        EOS
+        
+      end
+      
+      def each
+        find.each { |item| yield item }
+      end
+      
+      def size
+        entries.size
+      end
+      alias length size
+      
+      def [](key)
+        entries[key]
+      end
+      
+      def empty?
+        entries.empty?
+      end
+      
+      def find
+        return @results unless @results.nil?
+        
+        unless @instance.loaded_set.nil?
+          
+          # Temp variable for the instance variable name.
+          instance_variable_name = "@#{foreign_key}".to_sym
+          
+          set = @instance.loaded_set.instances.group_by { |instance| instance.key }
+          
+          # Fetch the foreign objects for all instances in the current object's loaded-set.
+          @instance.session.find(@associated_class, :all, foreign_key.to_sym => set.keys).group_by do |association|
+            association.instance_variable_get(instance_variable_name)
+          end.each_pair do |id, results|
+            set[id].first.send(@association_name).set(results)
+          end
+          
+        end
+        
+        return @results ||= []
+      end
+      
+      def set(results)
+        @results = results
+      end
+      
+      def inspect
+        @results.inspect
+      end
+      
+      def foreign_key
+        @foreign_key || (@foreign_key = (@options[:foreign_key] || @instance.session.schema[@instance.class].default_foreign_key))
+      end
+
+    end
+    
+    module HasMany
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def has_many(association_name, options = {})
+          HasManyAssociation.setup(self, association_name, options)
+        end
+      end
+    end
+    
+  end
+end