challah 0.6.0 → 0.6.1

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/date_time/zones.rb

@@ -0,0 +1,21 @@
+require 'active_support/core_ext/time/zones'
+
+class DateTime
+  # Returns the simultaneous time in <tt>Time.zone</tt>.
+  #
+  #   Time.zone = 'Hawaii'             # => 'Hawaii'
+  #   DateTime.new(2000).in_time_zone  # => Fri, 31 Dec 1999 14:00:00 HST -10:00
+  #
+  # This method is similar to Time#localtime, except that it uses <tt>Time.zone</tt> as the local zone
+  # instead of the operating system's time zone.
+  #
+  # You can also pass in a TimeZone instance or string that identifies a TimeZone as an argument,
+  # and the conversion will be based on that zone instead of <tt>Time.zone</tt>.
+  #
+  #   DateTime.new(2000).in_time_zone('Alaska')  # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
+  def in_time_zone(zone = ::Time.zone)
+    return self unless zone
+
+    ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.find_zone!(zone))
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/enumerable.rb

@@ -0,0 +1,127 @@
+require 'active_support/ordered_hash'
+
+module Enumerable
+  # Ruby 1.8.7 introduces group_by, but the result isn't ordered. Override it.
+  remove_method(:group_by) if [].respond_to?(:group_by) && RUBY_VERSION < '1.9'
+
+  # Collect an enumerable into sets, grouped by the result of a block. Useful,
+  # for example, for grouping records by date.
+  #
+  # Example:
+  #
+  #   latest_transcripts.group_by(&:day).each do |day, transcripts|
+  #     p "#{day} -> #{transcripts.map(&:class).join(', ')}"
+  #   end
+  #   "2006-03-01 -> Transcript"
+  #   "2006-02-28 -> Transcript"
+  #   "2006-02-27 -> Transcript, Transcript"
+  #   "2006-02-26 -> Transcript, Transcript"
+  #   "2006-02-25 -> Transcript"
+  #   "2006-02-24 -> Transcript, Transcript"
+  #   "2006-02-23 -> Transcript"
+  def group_by
+    return to_enum :group_by unless block_given?
+    assoc = ActiveSupport::OrderedHash.new
+
+    each do |element|
+      key = yield(element)
+
+      if assoc.has_key?(key)
+        assoc[key] << element
+      else
+        assoc[key] = [element]
+      end
+    end
+
+    assoc
+  end unless [].respond_to?(:group_by)
+
+  # 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(0) { |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)
+    if block_given?
+      map(&block).sum(identity)
+    else
+      inject(:+) || identity
+    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)
+    return to_enum :each_with_object, memo unless block_given?
+    each do |element|
+      yield element, memo
+    end
+    memo
+  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
+    return to_enum :index_by unless block_given?
+    Hash[map { |elem| [yield(elem), elem] }]
+  end
+
+  # Returns true if the enumerable has more than 1 element. Functionally equivalent to enum.to_a.size > 1.
+  # Can be called with a block too, much like any?, so <tt>people.many? { |p| p.age > 26 }</tt> returns true if more than one person is over 26.
+  def many?
+    cnt = 0
+    if block_given?
+      any? do |element|
+        cnt += 1 if yield element
+        cnt > 1
+      end
+    else
+      any?{ (cnt += 1) > 1 }
+    end
+  end
+
+  # The negative of the <tt>Enumerable#include?</tt>. Returns true if the collection does not include the object.
+  def exclude?(object)
+    !include?(object)
+  end
+end
+
+class Range #:nodoc:
+  # Optimize range sum to use arithmetic progression if a block is not given and
+  # we have a range of numeric values.
+  def sum(identity = 0)
+    return super if block_given? || !(first.instance_of?(Integer) && last.instance_of?(Integer))
+    actual_last = exclude_end? ? (last - 1) : last
+    (actual_last - first + 1) * (actual_last + first) / 2
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/exception.rb

@@ -0,0 +1,3 @@
+module ActiveSupport
+  FrozenObjectError = RUBY_VERSION < '1.9' ? TypeError : RuntimeError
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/file/atomic.rb

@@ -0,0 +1,42 @@
+class File
+  # Write to a file atomically. Useful for situations where you don't
+  # want other processes or threads to see half-written files.
+  #
+  #   File.atomic_write("important.file") do |file|
+  #     file.write("hello")
+  #   end
+  #
+  # If your temp directory is not on the same filesystem as the file you're
+  # trying to write, you can provide a different temporary directory.
+  #
+  #   File.atomic_write("/data/something.important", "/data/tmp") do |file|
+  #     file.write("hello")
+  #   end
+  def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
+    require 'tempfile' unless defined?(Tempfile)
+    require 'fileutils' unless defined?(FileUtils)
+
+    temp_file = Tempfile.new(basename(file_name), temp_dir)
+    temp_file.binmode
+    yield temp_file
+    temp_file.close
+
+    begin
+      # Get original file permissions
+      old_stat = stat(file_name)
+    rescue Errno::ENOENT
+      # No old permissions, write a temp file to determine the defaults
+      check_name = join(dirname(file_name), ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}")
+      open(check_name, "w") { }
+      old_stat = stat(check_name)
+      unlink(check_name)
+    end
+
+    # Overwrite original file with temp file
+    FileUtils.mv(temp_file.path, file_name)
+
+    # Set correct permissions on new file
+    chown(old_stat.uid, old_stat.gid, file_name)
+    chmod(old_stat.mode, file_name)
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/file/path.rb

@@ -0,0 +1,5 @@
+class File
+  unless File.allocate.respond_to?(:to_path)
+    alias to_path path
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/file.rb

@@ -0,0 +1,2 @@
+require 'active_support/core_ext/file/atomic'
+require 'active_support/core_ext/file/path'

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/float/rounding.rb

@@ -0,0 +1,19 @@
+class Float
+  alias precisionless_round round
+  private :precisionless_round
+
+  # Rounds the float with the specified precision.
+  #
+  #   x = 1.337
+  #   x.round    # => 1
+  #   x.round(1) # => 1.3
+  #   x.round(2) # => 1.34
+  def round(precision = nil)
+    if precision
+      magnitude = 10.0 ** precision
+      (self * magnitude).round / magnitude
+    else
+      precisionless_round
+    end
+  end
+end if RUBY_VERSION < '1.9'

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/float.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/float/rounding'

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/conversions.rb

@@ -0,0 +1,157 @@
+require 'active_support/xml_mini'
+require 'active_support/time'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+
+class Hash
+  # Returns a string containing an XML representation of its receiver:
+  #
+  #   {"foo" => 1, "bar" => 2}.to_xml
+  #   # =>
+  #   # <?xml version="1.0" encoding="UTF-8"?>
+  #   # <hash>
+  #   #   <foo type="integer">1</foo>
+  #   #   <bar type="integer">2</bar>
+  #   # </hash>
+  #
+  # To do so, the method loops over the pairs and builds nodes that depend on
+  # the _values_. Given a pair +key+, +value+:
+  #
+  # * If +value+ is a hash there's a recursive call with +key+ as <tt>:root</tt>.
+  #
+  # * If +value+ is an array there's a recursive call with +key+ as <tt>:root</tt>,
+  #   and +key+ singularized as <tt>:children</tt>.
+  #
+  # * If +value+ is a callable object it must expect one or two arguments. Depending
+  #   on the arity, the callable is invoked with the +options+ hash as first argument
+  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. The 
+  #   callable can add nodes by using <tt>options[:builder]</tt>.
+  #
+  #     "foo".to_xml(lambda { |options, key| options[:builder].b(key) })
+  #     # => "<b>foo</b>"
+  #
+  # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
+  #     
+  #     class Foo
+  #       def to_xml(options)
+  #         options[:builder].bar "fooing!"
+  #       end
+  #     end
+  #          
+  #     {:foo => Foo.new}.to_xml(:skip_instruct => true)
+  #     # => "<hash><bar>fooing!</bar></hash>"
+  #
+  # * Otherwise, a node with +key+ as tag is created with a string representation of
+  #   +value+ as text node. If +value+ is +nil+ an attribute "nil" set to "true" is added.
+  #   Unless the option <tt>:skip_types</tt> exists and is true, an attribute "type" is
+  #   added as well according to the following mapping:
+  #
+  #     XML_TYPE_NAMES = {
+  #       "Symbol"     => "symbol",
+  #       "Fixnum"     => "integer",
+  #       "Bignum"     => "integer",
+  #       "BigDecimal" => "decimal",
+  #       "Float"      => "float",
+  #       "TrueClass"  => "boolean",
+  #       "FalseClass" => "boolean",
+  #       "Date"       => "date",
+  #       "DateTime"   => "datetime",
+  #       "Time"       => "datetime"
+  #     }
+  #
+  # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
+  #
+  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
+  # configure your own builder with the <tt>:builder</tt> option. The method also accepts
+  # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
+  def to_xml(options = {})
+    require 'active_support/builder' unless defined?(Builder)
+
+    options = options.dup
+    options[:indent]  ||= 2
+    options[:root]    ||= "hash"
+    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+    builder = options[:builder]
+    builder.instruct! unless options.delete(:skip_instruct)
+
+    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
+
+    builder.__send__(:method_missing, root) do
+      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
+      yield builder if block_given?
+    end
+  end
+
+  class << self
+    def from_xml(xml)
+      typecast_xml_value(unrename_keys(ActiveSupport::XmlMini.parse(xml)))
+    end
+
+    private
+      def typecast_xml_value(value)
+        case value.class.to_s
+          when 'Hash'
+            if value['type'] == 'array'
+              _, entries = Array.wrap(value.detect { |k,v| not v.is_a?(String) })
+              if entries.nil? || (c = value['__content__'] && c.blank?)
+                []
+              else
+                case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
+                when "Array"
+                  entries.collect { |v| typecast_xml_value(v) }
+                when "Hash"
+                  [typecast_xml_value(entries)]
+                else
+                  raise "can't typecast #{entries.inspect}"
+                end
+              end
+            elsif value['type'] == 'file' || 
+               (value["__content__"] && (value.keys.size == 1 || value["__content__"].present?))
+              content = value["__content__"]
+              if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
+                parser.arity == 1 ? parser.call(content) : parser.call(content, value)
+              else
+                content
+              end
+            elsif value['type'] == 'string' && value['nil'] != 'true'
+              ""
+            # blank or nil parsed values are represented by nil
+            elsif value.blank? || value['nil'] == 'true'
+              nil
+            # If the type is the only element which makes it then
+            # this still makes the value nil, except if type is
+            # a XML node(where type['value'] is a Hash)
+            elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
+              nil
+            else
+              xml_value = Hash[value.map { |k,v| [k, typecast_xml_value(v)] }]
+
+              # Turn { :files => { :file => #<StringIO> } into { :files => #<StringIO> } so it is compatible with
+              # how multipart uploaded files from HTML appear
+              xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
+            end
+          when 'Array'
+            value.map! { |i| typecast_xml_value(i) }
+            value.length > 1 ? value : value.first
+          when 'String'
+            value
+          else
+            raise "can't typecast #{value.class.name} - #{value.inspect}"
+        end
+      end
+
+      def unrename_keys(params)
+        case params.class.to_s
+          when "Hash"
+            Hash[params.map { |k,v| [k.to_s.tr("-", "_"), unrename_keys(v)] } ]
+          when "Array"
+            params.map { |v| unrename_keys(v) }
+          else
+            params
+        end
+      end
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/deep_dup.rb

@@ -0,0 +1,18 @@
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { :a => { :b => 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] #=> nil
+  #   dup[:a][:c]  #=> "c"
+  def deep_dup
+    duplicate = self.dup
+    duplicate.each_pair do |k,v|
+      tv = duplicate[k]
+      duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
+    end
+    duplicate
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/deep_merge.rb

@@ -0,0 +1,21 @@
+class Hash
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = {:x => {:y => [4,5,6]}, :z => [7,8,9]}
+  #   h2 = {:x => {:y => [7,8,9]}, :z => "xyz"}
+  #
+  #   h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" }
+  #   h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }
+  def deep_merge(other_hash)
+    dup.deep_merge!(other_hash)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash)
+    other_hash.each_pair do |k,v|
+      tv = self[k]
+      self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+    end
+    self
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/diff.rb

@@ -0,0 +1,13 @@
+class Hash
+  # Returns a hash that represents the difference between two hashes.
+  #
+  # Examples:
+  #
+  #   {1 => 2}.diff(1 => 2)         # => {}
+  #   {1 => 2}.diff(1 => 3)         # => {1 => 2}
+  #   {}.diff(1 => 2)               # => {1 => 2}
+  #   {1 => 2, 3 => 4}.diff(1 => 2) # => {3 => 4}
+  def diff(h2)
+    dup.delete_if { |k, v| h2[k] == v }.merge!(h2.dup.delete_if { |k, v| has_key?(k) })
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/except.rb

@@ -0,0 +1,23 @@
+class Hash
+  # Return a hash that includes everything but the given keys. This is useful for
+  # limiting a set of parameters to everything but a few known toggles:
+  #
+  #   @person.update_attributes(params[:person].except(:admin))
+  #
+  # If the receiver responds to +convert_key+, the method is called on each of the
+  # arguments. This allows +except+ to play nice with hashes with indifferent access
+  # for instance:
+  #
+  #   {:a => 1}.with_indifferent_access.except(:a)  # => {}
+  #   {:a => 1}.with_indifferent_access.except("a") # => {}
+  #
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/indifferent_access.rb

@@ -0,0 +1,24 @@
+require 'active_support/hash_with_indifferent_access'
+
+class Hash
+
+  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
+  #
+  #   {:a => 1}.with_indifferent_access["a"] # => 1
+  #
+  def with_indifferent_access
+    ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self)
+  end
+
+  # Called when object is nested under an object that receives
+  # #with_indifferent_access. This method will be called on the current object
+  # by the enclosing object and is aliased to #with_indifferent_access by
+  # default. Subclasses of Hash may overwrite this method to return +self+ if
+  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
+  # desirable.
+  #
+  #   b = {:b => 1}
+  #   {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
+  #
+  alias nested_under_indifferent_access with_indifferent_access
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/keys.rb

@@ -0,0 +1,54 @@
+class Hash
+  # Return a new hash with all keys converted to strings.
+  #
+  #   { :name => 'Rob', :years => '28' }.stringify_keys
+  #   #=> { "name" => "Rob", "years" => "28" }
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  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, as long as
+  # they respond to +to_sym+.
+  #
+  #   { 'name' => 'Rob', 'years' => '28' }.symbolize_keys
+  #   #=> { :name => "Rob", :years => "28" }
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  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: years"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key: name"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      raise(ArgumentError, "Unknown key: #{k}") unless valid_keys.include?(k)
+    end
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/reverse_merge.rb

@@ -0,0 +1,23 @@
+class Hash
+  # Merges the caller into +other_hash+. For example,
+  #
+  #   options = options.reverse_merge(:size => 25, :velocity => 10)
+  #
+  # is equivalent to
+  #
+  #   options = {:size => 25, :velocity => 10}.merge(options)
+  #
+  # This is particularly useful for initializing an options hash
+  # with default values.
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+
+  # Destructive +reverse_merge+.
+  def reverse_merge!(other_hash)
+    # right wins if there is no left
+    merge!( other_hash ){|key,left,right| left }
+  end
+
+  alias_method :reverse_update, :reverse_merge!
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash/slice.rb

@@ -0,0 +1,40 @@
+class Hash
+  # Slice a hash to include only the given keys. This is useful for
+  # limiting an options hash to valid keys before passing to a method:
+  #
+  #   def search(criteria = {})
+  #     assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.slice(:mass, :velocity, :time))
+  #
+  # If you have an array of keys you want to limit to, you should splat them:
+  #
+  #   valid_keys = [:mass, :velocity, :time]
+  #   search(options.slice(*valid_keys))
+  def slice(*keys)
+    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end
+
+  # Replaces the hash with only the given keys.
+  # Returns a hash contained the removed key/value pairs
+  #   {:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d => 4}
+  def slice!(*keys)
+    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    replace(hash)
+    omit
+  end
+
+  # Removes and returns the key/value pairs matching the given keys.
+  #   {:a => 1, :b => 2, :c => 3, :d => 4}.extract!(:a, :b) # => {:a => 1, :b => 2}
+  def extract!(*keys)
+    result = {}
+    keys.each {|key| result[key] = delete(key) }
+    result
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/hash.rb

@@ -0,0 +1,9 @@
+require 'active_support/core_ext/hash/conversions'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/deep_dup'
+require 'active_support/core_ext/hash/diff'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/hash/slice'

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/integer/inflections.rb

@@ -0,0 +1,17 @@
+require 'active_support/inflector'
+
+class Integer
+  # Ordinalize turns a number into an ordinal string used to denote the
+  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  #  1.ordinalize     # => "1st"
+  #  2.ordinalize     # => "2nd"
+  #  1002.ordinalize  # => "1002nd"
+  #  1003.ordinalize  # => "1003rd"
+  #  -11.ordinalize   # => "-11th"
+  #  -1001.ordinalize # => "-1001st"
+  #
+  def ordinalize
+    ActiveSupport::Inflector.ordinalize(self)
+  end
+end

data/vendor/bundle/gems/activesupport-3.2.5/lib/active_support/core_ext/integer/multiple.rb

@@ -0,0 +1,10 @@
+class Integer
+  # Check whether the integer is evenly divisible by the argument.
+  #
+  #   0.multiple_of?(0)  #=> true
+  #   6.multiple_of?(5)  #=> false
+  #   10.multiple_of?(2) #=> true
+  def multiple_of?(number)
+    number != 0 ? self % number == 0 : zero?
+  end
+end