sbf-dm-core 1.3.0.beta

data/lib/dm-core/support/mash.rb

@@ -0,0 +1,176 @@
+module DataMapper
+  # This class has dubious semantics and we only have it so that people can write
+  # params[:key] instead of params['key'].
+  class Mash < Hash
+
+    # Initializes a new mash.
+    #
+    # @param [Hash, Object] constructor
+    #   The default value for the mash. If +constructor+ is a Hash, a new mash
+    #   will be created based on the keys of the hash and no default value will
+    #   be set.
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    # Gets the default value for the mash.
+    #
+    # @param [Object] key
+    #   The default value for the mash. If +key+ is a Symbol and it is a key in
+    #   the mash, then the default value will be set to the value matching the
+    #   key.
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Sets the +value+ associated with the specified +key+.
+    #
+    # @param [Object] key The key to set.
+    # @param [Object] value The value to set the key to.
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the mash with the key/value pairs from the specified hash.
+    #
+    # @param [Hash] other_hash
+    #   A hash to update values in the mash with. The keys and the values will be
+    #   converted to Mash format.
+    #
+    # @return [Mash] The updated mash.
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Determines whether the mash contains the specified +key+.
+    #
+    # @param [Object] key The key to check for.
+    # @return [Boolean] True if the key exists in the mash.
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # @param [Object] key The key to fetch.
+    # @param [Array] *extras Default value.
+    #
+    # @return [Object] The value at key or the default value.
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # @param [Array] *indices
+    #   The keys to retrieve values for.
+    #
+    # @return [Array] The values at each of the provided keys.
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # @param [Hash] hash The hash to merge with the mash.
+    #
+    # @return [Mash] A new mash with the hash values merged in.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # @param [Object] key The key to delete from the mash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    # Returns a mash that includes everything but the given +keys+.
+    #
+    # @param [Array<String, Symbol>] *keys The mash keys to exclude.
+    #
+    # @return [Mash] A new mash without the selected keys.
+    #
+    # @example
+    #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+    #     #=> { "two" => 2, "three" => 3 }
+    def except(*keys)
+      self.dup.except!(*keys.map {|k| convert_key(k)})
+    end
+
+    # Removes the specified +keys+ from the mash.
+    #
+    # @param [Array] *keys The mash keys to exclude.
+    #
+    # @return [Hash] +hash+
+    #
+    # @example
+    #   mash = { :one => 1, :two => 2, :three => 3 }
+    #   mash.except!(:one, :two)
+    #   mash # => { :three => 3 }
+    def except!(*keys)
+      keys.each { |key| delete(key) }
+      self
+    end
+
+    # Used to provide the same interface as Hash.
+    #
+    # @return [Mash] This mash unchanged.
+    def stringify_keys!; self end
+
+    # @return [Hash] The mash as a Hash with symbolized keys.
+    def symbolize_keys
+      h = Hash.new(default)
+      each { |key, val| h[key.to_sym] = val }
+      h
+    end
+
+    # @return [Hash] The mash as a Hash with string keys.
+    def to_hash
+      Hash.new(default).replace(self)
+    end
+
+    protected
+    # @param [Object] key The key to convert.
+    #
+    # @param [Object]
+    #   The converted key. If the key was a symbol, it will be converted to a
+    #   string.
+    #
+    # @api private
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    # @param [Object] value The value to convert.
+    #
+    # @return [Object]
+    #   The converted value. A Hash or an Array of hashes, will be converted to
+    #   their Mash equivalents.
+    #
+    # @api private
+    def convert_value(value)
+      if value.class == Hash
+         mash = Mash.new(value)
+         mash.default = value.default
+         mash
+      elsif value.is_a?(Array)
+        value.collect { |e| convert_value(e) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/dm-core/support/naming_conventions.rb

@@ -0,0 +1,109 @@
+module DataMapper
+
+  # Use these modules to establish naming conventions.
+  # The default is UnderscoredAndPluralized.
+  # You assign a naming convention like so:
+  #
+  #   repository(:default).adapter.resource_naming_convention = NamingConventions::Resource::Underscored
+  #
+  # You can also easily assign a custom convention with a Proc:
+  #
+  #   repository(:default).adapter.resource_naming_convention = lambda do |value|
+  #     'tbl' + value.camelize(true)
+  #   end
+  #
+  # Or by simply defining your own module in NamingConventions that responds to
+  # ::call.
+  #
+  # NOTE: It's important to set the convention before accessing your models
+  # since the resource_names are cached after first accessed.
+  # DataMapper.setup(name, uri) returns the Adapter for convenience, so you can
+  # use code like this:
+  #
+  #   adapter = DataMapper.setup(:default, 'mock://127.0.0.1/mock')
+  #   adapter.resource_naming_convention = NamingConventions::Resource::Underscored
+  module NamingConventions
+
+    module Resource
+
+      module UnderscoredAndPluralized
+        def self.call(name)
+          DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(name)).gsub('/', '_')
+        end
+      end # module UnderscoredAndPluralized
+
+      module UnderscoredAndPluralizedWithoutModule
+        def self.call(name)
+          DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(DataMapper::Inflector.demodulize(name)))
+        end
+      end # module UnderscoredAndPluralizedWithoutModule
+
+      module UnderscoredAndPluralizedWithoutLeadingModule
+        def self.call(name)
+          UnderscoredAndPluralized.call(name.to_s.gsub(/^[^:]*::/,''))
+        end
+      end
+
+      module Underscored
+        def self.call(name)
+          DataMapper::Inflector.underscore(name)
+        end
+      end # module Underscored
+
+      module Yaml
+        def self.call(name)
+          "#{DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(name))}.yaml"
+        end
+      end # module Yaml
+
+    end # module Resource
+
+    module Field
+
+      module UnderscoredAndPluralized
+        def self.call(property)
+          DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(property.name.to_s)).gsub('/', '_')
+        end
+      end # module UnderscoredAndPluralized
+
+      module UnderscoredAndPluralizedWithoutModule
+        def self.call(property)
+          DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(DataMapper::Inflector.demodulize(property.name.to_s)))
+        end
+      end # module UnderscoredAndPluralizedWithoutModule
+
+      module Underscored
+        def self.call(property)
+          DataMapper::Inflector.underscore(property.name.to_s)
+        end
+      end # module Underscored
+
+      module FQN
+        def self.call(property)
+          model, name = property.model, property.name
+
+          fk_names = model.relationships.inject([]) { |names, rel|
+            if rel.respond_to?(:required?)
+              names + rel.source_key.map(&:name)
+            else
+              names
+            end
+          }
+
+          return name.to_s if fk_names.include?(name)
+
+          storage_name = model.storage_name(property.repository_name)
+          "#{DataMapper::Inflector.singularize(storage_name)}_#{name}"
+        end
+      end # module FQN
+
+      module Yaml
+        def self.call(property)
+          "#{DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(property.name.to_s))}.yaml"
+        end
+      end # module Yaml
+
+    end # module Field
+
+  end # module NamingConventions
+end # module DataMapper

data/lib/dm-core/support/ordered_set.rb

@@ -0,0 +1,381 @@
+module DataMapper
+
+  # An ordered set of things
+  #
+  # {OrderedSet} implements set behavior and keeps
+  # track of the order in which entries were added.
+  #
+  # {OrderedSet} allows to inject a class that implements
+  # {OrderedSet::Cache::API} at construction time, and will
+  # use that cache implementation to enforce set semantics
+  # and perform internal caching of insertion order.
+  #
+  # @see OrderedSet::Cache::API
+  # @see OrderedSet::Cache
+  # @see SubjectSet::NameCache
+  #
+  # @api private
+  class OrderedSet
+
+    # The default cache used by {OrderedSet}
+    #
+    # Uses a {Hash} as internal storage and enforces set semantics
+    # by calling #eql? and #hash on the set's entries.
+    #
+    # @api private
+    class Cache
+
+      # The default implementation of the {API} that {OrderedSet} expects from
+      # the cache object that it uses to
+      #
+      #     1. keep track of insertion order
+      #     2. enforce set semantics.
+      #
+      # Classes including {API} must customize the behavior of the cache in 2 ways:
+      #
+      # They must determine the value to use as cache key and thus set discriminator,
+      # by implementing the {#key_for} method. The {#key_for} method accepts an arbitrary
+      # object as param and the method is free to return whatever value from that method.
+      # Obviously this will most likely be some attribute or value otherwise derived from
+      # the object that got passed in.
+      #
+      # They must determine which objects are valid set entries by overwriting the
+      # {#valid?} method. The {#valid?} method accepts an arbitrary object as param and
+      # the overwriting method must return either true or false.
+      #
+      # The motivation behind this is that set semantics cannot always be enforced
+      # by calling {#eql?} and {#hash} on the set's entries. For example, two entries
+      # might be considered unique wrt the set if their names are the same, but other
+      # internal state differs. This is exactly the case for {DataMapper::Property} and
+      # {DataMapper::Associations::Relationship} objects.
+      #
+      # @see DataMapper::SubjectSet::NameCache
+      #
+      # @api private
+      module API
+
+        # Initialize a new Cache
+        #
+        # @api private
+        def initialize
+          @cache = {}
+        end
+
+        # Tests if the given entry qualifies to be added to the cache
+        #
+        # @param [Object] entry
+        #   the entry to be checked
+        #
+        # @return [Boolean]
+        #   true if the entry qualifies to be added to the cache
+        #
+        # @api private
+        def valid?(entry)
+          raise NotImplementedError, "#{self}#valid? must be implemented"
+        end
+
+        # Given an entry, return the key to be used in the cache
+        #
+        # @param [Object] entry
+        #   the entry to get the key for
+        #
+        # @return [Object, nil]
+        #   a value derived from the entry that is used as key in the cache
+        #
+        # @api private
+        def key_for(entry)
+          raise NotImplementedError, "#{self}#key_for must be implemented"
+        end
+
+        # Check if the entry exists in the cache
+        #
+        # @param [Object] entry
+        #   the entry to test for
+        #
+        # @return [Boolean]
+        #   true if entry is included in the cache
+        #
+        # @api private
+        def include?(entry)
+          @cache.has_key?(key_for(entry))
+        end
+
+        # Return the index for the entry in the cache
+        #
+        # @param [Object] entry
+        #   the entry to get the index for
+        #
+        # @return [Integer, nil]
+        #   the index for the entry, or nil if it does not exist
+        #
+        # @api private
+        def [](entry)
+          @cache[key_for(entry)]
+        end
+
+        # Set the index for the entry in the cache
+        #
+        # @param [Object] entry
+        #   the entry to set the index for
+        # @param [Integer] index
+        #   the index to assign to the given entry
+        #
+        # @return [Integer]
+        #   the given index for the entry
+        #
+        # @api private
+        def []=(entry, index)
+          if valid?(entry)
+            @cache[key_for(entry)] = index
+          end
+        end
+
+        # Delete an entry from the cache
+        #
+        # @param [Object] entry
+        #   the entry to delete from the cache
+        #
+        # @return [API] self
+        #
+        # @api private
+        def delete(entry)
+          deleted_index = @cache.delete(key_for(entry))
+          if deleted_index
+            @cache.each do |key, index|
+              @cache[key] -= 1 if index > deleted_index
+            end
+          end
+          deleted_index
+        end
+
+        # Removes all entries and returns self
+        #
+        # @return [API] self
+        #
+        # @api private
+        def clear
+          @cache.clear
+          self
+        end
+
+      end # module API
+
+      include API
+
+      # Tests if the given entry qualifies to be added to the cache
+      #
+      # @param [Object] entry
+      #   the entry to be checked
+      #
+      # @return [true] true
+      #
+      # @api private
+      def valid?(entry)
+        true
+      end
+
+      # Given an entry, return the key to be used in the cache
+      #
+      # @param [Object] entry
+      #   the entry to get the key for
+      #
+      # @return [Object]
+      #   the passed in entry
+      #
+      # @api private
+      def key_for(entry)
+        entry
+      end
+
+    end # class Cache
+
+    include Enumerable
+    extend  Equalizer
+
+    # This set's entries
+    #
+    # The order in this Array is not guaranteed
+    # to be the order in which the entries were
+    # inserted. Use #each to access the entries
+    # in insertion order.
+    #
+    # @return [Array]
+    #  this set's entries
+    #
+    # @api private
+    attr_reader :entries
+
+    equalize :entries
+
+    # Initialize an OrderedSet
+    #
+    # @param [#each] entries
+    #   the entries to initialize this set with
+    # @param [Class<Cache::API>] cache
+    #   the cache implementation to use
+    #
+    # @api private
+    def initialize(entries = [], cache = Cache)
+      @cache   = cache.new
+      @entries = []
+      merge(entries.to_ary)
+    end
+
+    # Initialize a copy of OrderedSet
+    #
+    # @api private
+    def initialize_copy(*)
+      @cache   = @cache.dup
+      @entries = @entries.dup
+    end
+
+    # Get the entry at the given index
+    #
+    # @param [Integer] index
+    #   the index of the desired entry
+    #
+    # @return [Object, nil]
+    #   the entry at the given index, or nil if no entry is present
+    #
+    # @api private
+    def [](index)
+      entries[index]
+    end
+
+    # Add or update an entry in the set
+    #
+    # If the entry to add isn't part of the set already,
+    # it will be added. If an entry with the same cache
+    # key as the entry to add is part of the set already,
+    # it will be replaced with the given entry.
+    #
+    # @param [Object] entry
+    #   the entry to be added
+    #
+    # @return [OrderedSet] self
+    #
+    # @api private
+    def <<(entry)
+      if index = @cache[entry]
+        entries[index] = entry
+      else
+        @cache[entry] = size
+        entries << entry
+      end
+      self
+    end
+
+    # Merge with another Enumerable object
+    #
+    # @param [#each] other
+    #   the Enumerable to merge with this OrderedSet
+    #
+    # @return [OrderedSet] self
+    #
+    # @api private
+    def merge(other)
+      other.each { |entry| self << entry }
+      self
+    end
+
+    # Delete an entry from this OrderedSet
+    #
+    # @param [Object] entry
+    #   the entry to delete
+    #
+    # @return [Object, nil]
+    #   the deleted entry or nil
+    #
+    # @api private
+    def delete(entry)
+      if index = @cache.delete(entry)
+        entries.delete_at(index)
+      end
+    end
+
+    # Removes all entries and returns self
+    #
+    # @return [OrderedSet] self
+    #
+    # @api private
+    def clear
+      @cache.clear
+      entries.clear
+      self
+    end
+
+    # Iterate over each entry in the set
+    #
+    # @yield [entry]
+    #   all entries in the set
+    #
+    # @yieldparam [Object] entry
+    #   an entry in the set
+    #
+    # @return [OrderedSet] self
+    #
+    # @api private
+    def each
+      return to_enum unless block_given?
+      entries.each { |entry| yield(entry) }
+      self
+    end
+
+    # The number of entries
+    #
+    # @return [Integer]
+    #   the number of entries
+    #
+    # @api private
+    def size
+      entries.size
+    end
+
+    # Check if there are any entries
+    #
+    # @return [Boolean]
+    #   true if the set is empty
+    #
+    # @api private
+    def empty?
+      entries.empty?
+    end
+
+    # Check if the entry exists in the set
+    #
+    # @param [Object] entry
+    #   the entry to test for
+    #
+    # @return [Boolean]
+    #   true if entry is included in the set
+    #
+    # @api private
+    def include?(entry)
+      entries.include?(entry)
+    end
+
+    # Return the index for the entry in the set
+    #
+    # @param [Object] entry
+    #   the entry to check the set for
+    #
+    # @return [Integer, nil]
+    #   the index for the entry, or nil if it does not exist
+    #
+    # @api private
+    def index(entry)
+      @cache[entry]
+    end
+
+    # Convert the OrderedSet into an Array
+    #
+    # @return [Array]
+    #   an array containing all the OrderedSet's entries
+    #
+    # @api private
+    def to_ary
+      entries
+    end
+
+  end # class OrderedSet
+end # module DataMapper

data/lib/dm-core/support/subject.rb

@@ -0,0 +1,33 @@
+module DataMapper
+  module Subject
+    # Returns a default value of the subject for given resource
+    #
+    # When default value is a callable object, it is called with resource
+    # and subject passed as arguments.
+    #
+    # @param [Resource] resource
+    #   the model instance for which the default is to be set
+    #
+    # @return [Object]
+    #   the default value of this subject for +resource+
+    #
+    # @api semipublic
+    def default_for(resource)
+      if @default.respond_to?(:call)
+        @default.call(resource, self)
+      else
+        DataMapper::Ext.try_dup(@default)
+      end
+    end
+
+    # Returns true if the subject has a default value
+    #
+    # @return [Boolean]
+    #   true if the subject has a default value
+    #
+    # @api semipublic
+    def default?
+      @options.key?(:default)
+    end
+  end
+end