datamapper-dm-core 0.9.11 → 0.10.0

data/lib/dm-core/property_set.rb

@@ -1,169 +1,212 @@
 module DataMapper
-  class PropertySet
-    include Assertions
-    include Enumerable
-
+  # Set of Property objects, used to associate
+  # queries with set of fields it performed over,
+  # to represent composite keys (esp. for associations)
+  # and so on.
+  class PropertySet < Array
+    extend Deprecate
+
+    deprecate :has_property?, :named?
+    deprecate :slice,         :values_at
+    deprecate :add,           :<<
+
+    # TODO: document
+    # @api semipublic
     def [](name)
-      property_for(name) || raise(ArgumentError, "Unknown property '#{name}'", caller)
+      @properties[name]
     end
 
+    alias super_slice []=
+
+    # TODO: document
+    # @api semipublic
     def []=(name, property)
-      @key, @defaults = nil
-      if existing_property = detect { |p| p.name == name }
-        property.hash
-        @entries[@entries.index(existing_property)] = property
+      if named?(name)
+        add_property(property)
+        super_slice(index(property), property)
       else
-        add(property)
+        self << property
       end
-      property
-    end
-
-    def has_property?(name)
-      !!property_for(name)
-    end
-
-    def slice(*names)
-      @key, @defaults = nil
-      names.map do |name|
-        property_for(name)
-      end
-    end
-
-    def clear
-      @key, @defaults = nil
-      @entries.clear
     end
 
-    def add(*properties)
-      @key, @defaults = nil
-      @entries.push(*properties)
-      properties.each { |property| property.hash }
-      self
+    # TODO: document
+    # @api semipublic
+    def named?(name)
+      @properties.key?(name)
     end
 
-    alias << add
-
-    def length
-      @entries.length
+    # TODO: document
+    # @api semipublic
+    def values_at(*names)
+      @properties.values_at(*names)
     end
 
-    def empty?
-      @entries.empty?
+    # TODO: document
+    # @api semipublic
+    def <<(property)
+      if named?(property.name)
+        add_property(property)
+        super_slice(index(property), property)
+      else
+        add_property(property)
+        super
+      end
     end
 
-    def each
-      @entries.each { |property| yield property }
-      self
+    # TODO: document
+    # @api semipublic
+    def include?(property)
+      named?(property.name)
     end
 
+    # TODO: make PropertySet#reject return a PropertySet instance
+    # TODO: document
+    # @api semipublic
     def defaults
-      @defaults ||= reject { |property| property.lazy? }
+      @defaults ||= self.class.new(key | [ discriminator ].compact | reject { |property| property.lazy? }).freeze
     end
 
+    # TODO: document
+    # @api semipublic
     def key
-      @key ||= select { |property| property.key? }
+      @key ||= self.class.new(select { |property| property.key? }).freeze
+    end
+
+    # TODO: document
+    # @api semipublic
+    def discriminator
+      @discriminator ||= detect { |property| property.type == Types::Discriminator }
     end
 
+    # TODO: document
+    # @api semipublic
     def indexes
       index_hash = {}
-      repository_name = repository.name
-      each { |property| parse_index(property.index, property.field(repository_name), index_hash) }
+      each { |property| parse_index(property.index, property.field, index_hash) }
       index_hash
     end
 
+    # TODO: document
+    # @api semipublic
     def unique_indexes
       index_hash = {}
-      repository_name = repository.name
-      each { |property| parse_index(property.unique_index, property.field(repository_name), index_hash) }
+      each { |property| parse_index(property.unique_index, property.field, index_hash) }
       index_hash
     end
 
+    # TODO: document
+    # @api semipublic
     def get(resource)
       map { |property| property.get(resource) }
     end
 
+    # TODO: document
+    # @api semipublic
+    def get!(resource)
+      map { |property| property.get!(resource) }
+    end
+
+    # TODO: document
+    # @api semipublic
     def set(resource, values)
-      if values.kind_of?(Array) && values.length != length
-        raise ArgumentError, "+values+ must have a length of #{length}, but has #{values.length}", caller
-      end
+      zip(values) { |property, value| property.set(resource, value) }
+    end
 
-      each_with_index { |property,i| property.set(resource, values.nil? ? nil : values[i]) }
+    # TODO: document
+    # @api semipublic
+    def set!(resource, values)
+      zip(values) { |property, value| property.set!(resource, value) }
     end
 
-    def property_contexts(name)
-      contexts = []
-      lazy_contexts.each do |context,property_names|
-        contexts << context if property_names.include?(name)
-      end
-      contexts
+    # TODO: document
+    # @api semipublic
+    def loaded?(resource)
+      all? { |property| property.loaded?(resource) }
     end
 
-    def lazy_context(name)
-      lazy_contexts[name] ||= []
+    # TODO: document
+    # @api semipublic
+    def typecast(values)
+      zip(values.nil? ? [] : values).map { |property, value| property.typecast(value) }
     end
 
-    def lazy_load_context(names)
-      if names.kind_of?(Array) && names.empty?
-        raise ArgumentError, '+names+ cannot be empty', caller
+    # TODO: document
+    # @api private
+    def property_contexts(property)
+      contexts = []
+      lazy_contexts.each do |context, properties|
+        contexts << context if properties.include?(property)
       end
+      contexts
+    end
 
-      result = []
+    # TODO: document
+    # @api private
+    def lazy_context(context)
+      lazy_contexts[context] ||= []
+    end
 
-      Array(names).each do |name|
-        contexts = property_contexts(name)
-        if contexts.empty?
-          result << name  # not lazy
+    # TODO: document
+    # @api private
+    def in_context(properties)
+      properties_in_context = properties.map do |property|
+        if (contexts = property_contexts(property)).any?
+          lazy_contexts.values_at(*contexts)
         else
-          result |= lazy_contexts.values_at(*contexts).flatten.uniq
+          property
         end
       end
-      result
-    end
 
-    def to_query(bind_values)
-      Hash[ *zip(bind_values).flatten ]
-    end
-
-    def inspect
-      '#<PropertySet:{' + map { |property| property.inspect }.join(',') + '}>'
+      properties_in_context.flatten.uniq
     end
 
     private
 
-    def initialize(properties = [])
-      assert_kind_of 'properties', properties, Enumerable
+    # TODO: document
+    # @api semipublic
+    def initialize(*)
+      super
+      @properties = map { |property| [ property.name, property ] }.to_mash
+    end
+
+    # TODO: document
+    # @api private
+    def initialize_copy(*)
+      super
+      @properties = @properties.dup
+    end
 
-      @entries = properties
-      @property_for = {}
+    # TODO: document
+    # @api private
+    def add_property(property)
+      clear_cache
+      @properties[property.name] = property
     end
 
-    def initialize_copy(orig)
-      @key, @defaults = nil
-      @entries = orig.entries.dup
-      @property_for = {}
+    # TODO: document
+    # @api private
+    def clear_cache
+      @defaults, @key, @discriminator = nil
     end
 
+    # TODO: document
+    # @api private
     def lazy_contexts
       @lazy_contexts ||= {}
     end
 
+    # TODO: document
+    # @api private
     def parse_index(index, property, index_hash)
       case index
-      when true then index_hash[property] = [property]
-      when Symbol
-        index_hash[index.to_s] ||= []
-        index_hash[index.to_s] << property
-      when Enumerable then index.each { |idx| parse_index(idx, property, index_hash) }
+        when true
+          index_hash[property] = [ property ]
+        when Symbol
+          index_hash[index] ||= []
+          index_hash[index] << property
+        when Array
+          index.each { |idx| parse_index(idx, property, index_hash) }
       end
     end
-
-    def property_for(name)
-      unless @property_for[name]
-        property = detect { |property| property.name == name.to_sym }
-        @property_for[name.to_s] = @property_for[name.to_sym] = property if property
-      end
-      @property_for[name]
-    end
-
   end # class PropertySet
 end # module DataMapper