datamapper 0.2.3 → 0.2.4

data/lib/data_mapper/base.rb

@@ -1,9 +1,12 @@
+require 'data_mapper/property'
 require 'data_mapper/support/active_record_impersonation'
 require 'data_mapper/support/serialization'
-require 'data_mapper/validations/validation_helper'
+require 'data_mapper/validations'
 require 'data_mapper/associations'
 require 'data_mapper/callbacks'
 require 'data_mapper/embedded_value'
+require 'data_mapper/auto_migrations'
+require 'data_mapper/dependency_queue'
 
 begin
   require 'ferret'
@@ -11,7 +14,7 @@ rescue LoadError
 end
 
 module DataMapper
-  
+
   class Base
     
     # This probably needs to be protected
@@ -20,7 +23,7 @@ module DataMapper
     include CallbacksHelper
     include Support::ActiveRecordImpersonation
     include Support::Serialization
-    include Validations::ValidationHelper
+    include Validations
     include Associations
     
     # Track classes that inherit from DataMapper::Base.
@@ -34,44 +37,52 @@ module DataMapper
       end
     end
     
+    def self.dependencies
+      @dependency_queue || (@dependency_queue = DependencyQueue.new) 
+    end
+    
     def self.inherited(klass)
+      klass.instance_variable_set('@properties', [])
+      
+      klass.send :extend, AutoMigrations
       DataMapper::Base::subclasses << klass
-      klass.send(:undef_method, :id)      
+      klass.send(:undef_method, :id)
       
       # When this class is sub-classed, copy the declared columns.
       klass.class_eval do
-        
-        def self.auto_migrate!
-          if self::subclasses.empty?
-            database.schema[self].drop!
-            database.save(self)
-          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.drop!
-            table.create!
-          end
-        end
-        
         def self.subclasses
           @subclasses || (@subclasses = [])
         end
         
         def self.inherited(subclass)
+          
+          super_table = database.table(self)
+          
+          if super_table.type_column.nil?
+            super_table.add_column(:type, :class, {})
+          end
+          
           self::subclasses << subclass
         end
       end
     end
     
+    def self.logger
+      database.logger
+    end
+    
+    def logger
+      self.class.logger
+    end
+    
+    def self.transaction
+      yield
+    end
+    
+    def self.properties
+      @properties
+    end
+    
     # Allows you to override the table name for a model.
     # EXAMPLE:
     #   class WorkItem
@@ -90,9 +101,15 @@ module DataMapper
       end
     end
     
+    PROPERTY_OPTIONS = [
+      :public, :protected, :private, :accessor, :reader, :writer,
+      :lazy, :default, :nullable, :key, :serial, :column
+    ]
+    
     # Adds property accessors for a field that you'd like to be able to modify.  The DataMapper doesn't
     # use the table schema to infer accessors, you must explicity call #property to add field accessors
     # to your model.
+    #
     # EXAMPLE:
     #   class CellProvider
     #     property :name, :string
@@ -105,10 +122,34 @@ module DataMapper
     #
     #   => AT&T
     #   => 3
+    #
+    # OPTIONS:
+    #   * <tt>lazy</tt>: Lazy load the specified property (:lazy => true). False by default.
+    #   * <tt>accessor</tt>: Set method visibility for the property accessors. Affects both 
+    #   reader and writer. Allowable values are :public, :protected, :private. Defaults to 
+    #   :public
+    #   * <tt>reader</tt>: Like the accessor option but affects only the property reader.
+    #   * <tt>writer</tt>: Like the accessor option but affects only the property writer.
+    #   * <tt>protected</tt>: Alias for :reader => :public, :writer => :protected
+    #   * <tt>private</tt>: Alias for :reader => :public, :writer => :private
     def self.property(name, type, options = {})
-      mapping = database.schema[self].add_column(name, type, options)
-      property_getter(name, mapping)
-      property_setter(name, mapping)
+      
+      options.each_pair do |k,v|
+        raise ArgumentError.new("#{k.inspect} is not a supported option in DataMapper::Base::PROPERTY_OPTIONS") unless PROPERTY_OPTIONS.include?(k)
+      end
+      
+      visibility_options = [:public, :protected, :private]
+      reader_visibility = options[:reader] || options[:accessor] || :public
+      writer_visibility = options[:writer] || options[:accessor] || :public
+      writer_visibility = :protected if options[:protected]
+      writer_visibility = :private if options[:private]
+
+      raise(ArgumentError.new, "property visibility must be :public, :protected, or :private") unless visibility_options.include?(reader_visibility) && visibility_options.include?(writer_visibility)
+
+      mapping = database.schema[self].add_column(name.to_s.sub(/\?$/, '').to_sym, type, options)
+
+      property_getter(mapping, reader_visibility)
+      property_setter(mapping, writer_visibility)
       
       if MAGIC_PROPERTIES.has_key?(name)
         class_eval(&MAGIC_PROPERTIES[name])
@@ -124,35 +165,78 @@ module DataMapper
       :created_on => lambda { before_create { |x| x.created_on = Date::today } }
     }
     
-    def self.embed(class_or_name, &block)
-      EmbeddedValue::define(self, class_or_name, &block)
+    # An embedded value maps the values of an object to fields in the record of the object's owner.
+    # #embed takes a symbol to define the embedded class, options, and an optional block. See 
+    # examples for use cases.
+    # 
+    # EXAMPLE:
+    #   class CellPhone < DataMapper::Base
+    #     property :number, :string
+    #
+    #     embed :owner, :prefix => true do
+    #       property :name, :string
+    #       property :address, :string
+    #     end
+    #   end
+    #
+    #   my_phone = CellPhone.new
+    #   my_phone.owner.name = "Nick"
+    #   puts my_phone.owner.name
+    #
+    #   => Nick
+    #
+    # OPTIONS:
+    #   * <tt>prefix</tt>: define a column prefix, so instead of mapping :address to an 'address' 
+    #   column, it would map to 'owner_address' in the example above. If :prefix => true is 
+    #   specified, the prefix will be the name of the symbol given as the first parameter. If the
+    #   prefix is a string the specified string will be used for the prefix.
+    #   * <tt>lazy</tt>: lazy-load all embedded values at the same time. :lazy => true to enable.
+    #   Disabled (false) by default.
+    #   * <tt>accessor</tt>: Set method visibility for all embedded properties. Affects both
+    #   reader and writer. Allowable values are :public, :protected, :private. Defaults to :public
+    #   * <tt>reader</tt>: Like the accessor option but affects only embedded property readers.
+    #   * <tt>writer</tt>: Like the accessor option but affects only embedded property writers.
+    #   * <tt>protected</tt>: Alias for :reader => :public, :writer => :protected
+    #   * <tt>private</tt>: Alias for :reader => :public, :writer => :private
+    #
+    def self.embed(name, options = {}, &block)
+      EmbeddedValue::define(self, name, options, &block)
     end
 
-    def self.property_getter(name, mapping)
+    def self.property_getter(mapping, visibility = :public)
       if mapping.lazy?
         class_eval <<-EOS
-          def #{name}
-            lazy_load!(#{name.inspect})
-            @#{name}
+          #{visibility.to_s}
+          def #{mapping.name}
+            lazy_load!(#{mapping.name.inspect})
+            class << self;
+              attr_accessor #{mapping.name.inspect}
+            end
+            @#{mapping.name}
           end
         EOS
       else
-        class_eval("def #{name}; #{mapping.instance_variable_name} end")
+        class_eval("#{visibility.to_s}; def #{mapping.name}; #{mapping.instance_variable_name} end") unless [ :public, :private, :protected ].include?(mapping.name)
+      end
+      
+      if mapping.type == :boolean
+        class_eval("#{visibility.to_s}; def #{mapping.name}?; #{mapping.instance_variable_name} end")
       end
     end
     
-    def self.property_setter(name, mapping)
+    def self.property_setter(mapping, visibility = :public)
       if mapping.lazy?
         class_eval <<-EOS
-          def #{name.to_s.sub(/\?$/, '')}=(value)
+          #{visibility.to_s}
+          def #{mapping.name}=(value)
             class << self;
-              attr_accessor #{name.inspect}
+              attr_accessor #{mapping.name.inspect}
             end
-            @#{name} = value
+            @#{mapping.name} = value
           end
         EOS
       else
-        class_eval("def #{name.to_s.sub(/\?$/, '')}=(value); #{mapping.instance_variable_name} = value end")
+        class_eval("#{visibility.to_s}; def #{mapping.name}=(value); #{mapping.instance_variable_name} = value end")
       end
     end
     
@@ -160,19 +244,28 @@ module DataMapper
     # for the named methods so that the lazy_loading is skipped the second time.
     def lazy_load!(*names)
       
+      names = names.map { |name| name.to_sym }.reject { |name| lazy_loaded_attributes.include?(name) }
+      
       reset_attribute = lambda do |instance|
         singleton_class = (class << instance; self end)
         names.each do |name|
+          instance.lazy_loaded_attributes << name
           singleton_class.send(:attr_accessor, name)
         end
       end
       
-      unless new_record? || loaded_set.nil?
-        session.all(
+      unless names.empty? || new_record? || loaded_set.nil?
+        
+        key = database_context.table(self.class).key.to_sym
+        keys_to_select = loaded_set.map do |instance|
+          instance.send(key)
+        end
+        
+        database_context.all(
           self.class,
-          :select => ([:id] + names),
+          :select => ([key] + names),
           :reload => true,
-          :id => loaded_set.map(&:id)
+          key => keys_to_select
         ).each(&reset_attribute)
       else
         reset_attribute[self]
@@ -183,7 +276,12 @@ module DataMapper
     def new_record?
       @new_record.nil? || @new_record
     end
+
+    def ==(other)
+      private_attributes == other.send("private_attributes")
+    end
     
+    # Returns the difference between two objects, in terms of their attributes. 
     def ^(other)
       results = {}
       
@@ -199,10 +297,14 @@ module DataMapper
       results      
     end
     
+    def lazy_loaded_attributes
+      @lazy_loaded_attributes || @lazy_loaded_attributes = Set.new
+    end
+    
     def loaded_attributes
       pairs = {}
       
-      session.table(self).columns.each do |column|
+      database_context.table(self).columns.each do |column|
         pairs[column.name] = instance_variable_get(column.instance_variable_name)
       end
       
@@ -217,10 +319,12 @@ module DataMapper
     def attributes
       pairs = {}
       
-      session.table(self).columns.each do |column|
-        lazy_load!(column.name) if column.lazy?
-        value = instance_variable_get(column.instance_variable_name)
-        pairs[column.name] = column.type == :class ? value.to_s : value
+      database_context.table(self).columns.each do |column|
+        if self.class.public_method_defined?(column.name)
+          lazy_load!(column.name) if column.lazy?
+          value = instance_variable_get(column.instance_variable_name)
+          pairs[column.name] = column.type == :class ? value.to_s : value
+        end
       end
       
       pairs
@@ -228,50 +332,42 @@ module DataMapper
     
     # Mass-assign mapped fields.
     def attributes=(values_hash)
-      table = session.schema[self.class]
+      table = database_context.table(self.class)
       
-      values_hash.reject do |key, value|
-        protected_attribute? key
+      values_hash.delete_if do |key, value|
+        !self.class.public_method_defined?("#{key}=")
       end.each_pair do |key, value|
-        if column = table[key]
-          instance_variable_set(column.instance_variable_name, value)
-        else
+        if respond_to?(key)
           send("#{key}=", value)
+        elsif column = table[key]
+          instance_variable_set(column.instance_variable_name, value)          
         end
       end
     end
     
-    def dirty?(name = nil)
-      if name.nil?
-        session.table(self).columns.any? do |column|
+    def dirty?
+      result = database_context.table(self).columns.any? do |column|
+        if column.type == :object
+          Marshal.dump(self.instance_variable_get(column.instance_variable_name)) != original_values[column.name]
+        else
           self.instance_variable_get(column.instance_variable_name) != original_values[column.name]
-        end || loaded_associations.any? do |loaded_association|
-          if loaded_association.respond_to?(:dirty?)
-            loaded_association.dirty?
-          else
-            false
-          end
         end
-      else
-        key = name.kind_of?(Symbol) ? name : name.to_sym
-        self.instance_variable_get("@#{name}") != original_values[key]
+      end
+      
+      return true if result
+      
+      loaded_associations.any? do |loaded_association|
+        loaded_association.dirty?
       end
     end
 
     def dirty_attributes
       pairs = {}
       
-      if new_record?
-        session.table(self).columns.each do |column|
-          unless (value = instance_variable_get(column.instance_variable_name)).nil?
-            pairs[column.name] = value
-          end
-        end
-      else
-        session.table(self).columns.each do |column|
-          if (value = instance_variable_get(column.instance_variable_name)) != original_values[column.name]
-            pairs[column.name] = value
-          end
+      database_context.table(self).columns.each do |column|
+        value = instance_variable_get(column.instance_variable_name)
+        if value != original_values[column.name] && (!new_record? || !column.serial?)
+          pairs[column.name] = column.type != :object ? value : YAML.dump(value)
         end
       end
       
@@ -282,14 +378,6 @@ module DataMapper
       @original_values || (@original_values = {})
     end
     
-    def protected_attribute?(key)
-      self.class.protected_attributes.include?(key.kind_of?(Symbol) ? key : key.to_sym)
-    end
-    
-    def self.protected_attributes
-      @protected_attributes ||= []
-    end
-    
     def self.index
       @index || @index = Ferret::Index::Index.new(:path => "#{database.adapter.index_path}/#{name}")
     end
@@ -311,14 +399,14 @@ module DataMapper
       return all(:id => ids)
     end
     
-    def self.protect(*keys)
-      keys.each { |key| protected_attributes << key.to_sym }
-    end
-    
     def self.foreign_key
       Inflector.underscore(self.name) + "_id"
     end
     
+    def self.table
+      database.schema[self]
+    end
+    
     def inspect
       inspected_attributes = attributes.map { |k,v| "@#{k}=#{v.inspect}" }
       
@@ -335,27 +423,42 @@ module DataMapper
       @loaded_associations || @loaded_associations = []
     end
     
-    def session=(value)
-      @session = value
+    def database_context=(value)
+      @database_context = value
     end
     
-    def session
-      @session || ( @session = database )
+    def database_context
+      @database_context || ( @database_context = database )
     end
     
     def key=(value)
-      key_column = session.schema[self.class].key
+      key_column = database_context.table(self.class).key
       @__key = key_column.type_cast_value(value)
       instance_variable_set(key_column.instance_variable_name, @__key)
     end
     
     def key
       @__key || @__key = begin
-        key_column = session.schema[self.class].key
+        key_column = database_context.table(self.class).key
         key_column.type_cast_value(instance_variable_get(key_column.instance_variable_name))
       end
     end
+
+    private
+
+    # return all attributes, regardless of their visibility
+    def private_attributes
+      pairs = {}
+
+      database_context.table(self).columns.each do |column|
+        lazy_load!(column.name) if column.lazy?
+        value = instance_variable_get(column.instance_variable_name)
+        pairs[column.name] = column.type == :class ? value.to_s : value
+      end
+
+      pairs
+    end
     
   end
   
-end
+end

data/lib/data_mapper/context.rb

@@ -20,24 +20,26 @@ module DataMapper
     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(:id => args.first)
+        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 = { :id => args.first } # no options, set id
+          options = { key => args.first } # no options, set id
         end
       else
-        raise ArgumentError.new('Session#first takes a class, and optional type_or_id and/or options arguments')
+        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?(:id) && options[:id] == nil
+      return nil if options.has_key?(key.name) && options[key.name] == nil
       
       @adapter.load(self, klass, options).first
     end
@@ -46,8 +48,8 @@ module DataMapper
       @adapter.load(self, klass, options)
     end
     
-    def count(klass, options = {})
-      @adapter.count(klass, options)
+    def count(klass, *args)
+      table(klass).count(*args)
     end
     
     def save(instance)
@@ -63,19 +65,23 @@ module DataMapper
     end
     
     def truncate(klass)
-      @adapter.truncate(self, klass)
+      table(klass).truncate!
     end
     
     def create_table(klass)
-      @adapter.create_table(klass)
+      table(klass).create!
     end
     
     def drop_table(klass)
-      @adapter.drop(self, klass)
+      table(klass).drop!
     end
     
     def table_exists?(klass)
-      @adapter.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)

data/lib/data_mapper/database.rb

@@ -27,10 +27,12 @@ module DataMapper
     unless block_given?
       Database.context.last || Context.new(Database[name].adapter)
     else
-      Database.context.push(Context.new(Database[name].adapter))
-      result = yield(Database.context.last)
-      Database.context.pop
-      result
+      begin
+        Database.context.push(Context.new(Database[name].adapter))
+        return yield(Database.context.last)
+      ensure
+        Database.context.pop
+      end
     end
   end
   
@@ -172,8 +174,13 @@ module DataMapper
       @log_stream = nil
     end
     
-    attr_reader :name, :adapter
-    attr_accessor :host, :database, :schema_search_path, :username, :password, :log_stream, :log_level, :index_path, :socket
+    attr_reader :name, :adapter, :log_stream
+    
+    attr_accessor :host, :database, :schema_search_path, :username, :password, :log_level, :index_path, :socket
+    
+    def log_stream=(val)
+      @log_stream = (val.is_a?(String) && val =~ /STDOUT/ ? STDOUT : val)
+    end
     
     # Allows us to set the adapter for this database object. It can only be set once, and expects two types of values.
     #
@@ -206,17 +213,21 @@ module DataMapper
     
     # Default Logger from Ruby's logger.rb
     def logger
-      @logger = Logger.new(@log_stream, File::WRONLY | File::APPEND | File::CREAT)
-      @logger.level = @log_level
-      at_exit { @logger.close }
-      
+      @logger = create_logger
+    
       class << self
         attr_reader :logger
       end
-      
+    
       return @logger
     end
     
+    def create_logger
+      x = Logger.new(@log_stream, File::WRONLY | File::APPEND | File::CREAT)
+      x.level = @log_level
+      at_exit { x.close }
+      return x
+    end
   end
   
 end

data/lib/data_mapper/dependency_queue.rb

@@ -0,0 +1,28 @@
+module DataMapper
+  class DependencyQueue
+    
+    def initialize
+      @dependencies = Hash.new { |h,k| h[k] = [] }
+    end
+    
+    def add(class_name, &b)
+      @dependencies[class_name] << b
+      resolve!
+    end
+    
+    def resolve!
+      @dependencies.each_pair do |class_name, callbacks|
+        if Object.const_defined?(class_name)
+          klass = Object.const_get(class_name)
+
+          callbacks.each do |b|
+            b.call(klass)
+          end
+          
+          callbacks.clear
+        end
+      end
+    end
+    
+  end # class DependencyQueue
+end # module DataMapper