datamapper 0.3.2 → 0.9.3

data/lib/data_mapper/associations/has_n_association.rb

@@ -1,143 +0,0 @@
-module DataMapper                        
-  
-  class ForeignKeyNotFoundError < StandardError; end
-  class AssociationProtectedError < StandardError; end
-    
-  module Associations
-    
-    class HasNAssociation
-      
-      attr_reader :options
-      
-      OPTIONS = [
-        :class,
-        :class_name,
-        :foreign_key,
-        :dependent
-      ]
-      
-      def initialize(klass, association_name, options)
-        @constant = klass
-        @adapter = database.adapter
-        @table = @adapter.table(klass)
-        @association_name = association_name.to_sym
-        @options = options || Hash.new
-        
-        define_accessor(klass)
-        
-        Persistence::dependencies.add(associated_constant_name) do |klass|
-          @foreign_key_column = associated_table[foreign_key_name]
-          
-          unless @foreign_key_column
-            associated_constant.property(foreign_key_name, foreign_key_type)
-          
-            @foreign_key_column = associated_table[foreign_key_name]
-          
-            if @foreign_key_column.nil?
-              raise ForeignKeyNotFoundError.new(<<-EOS.compress_lines)
-                key_table => #{key_table.inspect},
-                association_table => #{associated_table.inspect},
-                association_name => #{name},
-                foreign_key_name => #{foreign_key_name.inspect},
-                foreign_key_type => #{foreign_key_type.inspect},
-                constant => #{constant.inspect},
-                associated_constant => #{associated_constant.inspect}
-              EOS
-            end
-          end
-        end
-      end
-      
-      def name
-        @association_name
-      end
-
-      def constant
-        @constant
-      end
-      
-      def associated_constant
-        @associated_constant || @associated_constant = Kernel.const_get(associated_constant_name)
-      end
-      
-      def associated_constant_name
-        @associated_constant_name || begin
-          
-          if @options.has_key?(:class) || @options.has_key?(:class_name)
-            @associated_constant_name = (@options[:class] || @options[:class_name])
-            
-            if @associated_constant_name.kind_of?(String)
-              @associated_constant_name = Inflector.classify(@associated_constant_name)
-            elsif @associated_constant_name.kind_of?(Class)
-              @associated_constant_name = @associated_constant_name.name
-            end  
-          else
-            @associated_constant_name = Inflector.classify(@association_name)
-          end
-          
-          @associated_constant_name
-        end
-        
-      end
-      
-      def primary_key_column
-        @primary_key_column || @primary_key_column = key_table.key
-      end
-      
-      def foreign_key_column
-        @foreign_key_column
-      end
-      
-      def foreign_key_name
-        @foreign_key_name || @foreign_key_name = (@options[:foreign_key] || key_table.default_foreign_key)
-      end
-      
-      def foreign_key_type
-        @foreign_key_type || @foreign_key_type = key_table.key.type
-      end
-      
-      def key_table
-        @key_table || @key_table = @adapter.table(constant)
-      end
-      
-      def associated_table
-        @association_table || @association_table = @adapter.table(associated_constant)
-      end
-      
-      def associated_columns
-        associated_table.columns.reject { |column| column.lazy? }
-      end
-      
-      def complementary_association
-        @complementary_association || begin
-          @complementary_association = associated_table.associations.find do |mapping|
-            mapping.is_a?(BelongsToAssociation) && 
-            mapping.foreign_key_column == foreign_key_column &&
-            mapping.key_table.name == key_table.name
-          end
-          
-          if @complementary_association
-            class << self
-              attr_accessor :complementary_association
-            end
-          end
-          
-          return @complementary_association
-        end
-      end
-      
-      def finder_options
-        @finder_options || @finder_options = @options.reject { |k,v| self.class::OPTIONS.include?(k) }
-      end
-      
-      def to_sql
-        "JOIN #{associated_table.to_sql} ON #{foreign_key_column.to_sql(true)} = #{primary_key_column.to_sql(true)}"
-      end
-      
-      def activate!(force = false)
-        foreign_key_column
-      end
-    end
-    
-  end
-end

data/lib/data_mapper/associations/reference.rb

@@ -1,47 +0,0 @@
-module DataMapper
-  
-  module Associations
-    
-    # Reference is an abstract-class providing the boiler-plate for
-    # the association proxies (ie: HasManyAssociation::Set, or
-    # HasOneAssociation::Instance)
-    # The proxies need to access the defining Association instances
-    # to obtain mapping information. This class provides convenient
-    # access to said Association.
-    #
-    # EXAMPLE:
-    #   class Zoo
-    #     has_many :exhibits
-    #   end
-    # The +has_many+ declaration instantiates a
-    # DataMapper::Associations::HasManyAssociation and adds it to the
-    # DataMapper::Adapters::Sql::Mappings::Table#associations array for
-    # the Table representing Zoo.
-    #
-    #   Zoo.new.exhibits
-    # +exhibits+ above returns an instance of
-    # DataMapper::Associations::HasManyAssociation::Set. This instance
-    # needs to access the actual HasManyAssociation instance in order
-    # to access the mapping information within. The DataMapper::Associations::Reference
-    # abstract-class for the Set provides the Reference#association method in order to
-    # provide easy access to this information.
-    class Reference
-  
-      # +instance+ is a mapped object instance. ie: #<Zoo:0x123456 ...>
-      # +association_name+ is the Symbol used to look up the Association
-      # instance within the DataMapper::Adapters::Sql::Mappings::Table 
-      def initialize(instance, association_name)
-        @instance, @association_name = instance, association_name.to_sym
-        @instance.loaded_associations << self
-      end
-  
-      # #association provides lazily initialized access to the declared
-      # Association.
-      def association
-        @association || (@association = @instance.database_context.table(@instance.class).associations[@association_name])
-      end
-  
-    end
-  end
-
-end

data/lib/data_mapper/attributes.rb

@@ -1,73 +0,0 @@
-module DataMapper
-  
-  module Attributes
-    
-    def self.included(klass)
-      klass.const_set('ATTRIBUTES', Set.new) unless klass.const_defined?('ATTRIBUTES')
-    end
-    
-    def attributes
-      __get_attributes(true)
-    end
-    
-    # Mass-assign mapped fields.
-    def attributes=(values_hash)
-      __set_attributes(values_hash, true)
-    end
-    
-    private
-    
-    def __method_defined?(name, public_only = true)
-      if public_only
-        self.class.public_method_defined?(name)
-      else
-        self.class.private_method_defined?(name) || 
-          self.class.protected_method_defined?(name) ||
-          self.class.public_method_defined?(name)
-      end
-    end
-    
-    def __get_attributes(public_only)
-      pairs = {}
-      
-      self.class::ATTRIBUTES.each do |name|
-        getter = if __method_defined?(name, public_only)
-          name
-        elsif __method_defined?(name.to_s.ensure_ends_with('?'), public_only)
-          name.to_s.ensure_ends_with('?')
-        else
-          nil         
-        end
-        
-        if getter
-          value = send(getter)
-          pairs[name] = value.is_a?(Class) ? value.to_s : value
-        end
-      end
-      
-      pairs
-    end
-    
-    def __set_attributes(values_hash, public_only)
-      values_hash.each_pair do |k,v|
-        setter_name = k.to_s.sub(/\?$/, '').ensure_ends_with('=')
-        if __method_defined?(setter_name, public_only)
-          send(setter_name, v)
-        end
-      end
-      
-      self
-    end
-        
-    # return all attributes, regardless of their visibility
-    def private_attributes
-      __get_attributes(false)
-    end
-
-    # private method for setting any/all attribute values, regardless of visibility
-    def private_attributes=(values_hash)
-      __set_attributes(values_hash, false)
-    end
-  end
-  
-end

data/lib/data_mapper/auto_migrations.rb

@@ -1,36 +0,0 @@
-module DataMapper
-  module AutoMigrations
-    def auto_migrate!
-      if self::subclasses.empty?
-        table = database.table(self)
-        table.activate_associations!
-        
-        table.create!(true)
-      else
-        schema = database.schema
-        columns = self::subclasses.inject(schema[self].columns) do |span, subclass|
-          span + schema[subclass].columns
-        end
-
-        table_name = schema[self].name.to_s
-        table = schema[table_name]
-        columns.each do |column|
-          table.add_column(column.name, column.type, column.options)
-        end
-        
-        table.activate_associations!
-        
-        return table.create!(true)
-      end
-    end
-    
-    private
-    def create_table(table)
-      raise NotImplementedError.new
-    end
-    
-    def modify_table(table, columns)
-      raise NotImplementedError.new
-    end
-  end
-end

data/lib/data_mapper/base.rb

@@ -1,17 +0,0 @@
-require 'data_mapper/persistence'
-require 'data_mapper/is/tree'
-
-module DataMapper
-
-  class Base
-		include DataMapper::Is::Tree
-    
-    def self.inherited(klass)
-      klass.send(:include, DataMapper::Persistence)
-    end
-
-    def self.auto_migrate!
-      DataMapper::Persistence.auto_migrate!
-    end
-  end
-end

data/lib/data_mapper/callbacks.rb

@@ -1,107 +0,0 @@
-module DataMapper
-  
-  # CallbacksHelper adds a class-method ClassMethods#callbacks
-  # when included in a class, and defines short-cut class-methods to
-  # add delegates to callbacks for the built-in Callbacks::EVENTS.
-  module CallbacksHelper
-    
-    # The ::included callback extends the included class with a
-    # ::callbacks method, and sets up helper methods for the standard
-    # events declared in Callbacks::EVENTS.
-    def self.included(base)
-      base.extend(ClassMethods)
-      
-      # Declare helpers for the standard EVENTS
-      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
-    
-    # Defines class-methods for the class that CallbacksHelper is
-    # included in.
-    module ClassMethods
-      
-      # Provides lazily initialized access to a Callbacks instance.
-      def callbacks
-        @callbacks || ( @callbacks = DataMapper::Callbacks.new )
-      end
-    end
-  end
-  
-  # Callbacks is a collection to assign and execute blocks of code when
-  # hooks throughout the DataMapper call Callbacks#execute. A set of the
-  # standard callbacks is declared in the Callbacks::EVENTS array.
-  class Callbacks
-  
-    # These are a collection of default callbacks that are hooked
-    # into the DataMapper. You're free to add your own events just by
-    # calling #add, but you'll have add the appropriate hooks into the
-    # system to actually execute them yourself.
-    EVENTS = [
-      :before_materialize, :after_materialize,
-      :before_save, :after_save,
-      :before_create, :after_create,
-      :before_update, :after_update,
-      :before_destroy, :after_destroy,
-      :before_validation, :after_validation
-      ]
-    
-    # Initializes an internal Hash that ensures callback names are always
-    # of type Symbol, and assigns an Array to store your delegating code
-    # when the callback is looked-up by name.
-    def initialize
-      @callbacks = Hash.new do |h,k|
-        raise 'Callback names must be Symbols' unless k.kind_of?(Symbol)
-        h[k] = Set.new
-      end
-    end
-    
-    # Executes a given callback and returns TRUE or FALSE depending on the
-    # return value of the callbacks. All callbacks must return successfully
-    # in order for the call to #execute to return TRUE. Callbacks always
-    # execute against an +instance+. You may pass  additional arguments
-    # which will in turn be passed to any Proc objects assigned to a specific
-    # callback. Strings assigned to callbacks do not accept parameters.
-    # They are instance-eval'ed instead. When the callback is a Symbol,
-    # it is sent to the instance under the assumption it is a method call.
-    def execute(name, instance, *args)
-      @callbacks[name].all? do |callback|
-        case callback
-        when String then instance.instance_eval(callback)
-        when Proc then callback[instance, *args]
-        when Symbol then instance.send(callback, *args)
-        else raise ''
-        end
-      end
-    end
-    
-    # Asign delegating code to a callback. The +block+ parameter
-    # can be a Proc object, a String which will be eval'ed when
-    # the callback is executed, or a Symbol, which will be sent to
-    # the instance executed against (as a method call).
-    def add(name, block)
-      callback = @callbacks[name]
-      raise ArgumentError.new("You didn't specify a callback in String, Symbol or Proc form.") unless [String, Proc, Symbol].detect { |type| block.is_a?(type) }
-      callback << block
-    end
-
-    def dup
-      copy = self.class.new
-      @callbacks.each_pair do |name, callbacks|
-        callbacks.each do |callback|
-          copy.add(name, callback)
-        end
-      end
-      return copy
-    end
-  end
-  
-end

data/lib/data_mapper/context.rb

@@ -1,112 +0,0 @@
-require 'data_mapper/identity_map'
-
-module DataMapper
-  
-  class Context
-      
-    class MaterializationError < StandardError
-    end
-    
-    attr_reader :adapter
-    
-    def initialize(adapter)
-      @adapter = adapter
-    end
-    
-    def identity_map
-      @identity_map || ( @identity_map = IdentityMap.new )
-    end
-    
-    def first(klass, *args)
-      id = nil
-      options = nil
-      table = self.table(klass)
-      key = table.key
-      
-      if args.empty? # No id, no options
-        options = { :limit => 1 }
-      elsif args.size == 2 && args.last.kind_of?(Hash) # id AND options
-        options = args.last.merge(key => args.first)
-      elsif args.size == 1 # id OR options
-        if args.first.kind_of?(Hash)
-          options = args.first.merge(:limit => 1) # no id, add limit
-        else
-          options = { key => args.first } # no options, set id
-        end
-      else
-        raise ArgumentError.new('Context#first takes a class, and optional type_or_id and/or options arguments')
-      end
-      
-      # Account for undesired behaviour in MySQL that returns the
-      # last inserted row when the WHERE clause contains a "#{primary_key} IS NULL".
-      return nil if options.has_key?(key.name) && options[key.name] == nil
-      
-      @adapter.load(self, klass, options).first
-    end
-    
-    def get(klass, keys)
-      @adapter.get(self, klass, keys)
-    end
-    
-    def all(klass, options = {})
-      @adapter.load(self, klass, options)
-    end
-    
-    def count(klass, *args)
-      table(klass).count(*args)
-    end
-    
-    def save(instance)
-      @adapter.save(self, instance)
-    end
-    
-    def destroy(instance)
-      @adapter.delete(self, instance)
-    end
-    
-    def delete_all(klass)
-      @adapter.delete(self, klass)
-    end
-    
-    def truncate(klass)
-      table(klass).truncate!
-    end
-    
-    def create_table(klass)
-      table(klass).create!
-    end
-    
-    def drop_table(klass)
-      table(klass).drop!
-    end
-    
-    def table_exists?(klass)
-      table(klass).exists?
-    end
-    
-    def column_exists_for_table?(klass, column_name)
-      @adapter.column_exists_for_table?(klass, column_name)
-    end
-    
-    def execute(*args)
-      @adapter.execute(*args)
-    end
-    
-    def query(*args)      
-      @adapter.query(*args)
-    end
-    
-    def schema
-      @adapter.schema
-    end
-    
-    def table(klass)
-      @adapter.table(klass)
-    end
-    
-    def logger
-      @logger || @logger = @adapter.logger
-    end
-
-  end
-end