ghost_dm-core 1.3.0.beta

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

@@ -0,0 +1,8 @@
+module DataMapper
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module DataMapper
+  module Chainable
+
+    # @api private
+    def chainable(&block)
+      mod = Module.new(&block)
+      include mod
+      mod
+    end
+
+    # @api private
+    def extendable(&block)
+      mod = Module.new(&block)
+      extend mod
+      mod
+    end
+  end # module Chainable
+end # module DataMapper

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

@@ -0,0 +1,12 @@
+module DataMapper
+  module Deprecate
+    def deprecate(old_method, new_method)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{old_method}(*args, &block)
+          warn "\#{self.class}##{old_method} is deprecated, use \#{self.class}##{new_method} instead (\#{caller.first})"
+          send(#{new_method.inspect}, *args, &block)
+        end
+      RUBY
+    end
+  end # module Deprecate
+end # module DataMapper

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

@@ -0,0 +1,89 @@
+module DataMapper
+  class DescendantSet
+    include Enumerable
+
+    # Initialize a DescendantSet instance
+    #
+    # @param [#to_ary] descendants
+    #   initialize with the descendants
+    #
+    # @api private
+    def initialize(descendants = [])
+      @descendants = SubjectSet.new(descendants)
+    end
+
+    # Copy a DescendantSet instance
+    #
+    # @param [DescendantSet] original
+    #   the original descendants
+    #
+    # @api private
+    def initialize_copy(original)
+      @descendants = @descendants.dup
+    end
+
+    # Add a descendant
+    #
+    # @param [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def <<(descendant)
+      @descendants << descendant
+      self
+    end
+
+    # Remove a descendant
+    #
+    # Also removes from all descendants
+    #
+    # @param [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def delete(descendant)
+      @descendants.delete(descendant)
+      each { |d| d.descendants.delete(descendant) }
+    end
+
+    # Iterate over each descendant
+    #
+    # @yield [descendant]
+    # @yieldparam [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def each
+      @descendants.each do |descendant|
+        yield descendant
+        descendant.descendants.each { |dd| yield dd }
+      end
+      self
+    end
+
+    # Test if there are any descendants
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def empty?
+      @descendants.empty?
+    end
+
+    # Removes all entries and returns self
+    #
+    # @return [DescendantSet] self
+    #
+    # @api private
+    def clear
+      @descendants.clear
+    end
+
+  end # class DescendantSet
+end # module DataMapper

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

@@ -0,0 +1,48 @@
+module DataMapper
+  module Equalizer
+    def equalize(*methods)
+      define_eql_method(methods)
+      define_equivalent_method(methods)
+      define_hash_method(methods)
+    end
+
+    private
+
+    def define_eql_method(methods)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def eql?(other)
+          return true if equal?(other)
+          instance_of?(other.class) &&
+          #{methods.map { |method| "#{method}.eql?(other.#{method})" }.join(' && ')}
+        end
+      RUBY
+    end
+
+    def define_equivalent_method(methods)
+      respond_to = []
+      equivalent = []
+
+      methods.each do |method|
+        respond_to << "other.respond_to?(#{method.inspect})"
+        equivalent << "#{method} == other.#{method}"
+      end
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def ==(other)
+          return true if equal?(other)
+          return false unless kind_of?(other.class) || other.kind_of?(self.class)
+          #{respond_to.join(' && ')} &&
+          #{equivalent.join(' && ')}
+        end
+      RUBY
+    end
+
+    def define_hash_method(methods)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def hash
+          self.class.hash ^ #{methods.map { |method| "#{method}.hash" }.join(' ^ ')}
+        end
+      RUBY
+    end
+  end
+end

data/lib/dm-core/support/ext/array.rb

@@ -0,0 +1,22 @@
+module DataMapper; module Ext
+  module Array
+    # Transforms an Array of key/value pairs into a {Mash}.
+    #
+    # This is a better idiom than using Mash[*array.flatten] in Ruby 1.8.6
+    # because it is not possible to limit the flattening to a single
+    # level.
+    #
+    # @param [Array] array
+    #   The array of key/value pairs to transform.
+    #
+    # @return [Mash]
+    #   A {Mash} where each entry in the Array is turned into a key/value.
+    #
+    # @api semipublic
+    def self.to_mash(array)
+      m = Mash.new
+      array.each { |k,v| m[k] = v }
+      m
+    end
+  end # class Array
+end; end

data/lib/dm-core/support/ext/blank.rb

@@ -0,0 +1,25 @@
+module DataMapper
+  module Ext
+    # Determines whether the specified +value+ is blank.
+    #
+    # An object is blank if it's false, empty, or a whitespace string.
+    # For example, "", "   ", +nil+, [], and {} are blank.
+    #
+    # @api semipublic
+    def self.blank?(value)
+      return value.blank? if value.respond_to?(:blank?)
+      case value
+      when ::NilClass, ::FalseClass
+        true
+      when ::TrueClass, ::Numeric
+        false
+      when ::Array, ::Hash
+        value.empty?
+      when ::String
+        value !~ /\S/
+      else
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+    end
+  end
+end

data/lib/dm-core/support/ext/hash.rb

@@ -0,0 +1,67 @@
+module DataMapper; module Ext
+  module Hash
+    # Creates a hash with *only* the specified key/value pairs from +hash+.
+    #
+    # @param [Hash] hash The hash from which to pick the key/value pairs.
+    # @param [Array] *keys The hash keys to include.
+    #
+    # @return [Hash] A new hash with only the selected keys.
+    #
+    # @example
+    #   hash = { :one => 1, :two => 2, :three => 3 }
+    #   Ext::Hash.only(hash, :one, :two) # => { :one => 1, :two => 2 }
+    #
+    # @api semipublic
+    def self.only(hash, *keys)
+      h = {}
+      keys.each {|k| h[k] = hash[k] if hash.has_key?(k) }
+      h
+    end
+
+    # Returns a hash that includes everything but the given +keys+.
+    #
+    # @param [Hash] hash The hash from which to pick the key/value pairs.
+    # @param [Array] *keys The hash keys to exclude.
+    #
+    # @return [Hash] A new hash without the specified keys.
+    #
+    # @example
+    #   hash = { :one => 1, :two => 2, :three => 3 }
+    #   Ext::Hash.except(hash, :one, :two) # => { :three => 3 }
+    #
+    # @api semipublic
+    def self.except(hash, *keys)
+      self.except!(hash.dup, *keys)
+    end
+
+    # Removes the specified +keys+ from the given +hash+.
+    #
+    # @param [Hash] hash The hash to modify.
+    # @param [Array] *keys The hash keys to exclude.
+    #
+    # @return [Hash] +hash+
+    #
+    # @example
+    #   hash = { :one => 1, :two => 2, :three => 3 }
+    #   Ext::Hash.except!(hash, :one, :two)
+    #   hash # => { :three => 3 }
+    #
+    # @api semipublic
+    def self.except!(hash, *keys)
+      keys.each { |key| hash.delete(key) }
+      hash
+    end
+
+    # Converts the specified +hash+ to a {Mash}.
+    #
+    # @param [Hash] hash The hash to convert.
+    # @return [Mash] The {Mash} for the specified +hash+.
+    #
+    # @api semipublic
+    def self.to_mash(hash)
+      h = Mash.new(hash)
+      h.default = hash.default
+      h
+    end
+  end
+end; end

data/lib/dm-core/support/ext/module.rb

@@ -0,0 +1,47 @@
+module DataMapper; module Ext
+  module Module
+
+    # @api semipublic
+    def self.find_const(mod, const_name)
+      if const_name[0..1] == '::'
+        DataMapper::Ext::Object.full_const_get(const_name[2..-1])
+      else
+        nested_const_lookup(mod, const_name)
+      end
+    end
+
+  private
+
+    # Doesn't do any caching since constants can change with remove_const
+    def self.nested_const_lookup(mod, const_name)
+      unless mod.equal?(::Object)
+        constants = []
+
+        mod.name.split('::').each do |part|
+          const = constants.last || ::Object
+          constants << const.const_get(part)
+        end
+
+        parts = const_name.split('::')
+
+        # from most to least specific constant, use each as a base and try
+        # to find a constant with the name const_name within them
+        constants.reverse_each do |const|
+          # return the nested constant if available
+          return const if parts.all? do |part|
+            const = if RUBY_VERSION >= '1.9.0'
+              const.const_defined?(part, false) ? const.const_get(part, false) : nil
+            else
+              const.const_defined?(part) ? const.const_get(part) : nil
+            end
+          end
+        end
+      end
+
+      # no relative constant found, fallback to an absolute lookup and
+      # use const_missing if not found
+      DataMapper::Ext::Object.full_const_get(const_name)
+    end
+
+  end
+end; end

data/lib/dm-core/support/ext/object.rb

@@ -0,0 +1,57 @@
+module DataMapper; module Ext
+  module Object
+    # Returns the value of the specified constant.
+    #
+    # @overload full_const_get(obj, name)
+    #   Returns the value of the specified constant in +obj+.
+    #   @param [Object] obj The root object used as origin.
+    #   @param [String] name The name of the constant to get, e.g. "Merb::Router".
+    #
+    # @overload full_const_get(name)
+    #   Returns the value of the fully-qualified constant.
+    #   @param [String] name The name of the constant to get, e.g. "Merb::Router".
+    #
+    # @return [Object] The constant corresponding to +name+.
+    #
+    # @api semipublic
+    def self.full_const_get(obj, name = nil)
+      obj, name = ::Object, obj if name.nil?
+
+      list = name.split("::")
+      list.shift if DataMapper::Ext.blank?(list.first)
+      list.each do |x|
+        # This is required because const_get tries to look for constants in the
+        # ancestor chain, but we only want constants that are HERE
+        obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
+      end
+      obj
+    end
+
+    # Sets the specified constant to the given +value+.
+    #
+    # @overload full_const_set(obj, name)
+    #   Sets the specified constant in +obj+ to the given +value+.
+    #   @param [Object] obj The root object used as origin.
+    #   @param [String] name The name of the constant to set, e.g. "Merb::Router".
+    #   @param [Object] value The value to assign to the constant.
+    #
+    # @overload full_const_set(name)
+    #   Sets the fully-qualified constant to the given +value+.
+    #   @param [String] name The name of the constant to set, e.g. "Merb::Router".
+    #   @param [Object] value The value to assign to the constant.
+    #
+    # @return [Object] The constant corresponding to +name+.
+    #
+    # @api semipublic
+    def self.full_const_set(obj, name, value = nil)
+      obj, name, value = ::Object, obj, name if value.nil?
+
+      list = name.split("::")
+      toplevel = DataMapper::Ext.blank?(list.first)
+      list.shift if toplevel
+      last = list.pop
+      obj = list.empty? ? ::Object : DataMapper::Ext::Object.full_const_get(list.join("::"))
+      obj.const_set(last, value) if obj && !obj.const_defined?(last)
+    end
+  end
+end; end

data/lib/dm-core/support/ext/string.rb

@@ -0,0 +1,24 @@
+module DataMapper; module Ext
+  module String
+    # Replace sequences of whitespace (including newlines) with either
+    # a single space or remove them entirely (according to param _spaced_).
+    #
+    #   compress_lines(<<QUERY)
+    #     SELECT name
+    #     FROM users
+    #   QUERY => "SELECT name FROM users"
+    #
+    # @param [String] string
+    #   The input string.
+    #
+    # @param [TrueClass, FalseClass] spaced (default=true)
+    #   Determines whether returned string has whitespace collapsed or removed.
+    #
+    # @return [String] The input string with whitespace (including newlines) replaced.
+    #
+    # @api semipublic
+    def self.compress_lines(string, spaced = true)
+      string.split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
+    end
+  end
+end; end

data/lib/dm-core/support/ext/try_dup.rb

@@ -0,0 +1,12 @@
+module DataMapper
+  module Ext
+    def self.try_dup(value)
+      case value
+      when ::TrueClass, ::FalseClass, ::NilClass, ::Module, ::Numeric, ::Symbol
+        value
+      else
+        value.dup
+      end
+    end
+  end
+end