datamapper 0.1.0

data/lib/data_mapper/extensions/active_record_impersonation.rb

@@ -0,0 +1,69 @@
+module DataMapper
+  module Extensions
+    
+    module ActiveRecordImpersonation
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      def save
+        session.save(self)
+      end
+      
+      def reload!
+        session.find(self.class, id, :select => session.mappings[self.class].columns.map(&:name), :reload => true)
+      end
+      
+      def reload
+        reload!
+      end
+      
+      def destroy!
+        session.destroy(self)
+      end
+      
+      module ClassMethods
+        
+        def all(options = {}, &b)
+          find(:all, options, &b)
+        end
+        
+        def first(options = {}, &b)
+          find(:first, options, &b)
+        end
+        
+        def delete_all
+          database.delete_all(self)
+        end
+        
+        def truncate!
+          database.truncate(self)
+        end
+        
+        def find(*args, &b)
+          DataMapper::database.find(self, *args, &b)
+        end
+        
+        def find_by_sql(*args)
+          DataMapper::database.query(*args)
+        end
+        
+        def [](id_or_hash)
+          if id_or_hash.kind_of?(Hash)
+            find(:first, id_or_hash)
+          else
+            find(id_or_hash)
+          end
+        end
+        
+        def create(attributes)
+          instance = self.new(attributes)
+          instance.save
+          instance
+        end
+      end
+    end
+    
+  end
+end

data/lib/data_mapper/extensions/callback_helpers.rb

@@ -0,0 +1,35 @@
+require 'data_mapper/callbacks'
+
+module DataMapper
+  module Extensions
+    
+    module CallbackHelpers
+    
+      def self.included(base)
+        base.extend(ClassMethods)
+        
+        # declare helpers for the standard callbacks
+        Callbacks::EVENTS.each do |name|
+          base.class_eval <<-EOS
+            def self.#{name}(string = nil, &block)
+              if string.nil?
+                callbacks.add(:#{name}, &block)
+              else
+                callbacks.add(:#{name}, string)
+              end
+            end
+          EOS
+        end
+      end
+      
+      module ClassMethods
+        
+        def callbacks
+          @callbacks ||= Callbacks.new
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/data_mapper/identity_map.rb

@@ -0,0 +1,21 @@
+require 'data_mapper/support/weak_hash'
+
+module DataMapper
+  class IdentityMap
+    
+    def initialize
+      @cache = Hash.new { |h,k| h[k] = Support::WeakHash.new }
+    end
+
+    def get(klass, key)
+      @cache[klass][key]
+    end
+
+    def set(instance)
+      raise "Can't store an instance with a nil key in the IdentityMap" if instance.key == nil
+        
+      @cache[instance.class][instance.key] = instance
+    end
+    
+  end
+end

data/lib/data_mapper/loaded_set.rb

@@ -0,0 +1,45 @@
+require 'data_mapper/support/enumerable'
+
+module DataMapper
+
+  # LoadedSet's purpose is to give a common reference for the results of a query,
+  # so that they can be manipulated by the DataMapper, behind-the-scenes, as a set.
+  class LoadedSet
+    
+    # Provides a reference to the database that originally loaded the instances.
+    attr_reader :database
+    # Provides an Enumerable of the instances loaded in the set.
+    attr_reader :instances
+    
+    def initialize(database)
+      @database = database
+      @instances = [] # ObjectIdCollection.new
+    end
+    
+    # Not sure if this is necessary yet...
+    # In other words: Does it make sense to allow portions of a set to be
+    # garbage-collected?
+    #
+    # If so, then this isn't good enough because it's likely to
+    # throw errors. If it's not, then letting Ruby itself track the
+    # references with a simple Array is probably more effecient.
+    class ObjectIdCollection
+      
+      include Enumerable
+      include Support::Enumerable
+      
+      def initialize
+        @object_ids = []
+      end
+      
+      def each
+        @object_ids.map { |id| yield ObjectSpace::_id2ref(id) }
+      end
+      
+      def <<(object)
+        @object_ids << object.object_id
+      end
+    end
+  end
+
+end

data/lib/data_mapper/mappings/column.rb

@@ -0,0 +1,78 @@
+module DataMapper
+  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(database, name, type, options = {})
+        @database = database
+        @name, @type, @options = name.to_sym, type, options
+      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 type_cast_value(value)
+        @database.type_cast_value(type, value)
+      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
+        @to_sql || (@to_sql = @database.quote_column_name(column_name).freeze)
+      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

data/lib/data_mapper/mappings/schema.rb

@@ -0,0 +1,28 @@
+require 'data_mapper/mappings/table'
+    
+module DataMapper
+  module Mappings
+    
+    class Schema
+    
+      def initialize(database)
+        @database = database
+        @tables = Hash.new { |h,k| h[k] = Table.new(@database, k) }
+      end
+    
+      def [](klass)
+        @tables[klass]
+      rescue
+        raise "#{klass.inspect} can't be mapped to a table"
+      end
+      
+      def each
+        @tables.values.each do |table|
+          yield table
+        end
+      end
+    
+    end
+    
+  end
+end

data/lib/data_mapper/mappings/table.rb

@@ -0,0 +1,99 @@
+require 'data_mapper/mappings/column'
+
+module DataMapper
+  module Mappings
+    
+    class Table
+      
+      attr_reader :klass
+      
+      def initialize(database, klass)
+        unless database.kind_of?(DataMapper::Database) && klass.kind_of?(Class)
+          raise "Database and klass are required: #{ { :database => database, :klass => klass }.inspect }"
+        end
+        
+        @database = database
+        @klass = 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 } }
+      end
+      
+      def columns
+        key if @key.nil?
+        @columns
+      end
+      
+      def key
+        if @key.nil?
+          key_column = @columns.find { |c| c.key? }
+          @key = if key_column.nil?
+            add_column(:id, :integer, :key => true)
+            @klass.send(:attr_reader, :id) unless @klass.methods.include?(:id)
+            @columns.last
+          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(@database, column_name, type, options)
+          @columns << 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
+            @database[@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 = "#{Inflector.underscore(Inflector.singularize(name))}_id".freeze)
+      end
+      
+      def to_sql
+        @to_sql || (@to_sql = @database.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

data/lib/data_mapper/queries/conditions.rb

@@ -0,0 +1,141 @@
+module DataMapper
+  module Queries
+    
+    class Conditions
+      
+      def initialize(database, options)
+        @database, @options = database, options
+        @has_id = false
+      end
+      
+      class NormalizationError < StandardError
+        
+        attr_reader :inner_error
+        
+        def initialize(clause, inner_error = nil)
+          @clause = clause
+          @inner_error = inner_error
+          
+          message = "Failed to normalize clause: #{clause.inspect}"
+          message << ", Error: #{inner_error.inspect}" unless inner_error.nil?
+          
+          super(message)
+        end
+        
+      end
+      
+      def normalize(clause, collector)
+        case clause
+          when Hash then
+            clause.each_pair do |k,v|
+              if k.kind_of?(Symbol::Operator)
+                if k.type == :select
+                  k.options[:class] ||= @options[:class]
+                  
+                  k.options[:select] ||= if k.value.to_s == @database[k.options[:class]].default_foreign_key
+                    @database[k.options[:class]].key.column_name
+                  else
+                    k.value
+                  end
+                  
+                  sub_select = @database.select_statement(k.options.merge(v))
+                  normalize(["#{@database[@options[:class]][k.value.to_sym].to_sql} IN ?", sub_select], collector)
+                else                
+                  @has_id = true if k.value == :id
+                  op = case k.type
+                    when :gt then '>'
+                    when :gte then '>='
+                    when :lt then '<'
+                    when :lte then '<='
+                    when :not then v.nil? ? 'IS NOT' : (v.kind_of?(Array) ? 'NOT IN' : '<>')
+                    when :eql then v.nil? ? 'IS' : (v.kind_of?(Array) ? 'IN' : '=')
+                    when :like then 'LIKE'
+                    when :in then 'IN'
+                    else raise ArgumentError.new('Operator type not supported')
+                  end
+                  normalize(["#{@database[@options[:class]][k.value.to_sym].to_sql} #{op} ?", v], collector)
+                end
+              else
+                @has_id = true if k == :id
+                case v
+                when Array then
+                  normalize(["#{@database[@options[:class]][k.to_sym].to_sql} IN ?", v], collector)
+                when SelectStatement then
+                  normalize(["#{@database[@options[:class]][k.to_sym].to_sql} IN ?", v], collector)
+                else
+                  normalize(["#{@database[@options[:class]][k.to_sym].to_sql} = ?", v], collector)
+                end
+              end
+            end
+          when Array then
+            return collector if clause.empty?
+            @has_id = true if clause.first =~ /(^|\s|\`)id(\`|\s|\=|\<)/ && !clause[1].kind_of?(SelectStatement)
+            collector << escape(clause)
+          when String then
+            @has_id = true if clause =~ /(^|\s|\`)id(\`|\s|\=|\<)/
+            collector << clause
+          else raise NormalizationError.new(clause)              
+        end
+        
+        return collector
+      end
+      
+      def escape(conditions)
+        clause = conditions.shift
+
+        clause.gsub(/\?/) do |x|
+          # Check if the condition is an in, clause.
+          case conditions.first
+          when Array then
+            '(' << conditions.shift.map { |c| @database.quote_value(c) }.join(', ') << ')'
+          when SelectStatement then
+            '(' << conditions.shift.to_sql << ')'
+          else
+            @database.quote_value(conditions.shift)
+          end
+        end
+      end
+      
+      def has_id?
+        normalized_conditions
+        @has_id
+      end
+      
+      def normalized_conditions
+        
+        if @normalized_conditions.nil?
+          @normalized_conditions = []
+          
+          table = @database[@options[:class]]
+          invalid_keys = nil
+          
+          implicits = @options.reject do |k,v|            
+            standard_key = DataMapper::Session::FIND_OPTIONS.include?(k)
+            (invalid_keys ||= []) << k if !standard_key && table[k.to_sym].nil?
+            standard_key
+          end
+          
+          raise "Invalid options: #{invalid_keys.inspect}" unless invalid_keys.nil?
+          
+          normalize(implicits, @normalized_conditions)
+          
+          if @options.has_key?(:conditions)
+            normalize(@options[:conditions], @normalized_conditions)
+          end
+          
+        end
+        
+        return @normalized_conditions          
+      end
+      
+      def empty?
+        normalized_conditions.empty?
+      end
+      
+      def to_a
+        normalized_conditions
+      end
+    end
+    
+  end
+end