ant-mapper 0.0.2

data/lib/ant_support/core_ext/class/inheritable_attributes.rb

@@ -0,0 +1,140 @@
+# Retain for backward compatibility.  Methods are now included in Class.
+module ClassInheritableAttributes # :nodoc:
+end
+
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => value.duplicable? ? value.dup : value)
+        end
+      end
+
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end

data/lib/ant_support/core_ext/class/removal.rb

@@ -0,0 +1,50 @@
+class Class #:nodoc:
+  
+  # Unassociates the class with its subclasses and removes the subclasses
+  # themselves.
+  #
+  #   Integer.remove_subclasses # => [Bignum, Fixnum]
+  #   Fixnum                    # => NameError: uninitialized constant Fixnum
+  def remove_subclasses
+    Object.remove_subclasses_of(self)
+  end
+
+  # Returns an array with the names of the subclasses of +self+ as strings.
+  #
+  #   Integer.subclasses # => ["Bignum", "Fixnum"]
+  def subclasses
+    Object.subclasses_of(self).map { |o| o.to_s }
+  end
+
+  # Removes the classes in +klasses+ from their parent module.
+  #
+  # Ordinary classes belong to some module via a constant. This method computes
+  # that constant name from the class name and removes it from the module it
+  # belongs to.
+  #
+  #   Object.remove_class(Integer) # => [Integer]
+  #   Integer                      # => NameError: uninitialized constant Integer
+  #
+  # Take into account that in general the class object could be still stored
+  # somewhere else.
+  #
+  #   i = Integer                  # => Integer
+  #   Object.remove_class(Integer) # => [Integer]
+  #   Integer                      # => NameError: uninitialized constant Integer
+  #   i.subclasses                 # => ["Bignum", "Fixnum"]
+  #   Fixnum.superclass            # => Integer
+  def remove_class(*klasses)
+    klasses.flatten.each do |klass|
+      # Skip this class if there is nothing bound to this name
+      next unless defined?(klass.name)
+      
+      basename = klass.to_s.split("::").last
+      parent = klass.parent
+      
+      # Skip this class if it does not match the current one bound to this name
+      next unless parent.const_defined?(basename) && klass = parent.const_get(basename)
+
+      parent.instance_eval { remove_const basename } unless parent == klass
+    end
+  end
+end

data/lib/ant_support/core_ext/duplicable.rb

@@ -0,0 +1,43 @@
+class Object
+  # Can you safely .dup this object?
+  # False for nil, false, true, symbols, and numbers; true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Symbol #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Numeric #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Class #:nodoc:
+  def duplicable?
+    false
+  end
+end

data/lib/ant_support/core_ext/enumerable.rb

@@ -0,0 +1,72 @@
+module Enumerable
+
+  # Calculates a sum from the elements. Examples:
+  #
+  #  payments.sum { |p| p.price * p.tax_rate }
+  #  payments.sum(&:price)
+  #
+  # The latter is a shortcut for:
+  #
+  #  payments.inject { |sum, p| sum + p.price }
+  #
+  # It can also calculate the sum without the use of a block.
+  #
+  #  [5, 15, 10].sum # => 30
+  #  ["foo", "bar"].sum # => "foobar"
+  #  [[1, 2], [3, 1, 5]].sum => [1, 2, 3, 1, 5]
+  #
+  # The default sum of an empty list is zero. You can override this default:
+  #
+  #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
+  #
+  def sum(identity = 0, &block)
+    return identity unless size > 0
+
+    if block_given?
+      map(&block).sum
+    else
+      inject { |sum, element| sum + element }
+    end
+  end
+
+  # Iterates over a collection, passing the current element *and* the
+  # +memo+ to the block. Handy for building up hashes or
+  # reducing collections down to one object. Examples:
+  #
+  #   %w(foo bar).each_with_object({}) { |str, hsh| hsh[str] = str.upcase } #=> {'foo' => 'FOO', 'bar' => 'BAR'}
+  #
+  # *Note* that you can't use immutable objects like numbers, true or false as
+  # the memo. You would think the following returns 120, but since the memo is
+  # never changed, it does not.
+  #
+  #   (1..5).each_with_object(1) { |value, memo| memo *= value } # => 1
+  #
+  def each_with_object(memo, &block)
+    returning memo do |m|
+      each do |element|
+        block.call(element, m)
+      end
+    end
+  end unless [].respond_to?(:each_with_object)
+
+  # Convert an enumerable to a hash. Examples:
+  #
+  #   people.index_by(&:login)
+  #     => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
+  #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
+  #
+  def index_by
+    inject({}) do |accum, elem|
+      accum[yield(elem)] = elem
+      accum
+    end
+  end
+
+  # Returns true if the collection has more than 1 element. Functionally equivalent to collection.size > 1.
+  # Works with a block too ala any?, so people.many? { |p| p.age > 26 } # => returns true if more than 1 person is over 26.
+  def many?(&block)
+    size = block_given? ? select(&block).size : self.size
+    size > 1
+  end
+end

data/lib/ant_support/core_ext/hash.rb

@@ -0,0 +1,6 @@
+require "ant_support/core_ext/hash/keys"
+
+
+class Hash #:nodoc:
+  include AntSupport::CoreExtensions::Hash::Keys
+end

data/lib/ant_support/core_ext/hash/keys.rb

@@ -0,0 +1,52 @@
+module AntSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Keys
+        # Return a new hash with all keys converted to strings.
+        def stringify_keys
+          inject({}) do |options, (key, value)|
+            options[key.to_s] = value
+            options
+          end
+        end
+
+        # Destructively convert all keys to strings.
+        def stringify_keys!
+          keys.each do |key|
+            self[key.to_s] = delete(key)
+          end
+          self
+        end
+
+        # Return a new hash with all keys converted to symbols.
+        def symbolize_keys
+          inject({}) do |options, (key, value)|
+            options[(key.to_sym rescue key) || key] = value
+            options
+          end
+        end
+
+        # Destructively convert all keys to symbols.
+        def symbolize_keys!
+          self.replace(self.symbolize_keys)
+        end
+
+        alias_method :to_options,  :symbolize_keys
+        alias_method :to_options!, :symbolize_keys!
+
+        # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+        # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+        # as keys, this will fail.
+        #
+        # ==== Examples:
+        #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+        #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+        #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+        def assert_valid_keys(*valid_keys)
+          unknown_keys = keys - [valid_keys].flatten
+          raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+        end
+      end
+    end
+  end
+end

data/lib/ant_support/core_ext/module.rb

@@ -0,0 +1,16 @@
+require 'ant_support/core_ext/module/attribute_accessors'
+require 'ant_support/core_ext/module/attr_accessor_with_default'
+require 'ant_support/core_ext/module/aliasing'
+
+module AntSupport
+  module CoreExtensions
+    # Various extensions for the Ruby core Module class.
+    module Module
+      # Nothing here. Only defined for API documentation purposes.
+    end
+  end
+end
+
+class Module
+  include AntSupport::CoreExtensions::Module
+end

data/lib/ant_support/core_ext/module/aliasing.rb

@@ -0,0 +1,74 @@
+module AntSupport
+  module CoreExtensions
+    module Module
+      # Encapsulates the common pattern of:
+      #
+      #   alias_method :foo_without_feature, :foo
+      #   alias_method :foo, :foo_with_feature
+      #
+      # With this, you simply do:
+      #
+      #   alias_method_chain :foo, :feature
+      #
+      # And both aliases are set up for you.
+      #
+      # Query and bang methods (foo?, foo!) keep the same punctuation:
+      #
+      #   alias_method_chain :foo?, :feature
+      #
+      # is equivalent to
+      #
+      #   alias_method :foo_without_feature?, :foo?
+      #   alias_method :foo?, :foo_with_feature?
+      #
+      # so you can safely chain foo, foo?, and foo! with the same feature.
+      def alias_method_chain(target, feature)
+        # Strip out punctuation on predicates or bang methods since
+        # e.g. target?_without_feature is not a valid method name.
+        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+        yield(aliased_target, punctuation) if block_given?
+
+        with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+        alias_method without_method, target
+        alias_method target, with_method
+
+        case
+          when public_method_defined?(without_method)
+            public target
+          when protected_method_defined?(without_method)
+            protected target
+          when private_method_defined?(without_method)
+            private target
+        end
+      end
+
+      # Allows you to make aliases for attributes, which includes
+      # getter, setter, and query methods.
+      #
+      # Example:
+      #
+      #   class Content < AntMapper::Base
+      #     # has a title attribute
+      #   end
+      #
+      #   class Email < Content
+      #     alias_attribute :subject, :title
+      #   end
+      #
+      #   e = Email.find(1)
+      #   e.title    # => "Superstars"
+      #   e.subject  # => "Superstars"
+      #   e.subject? # => true
+      #   e.subject = "Megastars"
+      #   e.title    # => "Megastars"
+      def alias_attribute(new_name, old_name)
+        module_eval <<-STR, __FILE__, __LINE__+1
+          def #{new_name}; self.#{old_name}; end
+          def #{new_name}?; self.#{old_name}?; end
+          def #{new_name}=(v); self.#{old_name} = v; end
+        STR
+      end
+    end
+  end
+end