dm-core 0.10.0 → 0.10.1

data/lib/dm-core/associations/relationship.rb

@@ -6,7 +6,7 @@ module DataMapper
     class Relationship
       include Extlib::Assertions
 
-      OPTIONS = [ :child_repository_name, :parent_repository_name, :child_key, :parent_key, :min, :max, :inverse ].to_set
+      OPTIONS = [ :child_repository_name, :parent_repository_name, :child_key, :parent_key, :min, :max, :inverse, :reader_visibility, :writer_visibility ].to_set
 
       # Relationship name
       #
@@ -94,6 +94,22 @@ module DataMapper
       # @api semipublic
       attr_reader :max
 
+      # Returns the visibility for the source accessor
+      #
+      # @return [Symbol]
+      #   the visibility for the accessor added to the source
+      #
+      # @api semipublic
+      attr_reader :reader_visibility
+
+      # Returns the visibility for the source mutator
+      #
+      # @return [Symbol]
+      #   the visibility for the mutator added to the source
+      #
+      # @api semipublic
+      attr_reader :writer_visibility
+
       # Returns query options for relationship.
       #
       # For this base class, always returns query options
@@ -352,7 +368,6 @@ module DataMapper
       def ==(other)
         return true  if equal?(other)
         return false if kind_of_inverse?(other)
-
         other.respond_to?(:cmp_repository?, true) &&
         other.respond_to?(:cmp_model?, true)      &&
         other.respond_to?(:cmp_key?, true)        &&
@@ -427,6 +442,8 @@ module DataMapper
         @parent_properties      = @options[:parent_key].try_dup.freeze
         @min                    = @options[:min]
         @max                    = @options[:max]
+        @reader_visibility      = @options.fetch(:reader_visibility, :public)
+        @writer_visibility      = @options.fetch(:writer_visibility, :public)
 
         # TODO: normalize the @query to become :conditions => AndOperation
         #  - Property/Relationship/Path should be left alone
@@ -478,22 +495,38 @@ module DataMapper
         object
       end
 
-      # Creates reader method for association.
-      #
-      # Must be implemented by subclasses.
+      # Dynamically defines reader method for source side of association
+      # (for instance, method article for model Paragraph)
       #
       # @api semipublic
       def create_reader
-        raise NotImplementedError, "#{self.class}#create_reader not implemented"
+        reader_name = name.to_s
+
+        return if source_model.resource_method_defined?(reader_name)
+
+        source_model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{reader_visibility}                               # public
+          def #{reader_name}(query = nil)                    # def author(query = nil)
+            relationships[#{name.inspect}].get(self, query)  #   relationships[:author].get(self, query)
+          end                                                # end
+        RUBY
       end
 
-      # Creates both writer method for association.
-      #
-      # Must be implemented by subclasses.
+      # Dynamically defines writer method for source side of association
+      # (for instance, method article= for model Paragraph)
       #
       # @api semipublic
       def create_writer
-        raise NotImplementedError, "#{self.class}#create_writer not implemented"
+        writer_name = "#{name}="
+
+        return if source_model.resource_method_defined?(writer_name)
+
+        source_model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{writer_visibility}                                # public
+          def #{writer_name}(target)                          # def author=(target)
+            relationships[#{name.inspect}].set(self, target)  #   relationships[:author].set(self, target)
+          end                                                 # end
+        RUBY
       end
 
       # Sets the association targets in the resource
@@ -569,16 +602,6 @@ module DataMapper
         options.only(*OPTIONS - [ :min, :max ]).update(:inverse => self)
       end
 
-      # TODO: document
-      # @api private
-      def options_with_inverse
-        if child_model? && parent_model?
-          options.merge(:inverse => inverse)
-        else
-          options.merge(:inverse => inverse_name)
-        end
-      end
-
       # TODO: document
       # @api private
       def kind_of_inverse?(other)

data/lib/dm-core/collection.rb

@@ -534,9 +534,10 @@ module DataMapper
     #   the last Resource in the Collection
     #
     # @api public
-    def pop
-      return nil unless resource = super
-      resource_removed(resource)
+    def pop(*)
+      if removed = super
+        resources_removed(removed)
+      end
     end
 
     # Removes and returns the first Resource in the Collection
@@ -545,9 +546,10 @@ module DataMapper
     #   the first Resource in the Collection
     #
     # @api public
-    def shift
-      return nil unless resource = super
-      resource_removed(resource)
+    def shift(*)
+      if removed = super
+        resources_removed(removed)
+      end
     end
 
     # Remove Resource from the Collection
@@ -566,8 +568,9 @@ module DataMapper
     #
     # @api public
     def delete(resource)
-      return nil unless resource = super
-      resource_removed(resource)
+      if resource = super
+        resource_removed(resource)
+      end
     end
 
     # Remove Resource from the Collection by offset
@@ -586,8 +589,9 @@ module DataMapper
     #
     # @api public
     def delete_at(offset)
-      return nil unless resource = super
-      resource_removed(resource)
+      if resource = super
+        resource_removed(resource)
+      end
     end
 
     # Deletes every Resource for which block evaluates to true.
@@ -1103,36 +1107,33 @@ module DataMapper
     #
     # @api private
     def default_attributes
-      @default_attributes ||=
-        begin
-          unless query.conditions.kind_of?(Query::Conditions::AndOperation)
-            return
-          end
+      return @default_attributes if @default_attributes
 
-          default_attributes = {}
+      default_attributes = {}
 
-          repository_name = repository.name
-          relationships   = self.relationships.values
-          properties      = model.properties(repository_name)
-          key             = model.key(repository_name)
+      conditions = query.conditions
 
-          # if all the key properties are included in the conditions,
-          # then do not allow them to be default attributes
-          if query.condition_properties.to_set.superset?(key.to_set)
-            properties -= key
-          end
+      if conditions.kind_of?(Query::Conditions::AndOperation)
+        repository_name = repository.name
+        relationships   = self.relationships.values
+        properties      = model.properties(repository_name)
+        key             = model.key(repository_name)
 
-          query.conditions.each do |condition|
-            unless condition.kind_of?(Query::Conditions::EqualToComparison) &&
-              (properties.include?(condition.subject) || (condition.relationship? && condition.subject.source_model == model))
-              next
-            end
+        # if all the key properties are included in the conditions,
+        # then do not allow them to be default attributes
+        if query.condition_properties.to_set.superset?(key.to_set)
+          properties -= key
+        end
 
+        conditions.each do |condition|
+          if condition.kind_of?(Query::Conditions::EqualToComparison) &&
+            (properties.include?(condition.subject) || (condition.relationship? && condition.subject.source_model == model))
             default_attributes[condition.subject] = condition.value
           end
-
-          default_attributes.freeze
         end
+      end
+
+      @default_attributes = default_attributes.freeze
     end
 
     # Set the default attributes for a non-frozen resource

data/lib/dm-core/model/property.rb

@@ -24,9 +24,8 @@ module DataMapper
           model.instance_variable_set(:@paranoid_properties,      @paranoid_properties.dup)
 
           @properties.each do |repository_name, properties|
-            properties.each do |property|
-              model.properties(repository_name) << property
-            end
+            model_properties = model.properties(repository_name)
+            properties.each { |property| model_properties[property.name] ||= property }
           end
 
           super
@@ -74,8 +73,10 @@ module DataMapper
           context = options.fetch(:lazy, :default)
           context = :default if context == true
 
-          Array(context).each do |item|
-            properties(repository_name).lazy_context(item) << name
+          properties = properties(repository_name)
+
+          Array(context).each do |context|
+            properties.lazy_context(context) << self
           end
         end
 
@@ -83,8 +84,7 @@ module DataMapper
         # added after the child classes' properties have been copied from
         # the parent
         descendants.each do |descendant|
-          next if descendant.properties(repository_name).named?(name)
-          descendant.property(name, type, options)
+          descendant.properties(repository_name)[name] ||= property
         end
 
         create_reader_for(property)
@@ -156,7 +156,7 @@ module DataMapper
 
         descendants.each do |model|
           model.properties(repository_name).each do |property|
-            properties << property unless properties.named?(property.name)
+            properties[property.name] ||= property
           end
         end
 

data/lib/dm-core/model/relationship.rb

@@ -27,15 +27,11 @@ module DataMapper
         #
         # @api private
         def inherited(model)
-          # TODO: Create a RelationshipSet class, and then add a method that allows copying the relationships to the supplied repository and model
-          model.instance_variable_set(:@relationships, duped_relationships = {})
+          model.instance_variable_set(:@relationships, {})
 
           @relationships.each do |repository_name, relationships|
-            dup = duped_relationships[repository_name] ||= Mash.new
-
-            relationships.each do |name, relationship|
-              dup[name] = relationship.inherited_by(model)
-            end
+            model_relationships = model.relationships(repository_name)
+            relationships.each { |name, relationship| model_relationships[name] ||= relationship }
           end
 
           super
@@ -120,9 +116,11 @@ module DataMapper
 
         model ||= options.delete(:model)
 
+        repository_name = repository.name
+
         # TODO: change to :target_respository_name and :source_repository_name
         options[:child_repository_name]  = options.delete(:repository)
-        options[:parent_repository_name] = repository.name
+        options[:parent_repository_name] = repository_name
 
         klass = if options[:max] > 1
           options.key?(:through) ? Associations::ManyToMany::Relationship : Associations::OneToMany::Relationship
@@ -130,10 +128,10 @@ module DataMapper
           Associations::OneToOne::Relationship
         end
 
-        relationship = relationships(repository.name)[name] = klass.new(name, model, self, options)
+        relationship = relationships(repository_name)[name] = klass.new(name, model, self, options)
 
         descendants.each do |descendant|
-          descendant.relationships(repository.name)[name] ||= relationship.inherited_by(descendant)
+          descendant.relationships(repository_name)[name] ||= relationship
         end
 
         relationship
@@ -186,10 +184,10 @@ module DataMapper
         options[:child_repository_name]  = repository_name
         options[:parent_repository_name] = options.delete(:repository)
 
-        relationship = relationships(repository.name)[name] = Associations::ManyToOne::Relationship.new(name, self, model, options)
+        relationship = relationships(repository_name)[name] = Associations::ManyToOne::Relationship.new(name, self, model, options)
 
         descendants.each do |descendant|
-          descendant.relationships(repository.name)[name] ||= relationship.inherited_by(descendant)
+          descendant.relationships(repository_name)[name] ||= relationship
         end
 
         relationship

data/lib/dm-core/property.rb

@@ -293,10 +293,13 @@ module DataMapper
   class Property
     include Extlib::Assertions
     extend Deprecate
+    extend Equalizer
 
     deprecate :unique, :unique?
     deprecate :size,   :length
 
+    equalize :model, :name
+
     # NOTE: PLEASE update OPTIONS in DataMapper::Type when updating
     # them here
     OPTIONS = [
@@ -363,56 +366,6 @@ module DataMapper
       @unique
     end
 
-    # Compares another Property for equivalency
-    #
-    #   TODO: needs example
-    #
-    # @param [Property] other
-    #   the other Property to compare with
-    #
-    # @return [Boolean]
-    #   true if they are equivalent, false if not
-    #
-    # @api semipublic
-    def ==(other)
-      if equal?(other)
-        return true
-      end
-
-      unless other.respond_to?(:model)
-        return false
-      end
-
-      unless other.respond_to?(:name)
-        return false
-      end
-
-      cmp?(other, :==)
-    end
-
-    # Compares another Property for equality
-    #
-    #   TODO: needs example
-    #
-    # @param [Property] other
-    #   the other Property to compare with
-    #
-    # @return [Boolean]
-    #   true if they are equal, false if not
-    #
-    # @api semipublic
-    def eql?(other)
-      if equal?(other)
-        return true
-      end
-
-      unless instance_of?(other.class)
-        return false
-      end
-
-      cmp?(other, :eql?)
-    end
-
     # Returns the hash of the property name
     #
     # This is necessary to allow comparisons between different properties
@@ -640,11 +593,19 @@ module DataMapper
     #
     # @api private
     def lazy_load(resource)
-      # If we're trying to load a lazy property, load it. Otherwise, lazy-load
-      # any properties that should be eager-loaded but were not included
-      # in the original :fields list
-      property_names = lazy? ? [ name ] : model.properties(resource.repository.name).defaults.map { |property| property.name }
-      resource.send(:lazy_load, property_names)
+      resource.send(:lazy_load, lazy_load_properties)
+    end
+
+    # TODO: document
+    # @api private
+    def lazy_load_properties
+      @lazy_load_properties ||= properties.in_context(lazy? ? [ self ] : properties.defaults)
+    end
+
+    # TODO: document
+    # @api private
+    def properties
+      @properties ||= model.properties(repository_name)
     end
 
     # typecasts values into a primitive (Ruby class that backs DataMapper
@@ -673,7 +634,7 @@ module DataMapper
     # @return [rue, String, Float, Integer, BigDecimal, DateTime, Date, Time, Class]
     #   The typecasted +value+
     #
-    # @api private
+    # @api semipublic
     def typecast(value)
       return type.typecast(value, self) if type.respond_to?(:typecast)
       return value if primitive?(value) || value.nil?
@@ -903,19 +864,16 @@ module DataMapper
               raise ArgumentError, "options[#{key.inspect}] must not be nil"
             end
 
-          when :serial, :key, :nullable, :unique, :auto_validation
+          when :serial, :key, :nullable, :auto_validation
             unless value == true || value == false
               raise ArgumentError, "options[#{key.inspect}] must be either true or false"
             end
 
-          when :lazy
-            unless value == true || value == false || value.kind_of?(Symbol) || (value.kind_of?(Array) && value.all? { |val| val.kind_of?(Symbol) })
+          when :index, :unique_index, :unique, :lazy
+            unless value == true || value == false || value.kind_of?(Symbol) || (value.kind_of?(Array) && value.any? && value.all? { |val| val.kind_of?(Symbol) })
               raise ArgumentError, "options[#{key.inspect}] must be either true, false, a Symbol or an Array of Symbols"
             end
 
-          when :index, :unique_index
-            assert_kind_of "options[#{key.inspect}]", value, Symbol, Array, TrueClass
-
           when :length
             assert_kind_of "options[#{key.inspect}]", value, Range, Integer
 
@@ -1184,28 +1142,5 @@ module DataMapper
     rescue NameError
       value
     end
-
-    # Return true if +other+'s is equivalent or equal to +self+'s
-    #
-    # @param [Property] other
-    #   The Property whose attributes are to be compared with +self+'s
-    # @param [Symbol] operator
-    #   The comparison operator to use to compare the attributes
-    #
-    # @return [Boolean]
-    #   The result of the comparison of +other+'s attributes with +self+'s
-    #
-    # @api private
-    def cmp?(other, operator)
-      unless model.base_model.send(operator, other.model.base_model)
-        return false
-      end
-
-      unless name.send(operator, other.name)
-        return false
-      end
-
-      true
-    end
   end # class Property
 end # module DataMapper

data/lib/dm-core/property_set.rb

@@ -132,10 +132,10 @@ module DataMapper
 
     # TODO: document
     # @api private
-    def property_contexts(property_name)
+    def property_contexts(property)
       contexts = []
-      lazy_contexts.each do |context, property_names|
-        contexts << context if property_names.include?(property_name)
+      lazy_contexts.each do |context, properties|
+        contexts << context if properties.include?(property)
       end
       contexts
     end
@@ -148,16 +148,16 @@ module DataMapper
 
     # TODO: document
     # @api private
-    def in_context(property_names)
-      property_names_in_context = property_names.map do |property_name|
-        if (contexts = property_contexts(property_name)).any?
+    def in_context(properties)
+      properties_in_context = properties.map do |property|
+        if (contexts = property_contexts(property)).any?
           lazy_contexts.values_at(*contexts)
         else
-          property_name  # not lazy
+          property
         end
       end
 
-      values_at(*property_names_in_context.flatten.uniq)
+      properties_in_context.flatten.uniq
     end
 
     private

data/lib/dm-core/query/conditions/comparison.rb

@@ -108,9 +108,12 @@ module DataMapper
       # A base class for the various comparison classes.
       class AbstractComparison
         extend Deprecate
+        extend Equalizer
 
         deprecate :property, :subject
 
+        equalize :slug, :subject, :value
+
         # The property or relationship which is being matched against
         #
         # @return [Property, Associations::Relationship]
@@ -188,6 +191,16 @@ module DataMapper
           slug ? @slug = slug : @slug
         end
 
+        # Return the comparison class slug
+        #
+        # @return [Symbol]
+        #   the comparison class slug
+        #
+        # @api private
+        def slug
+          self.class.slug
+        end
+
         # Tests that the Comparison is valid
         #
         # Subclasses can overload this to customise the means by which they
@@ -227,57 +240,6 @@ module DataMapper
           subject.kind_of?(Property)
         end
 
-        # Computes a hash-code for this Comparison
-        #
-        # Two Comparisons of the same class, and with the same subject and
-        # value will have the same hash-code.
-        #
-        # @return [Fixnum] The computed hash-code.
-        #
-        # @api semipublic
-        def hash
-          [ self.class, @subject, @value ].hash
-        end
-
-        # Returns true if this object equals +other+
-        #
-        # The objects are considered equal if they are the same object, or
-        # have the same slug, subject and value.
-        #
-        # @param [Object] other
-        #   Another object to be compared against this one.
-        #
-        # @return [Boolean]
-        #
-        # @api semipublic
-        def ==(other)
-          return true if equal?(other)
-
-          return false unless other.class.respond_to?(:slug)
-          return false unless other.respond_to?(:subject)
-          return false unless other.respond_to?(:value)
-
-          cmp?(other, :==)
-        end
-
-        # Returns true if this object equals +other+
-        #
-        # The objects are considered equal if they are the same object, or are
-        # the same class, and have the same slug, subject and value.
-        #
-        # @param [Object] other
-        #   Another object to be compared against this one.
-        #
-        # @return [Boolean]
-        #
-        # @api semipublic
-        def eql?(other)
-          return true if equal?(other)
-          return false unless instance_of?(other.class)
-
-          cmp?(other, :eql?)
-        end
-
         # Returns a human-readable representation of this object
         #
         # @return [String]
@@ -334,26 +296,6 @@ module DataMapper
           @loaded_value = @loaded_value.dup
         end
 
-        # Compares this comparison with +other+ using the given +operator+
-        #
-        # Checks that the slug, subject and value all return true when
-        # compared with their counterparts in +other+ with +operator+.
-        #
-        # @param [AbstractComparison] other
-        #    Another object to be compared against this one.
-        #
-        # @see AbstractComparison#==
-        # @see AbstractComparison#eql?
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        def cmp?(other, operator)
-          self.class.slug.send(operator, other.class.slug) &&
-          subject.send(operator, other.subject)            &&
-          value.send(operator, other.value)
-        end
-
         # Typecasts the given +val+ using subject#typecast
         #
         # If the subject has no typecast method the value is returned without