datamapper 0.1.0 → 0.1.1

data/lib/data_mapper/adapters/sql/commands/save_command.rb

@@ -0,0 +1,141 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Commands
+    
+        class SaveCommand
+      
+          def initialize(adapter, session, instance)
+            @adapter, @session, @instance = adapter, session, instance
+          end
+      
+          def to_update_sql
+            table = @adapter[@instance.class]
+        
+            sql = "UPDATE " << table.to_sql << " SET "
+        
+            @instance.dirty_attributes.map do |k, v|
+              sql << table[k].to_sql << " = " << @adapter.quote_value(v) << ", "
+            end
+        
+            sql[0, sql.size - 2] << " WHERE #{table.key.to_sql} = " << @adapter.quote_value(@instance.key)
+          end
+          
+          def to_insert_sql
+        
+            table = @adapter[@instance.class]
+        
+            keys = []
+            values = []
+        
+            @instance.dirty_attributes.each_pair { |k,v| keys << table[k].to_sql; values << v }
+        
+            # Formatting is a bit off here, but it looks nicer in the log this way.
+            sql = "INSERT INTO #{table.to_sql} (#{keys.join(', ')}) \
+    VALUES (#{values.map { |v| @adapter.quote_value(v) }.join(', ')})"
+          end
+          
+          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(', ')
+        
+            sql << ", PRIMARY KEY (#{table.key.to_sql}))"
+        
+            return sql
+          end
+      
+          def column_long_form(column)
+            long_form = "#{column.to_sql} #{@adapter.class::TYPES[column.type] || column.type}"
+        
+            long_form << "(#{column.size})" unless column.size.nil?
+            long_form << " NOT NULL" unless column.nullable?
+            long_form << " auto_increment" if column.key?
+            long_form << " default #{column.options[:default]}" if column.options.has_key?(:default)
+        
+            return long_form
+          end
+          
+          def callback(name)
+            @instance.class.callbacks.execute(name, @instance)
+          end
+          
+          def insert!
+            callback(:before_create)
+            
+            result = execute_insert(to_insert_sql)
+            
+            if result
+              @instance.instance_variable_set(:@new_record, false)
+              @instance.instance_variable_set(:@id, result)
+              calculate_original_hashes(@instance)
+              @session.identity_map.set(@instance)
+              callback(:after_create)
+            end
+
+            return result
+          rescue => error
+            @adapter.log.error(error)
+            raise error
+          end
+
+          def update!
+            callback(:before_update)
+            
+            result = execute_update(to_update_sql)
+            
+            calculate_original_hashes(@instance)
+            callback(:after_update)
+            return result
+          rescue => error
+            @adapter.log.error(error)
+            raise error
+          end
+          
+          def call
+            if @instance.kind_of?(Class)
+              return false if @adapter.table_exists?(@instance)
+              execute_create_table(to_create_table_sql)
+            else
+              return false unless @instance.dirty?
+              callback(:before_save)
+              result = @instance.new_record? ? insert! : update!
+              @instance.session = @session
+              callback(:after_save)
+              result
+            end
+          end
+          
+          protected
+          def execute_insert(sql)
+            raise NotImplementedError.new
+          end
+          
+          def execute_update(sql)
+            raise NotImplementedError.new
+          end
+          
+          def execute_create_table(sql)
+            raise NotImplementedError.new
+          end
+          
+          private
+          # Calculates the original hashes for each value
+          # in an instance's set of attributes, and adds
+          # them to the original_hashes hash.
+          def calculate_original_hashes(instance)
+            instance.attributes.each_pair do |name, value|
+              instance.original_hashes[name] = value.hash
+            end
+          end
+      
+        end
+    
+      end
+    end
+  end
+end

data/lib/data_mapper/adapters/sql/commands/table_exists_command.rb

@@ -0,0 +1,33 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Commands
+    
+        class TableExistsCommand
+      
+          def initialize(adapter, klass_or_name)
+            @adapter, @klass_or_name = adapter, klass_or_name
+          end
+      
+          def table_name
+            @table_name || @table_name = case @klass_or_name
+            when String then @adapter.quote_value(@klass_or_name)
+            when Class then @adapter.quote_value(@adapter[@klass_or_name].name)
+            else raise ArgumentError.new('klass_or_name must be a mapped-class or a table name')
+            end
+          end
+          
+          def to_sql
+            "SHOW TABLES LIKE #{table_name}"
+          end
+          
+          def call
+            raise NotImplementedError.new
+          end
+      
+        end
+    
+      end
+    end
+  end
+end

data/lib/data_mapper/adapters/sql/mappings/column.rb

@@ -0,0 +1,91 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Mappings
+    
+        # TODO: There are of course many more options to add here.
+        # Ordinal, Length/Size, Nullability are just a few.
+        class Column
+    
+          attr_accessor :name, :type, :options
+    
+          def initialize(adapter, table, name, type, options = {})
+            @adapter = adapter
+            @table = table
+            @name, @type, @options = name.to_sym, type, options
+            
+            (class << self; self end).class_eval <<-EOS
+              def type_cast_value(value)
+                @adapter.type_cast_#{type}(value)
+              end
+            EOS
+          end
+    
+          def lazy=(value)
+            @options[:lazy] = value
+          end
+    
+          # Determines if the field should be lazy loaded.
+          # You can set this explicitly, or accept the default,
+          # which is false for all but text fields.
+          def lazy?
+            @options[:lazy] || (type == :text)
+          end
+      
+          def nullable?
+            @options[:nullable] || true
+          end
+      
+          def key?
+            @options[:key] || false
+          end
+    
+          def to_sym
+            @name
+          end
+      
+          def instance_variable_name
+            @instance_variable_name || (@instance_variable_name = "@#{@name.to_s.gsub(/\?$/, '')}".freeze)
+          end
+      
+          def to_s
+            @name.to_s
+          end
+      
+          def column_name
+            @column_name || (@column_name = (@options.has_key?(:column) ? @options[:column].to_s : name.to_s.gsub(/\?$/, '')).freeze)
+          end
+      
+          def to_sql(include_table_name = false)
+            if include_table_name
+              @to_sql_with_table_name || @to_sql_with_table_name = begin
+                (@table.to_sql + '.' + @adapter.quote_column_name(column_name)).freeze
+              end
+            else
+              @to_sql || (@to_sql = @adapter.quote_column_name(column_name).freeze)
+            end
+          end
+      
+          def size
+            @size || begin
+              return @size = @options[:size] if @options.has_key?(:size)
+              return @size = @options[:length] if @options.has_key?(:length)
+          
+              @size = case type
+                when :integer then 4
+                when :string, :class then 50
+                else nil
+              end
+            end
+          end
+      
+          def inspect
+            "#<%s:0x%x @name=%s, @type=%s, @options=%s>" % [self.class.name, (object_id * 2), to_sql, type.inspect, options.inspect]
+          end
+      
+        end
+    
+      end
+    end
+  end
+end

data/lib/data_mapper/adapters/sql/mappings/schema.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/table'
+    
+module DataMapper
+  module Adapters
+    module Sql
+      module Mappings
+    
+        class Schema
+    
+          def initialize(adapter)
+            @adapter = adapter
+            @tables = Hash.new { |h,k| h[k] = Table.new(@adapter, k) }
+          end
+
+          def [](klass)
+            @tables[klass]
+          end
+      
+          def each
+            @tables.values.each do |table|
+              yield table
+            end
+          end
+    
+        end
+    
+      end
+    end
+  end
+end

data/lib/data_mapper/adapters/sql/mappings/table.rb

@@ -0,0 +1,143 @@
+require File.dirname(__FILE__) + '/column'
+
+module DataMapper
+  module Adapters
+    module Sql
+      module Mappings
+    
+        class Table
+      
+          class Association
+            def initialize(association_name, constant_name)
+              @association_name, @constant_name = association_name, constant_name
+            end
+            
+            def name
+              @association_name
+            end
+            
+            def constant
+              @constant || @constant = begin
+                Object.const_get(@constant_name)
+              end
+            end
+            
+          end
+            
+          attr_reader :klass
+      
+          def initialize(adapter, setup_klass)
+            raise "\"setup_klass\" must not be nil!" if setup_klass.nil?
+            @adapter = adapter
+            @klass = setup_klass
+            @columns = []
+            @columns_hash = Hash.new { |h,k| h[k] = @columns.find { |c| c.name == k } }
+            @columns_by_column_name = Hash.new { |h,k| h[k.to_s] = @columns.find { |c| c.column_name == k.to_s } }
+            @has_many = []
+            @associations = []
+          end
+          
+          def associations
+            @associations
+          end
+      
+          # def has_many(association_name, options)
+          #   @associtaions << Association.new(association_name, Inflector.classify(Inflector.singularize(association_name.to_s)))
+          # end
+          
+          # def has_many_associations
+          #   @has_many
+          # end
+          
+          def columns
+            key if @key.nil?
+            @columns
+          end
+          
+          def exists?
+            @adapter.table_exists?(name)
+          end
+          
+          def drop!
+            @adapter.delete(@klass, :drop => true) if exists?
+          end
+          
+          def create!
+            @adapter.save(database, @klass) unless exists?
+          end
+      
+          def key
+            if @key.nil?
+              key_column = @columns.find { |c| c.key? }
+              @key = if key_column.nil?
+                column = add_column(:id, :integer, :key => true)
+                @klass.send(:attr_reader, :id) unless @klass.methods.include?(:id)
+                column
+              else
+                key_column
+              end
+            end
+          
+            @key
+          end
+      
+          def add_column(column_name, type, options)
+            column = @columns.find { |c| c.name == column_name.to_sym }
+        
+            if column.nil?
+              reset_derived_columns!
+              column = Column.new(@adapter, self, column_name, type, options)
+              @columns.send(column_name == :id ? :unshift : :push, column)
+            end
+        
+            return column
+          end
+      
+          def [](column_name)
+            return key if column_name == :id
+            @columns_hash[column_name.kind_of?(Symbol) ? column_name : column_name.to_sym]
+          end
+      
+          def find_by_column_name(column_name)
+            @columns_by_column_name[column_name.kind_of?(String) ? column_name : column_name.to_s]
+          end
+      
+          def name
+            @name || begin
+              @name = if @klass.superclass != DataMapper::Base && @klass.superclass != Object
+                @adapter[@klass.superclass].name
+              else
+                Inflector.tableize(@klass.name)
+              end.freeze
+            end
+          end
+      
+          def name=(value)
+            @name = value
+          end
+      
+          def default_foreign_key
+            @default_foreign_key || (@default_foreign_key = "#{String::memoized_underscore(Inflector.singularize(name))}_id".freeze)
+          end
+      
+          def to_sql
+            @to_sql || (@to_sql = @adapter.quote_table_name(name).freeze)
+          end
+      
+          def inspect
+            "#<%s:0x%x @klass=%s, @name=%s, @columns=%s>" % [self.class.name, (object_id * 2), @klass.name, to_sql, @columns.inspect]
+          end
+      
+          private
+          def reset_derived_columns!
+            @columns_hash.clear
+            @columns_by_column_name.clear
+            @key = nil
+          end
+      
+        end
+    
+      end
+    end
+  end
+end

data/lib/data_mapper/adapters/sql/quoting.rb

@@ -0,0 +1,38 @@
+module DataMapper
+  module Adapters
+    module Sql
+      
+      # Quoting is a mixin that extends your DataMapper::Database singleton-class
+      # to allow for object-name and value quoting to be exposed to the queries.
+      #
+      # DESIGN: Is there any need for this outside of the query objects? Should
+      # we just include it in our query object subclasses and not rely on a Quoting
+      # mixin being part of the "standard" Adapter interface?
+      module Quoting
+
+        def quote_table_name(name)
+          name.ensure_wrapped_with(self.class::TABLE_QUOTING_CHARACTER)
+        end
+
+        def quote_column_name(name)
+          name.ensure_wrapped_with(self.class::COLUMN_QUOTING_CHARACTER)
+        end
+
+        def quote_value(value)
+          return 'NULL' if value.nil?
+
+          case value
+            when Numeric then value.to_s
+            when String then "'#{value.gsub("'", "''")}'"
+            when Class then "'#{value.name}'"
+            when Date then "'#{value.to_s}'"
+            when Time, DateTime then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+            when TrueClass, FalseClass then value.to_s.upcase
+            else raise "Don't know how to quote #{value.inspect}"
+          end
+        end
+
+      end # module Quoting
+    end
+  end
+end