usher 0.6.8 → 0.7.0

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash/conversions.rb

@@ -0,0 +1,259 @@
+require 'date'
+require 'cgi'
+require 'builder'
+require 'xmlsimple'
+
+# Locked down XmlSimple#xml_in_string
+class XmlSimple
+  # Same as xml_in but doesn't try to smartly shoot itself in the foot.
+  def xml_in_string(string, options = nil)
+    handle_options('in', options)
+
+    @doc = parse(string)
+    result = collapse(@doc.root)
+
+    if @options['keeproot']
+      merge({}, @doc.root.name, result)
+    else
+      result
+    end
+  end
+
+  def self.xml_in_string(string, options = nil)
+    new.xml_in_string(string, options)
+  end
+end
+
+# This module exists to decorate files deserialized using Hash.from_xml with
+# the <tt>original_filename</tt> and <tt>content_type</tt> methods.
+module FileLike #:nodoc:
+  attr_writer :original_filename, :content_type
+
+  def original_filename
+    @original_filename || 'untitled'
+  end
+
+  def content_type
+    @content_type || 'application/octet-stream'
+  end
+end
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Conversions
+
+        XML_TYPE_NAMES = {
+          "Symbol"     => "symbol",
+          "Fixnum"     => "integer",
+          "Bignum"     => "integer",
+          "BigDecimal" => "decimal",
+          "Float"      => "float",
+          "Date"       => "date",
+          "DateTime"   => "datetime",
+          "Time"       => "datetime",
+          "TrueClass"  => "boolean",
+          "FalseClass" => "boolean"
+        } unless defined?(XML_TYPE_NAMES)
+
+        XML_FORMATTING = {
+          "symbol"   => Proc.new { |symbol| symbol.to_s },
+          "date"     => Proc.new { |date| date.to_s(:db) },
+          "datetime" => Proc.new { |time| time.xmlschema },
+          "binary"   => Proc.new { |binary| ActiveSupport::Base64.encode64(binary) },
+          "yaml"     => Proc.new { |yaml| yaml.to_yaml }
+        } unless defined?(XML_FORMATTING)
+
+        # TODO: use Time.xmlschema instead of Time.parse;
+        #       use regexp instead of Date.parse
+        unless defined?(XML_PARSING)
+          XML_PARSING = {
+            "symbol"       => Proc.new  { |symbol|  symbol.to_sym },
+            "date"         => Proc.new  { |date|    ::Date.parse(date) },
+            "datetime"     => Proc.new  { |time|    ::Time.parse(time).utc rescue ::DateTime.parse(time).utc },
+            "integer"      => Proc.new  { |integer| integer.to_i },
+            "float"        => Proc.new  { |float|   float.to_f },
+            "decimal"      => Proc.new  { |number|  BigDecimal(number) },
+            "boolean"      => Proc.new  { |boolean| %w(1 true).include?(boolean.strip) },
+            "string"       => Proc.new  { |string|  string.to_s },
+            "yaml"         => Proc.new  { |yaml|    YAML::load(yaml) rescue yaml },
+            "base64Binary" => Proc.new  { |bin|     ActiveSupport::Base64.decode64(bin) },
+            "file"         => Proc.new do |file, entity|
+              f = StringIO.new(ActiveSupport::Base64.decode64(file))
+              f.extend(FileLike)
+              f.original_filename = entity['name']
+              f.content_type = entity['content_type']
+              f
+            end
+          }
+
+          XML_PARSING.update(
+            "double"   => XML_PARSING["float"],
+            "dateTime" => XML_PARSING["datetime"]
+          )
+        end
+
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        # Converts a hash into a string suitable for use as a URL query string. An optional <tt>namespace</tt> can be
+        # passed to enclose the param names (see example below).
+        #
+        # ==== Example:
+        #   { :name => 'David', :nationality => 'Danish' }.to_query # => "name=David&nationality=Danish"
+        #
+        #   { :name => 'David', :nationality => 'Danish' }.to_query('user') # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+        def to_query(namespace = nil)
+          collect do |key, value|
+            value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+          end.sort * '&'
+        end
+        
+        alias_method :to_param, :to_query
+
+        def to_xml(options = {})
+          options[:indent] ||= 2
+          options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
+                                   :root => "hash" })
+          options[:builder].instruct! unless options.delete(:skip_instruct)
+          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+          root = dasherize ? options[:root].to_s.dasherize : options[:root].to_s
+
+          options[:builder].__send__(:method_missing, root) do
+            each do |key, value|
+              case value
+                when ::Hash
+                  value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
+                when ::Array
+                  value.to_xml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true}))
+                when ::Method, ::Proc
+                  # If the Method or Proc takes two arguments, then
+                  # pass the suggested child element name.  This is
+                  # used if the Method or Proc will be operating over
+                  # multiple records and needs to create an containing
+                  # element that will contain the objects being
+                  # serialized.
+                  if 1 == value.arity
+                    value.call(options.merge({ :root => key, :skip_instruct => true }))
+                  else
+                    value.call(options.merge({ :root => key, :skip_instruct => true }), key.to_s.singularize)
+                  end
+                else
+                  if value.respond_to?(:to_xml)
+                    value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
+                  else
+                    type_name = XML_TYPE_NAMES[value.class.name]
+
+                    key = dasherize ? key.to_s.dasherize : key.to_s
+
+                    attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
+                    if value.nil?
+                      attributes[:nil] = true
+                    end
+
+                    options[:builder].tag!(key,
+                      XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
+                      attributes
+                    )
+                  end
+              end
+            end
+            
+            yield options[:builder] if block_given?
+          end
+
+        end
+
+        module ClassMethods
+          def from_xml(xml)
+            # TODO: Refactor this into something much cleaner that doesn't rely on XmlSimple
+            typecast_xml_value(undasherize_keys(XmlSimple.xml_in_string(xml,
+              'forcearray'   => false,
+              'forcecontent' => true,
+              'keeproot'     => true,
+              'contentkey'   => '__content__')
+            ))
+          end
+
+          private
+            def typecast_xml_value(value)
+              case value.class.to_s
+                when 'Hash'
+                  if value['type'] == 'array'
+                    child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
+                    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.has_key?("__content__")
+                    content = value["__content__"]
+                    if parser = XML_PARSING[value["type"]]
+                      if parser.arity == 2
+                        XML_PARSING[value["type"]].call(content, value)
+                      else
+                        XML_PARSING[value["type"]].call(content)
+                      end
+                    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 = value.inject({}) do |h,(k,v)|
+                      h[k] = typecast_xml_value(v)
+                      h
+                    end
+                    
+                    # 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) }
+                  case value.length
+                    when 0 then nil
+                    when 1 then value.first
+                    else value
+                  end
+                when 'String'
+                  value
+                else
+                  raise "can't typecast #{value.class.name} - #{value.inspect}"
+              end
+            end
+
+            def undasherize_keys(params)
+              case params.class.to_s
+                when "Hash"
+                  params.inject({}) do |h,(k,v)|
+                    h[k.to_s.tr("-", "_")] = undasherize_keys(v)
+                    h
+                  end
+                when "Array"
+                  params.map { |v| undasherize_keys(v) }
+                else
+                  params
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash/deep_merge.rb

@@ -0,0 +1,23 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      # Allows for deep merging
+      module DeepMerge
+        # Returns a new hash with +self+ and +other_hash+ merged recursively.
+        def deep_merge(other_hash)
+          self.merge(other_hash) do |key, oldval, newval|
+            oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+            newval = newval.to_hash if newval.respond_to?(:to_hash)
+            oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? oldval.deep_merge(newval) : newval
+          end
+        end
+
+        # Returns a new hash with +self+ and +other_hash+ merged recursively.
+        # Modifies the receiver in place.
+        def deep_merge!(other_hash)
+          replace(deep_merge(other_hash))
+        end
+      end
+    end
+  end
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash/diff.rb

@@ -0,0 +1,19 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Diff
+        # 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)
+          self.dup.delete_if { |k, v| h2[k] == v }.merge(h2.dup.delete_if { |k, v| self.has_key?(k) })
+        end
+      end
+    end
+  end
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash/except.rb

@@ -0,0 +1,25 @@
+require 'set'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      # 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))
+      module Except
+        # Returns a new hash without the given keys.
+        def except(*keys)
+          dup.except!(*keys)
+        end
+
+        # Replaces the hash without the given keys.
+        def except!(*keys)
+          keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+          keys.each { |key| delete(key) }
+          self
+        end
+      end
+    end
+  end
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash/indifferent_access.rb

@@ -0,0 +1,137 @@
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+
+class HashWithIndifferentAccess < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  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)
+
+  # Assigns a new value to the hash:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:key] = "value"
+  #
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # Updates the instantized hash with values from the second:
+  # 
+  #   hash_1 = HashWithIndifferentAccess.new
+  #   hash_1[:key] = "value"
+  # 
+  #   hash_2 = HashWithIndifferentAccess.new
+  #   hash_2[:key] = "New Value!"
+  # 
+  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+  # 
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # Checks the hash for a key matching the argument passed in:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash["key"] = "value"
+  #   hash.key? :key  # => true
+  #   hash.key? "key" # => true
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # Fetches the value for the specified key, same as doing hash[key]
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # Returns an exact copy of the hash.
+  def dup
+    HashWithIndifferentAccess.new(self)
+  end
+
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # Removes a specified key from the hash.
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+  def to_options!; self end
+
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        value.with_indifferent_access
+      when Array
+        value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+      else
+        value
+      end
+    end
+end
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module IndifferentAccess #:nodoc:
+        def with_indifferent_access
+          hash = HashWithIndifferentAccess.new(self)
+          hash.default = self.default
+          hash
+        end
+      end
+    end
+  end
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash/keys.rb

@@ -0,0 +1,52 @@
+module ActiveSupport #: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/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash/reverse_merge.rb

@@ -0,0 +1,35 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      # Allows for reverse merging two hashes where the keys in the calling hash take precedence over those
+      # in the <tt>other_hash</tt>. This is particularly useful for initializing an option hash with default values:
+      #
+      #   def setup(options = {})
+      #     options.reverse_merge! :size => 25, :velocity => 10
+      #   end
+      #
+      # Using <tt>merge</tt>, the above example would look as follows:
+      #
+      #   def setup(options = {})
+      #     { :size => 25, :velocity => 10 }.merge(options)
+      #   end
+      #
+      # The default <tt>:size</tt> and <tt>:velocity</tt> are only set if the +options+ hash passed in doesn't already
+      # have the respective key.
+      module ReverseMerge
+        # Performs the opposite of <tt>merge</tt>, with the keys and values from the first hash taking precedence over the second.
+        def reverse_merge(other_hash)
+          other_hash.merge(self)
+        end
+
+        # Performs the opposite of <tt>merge</tt>, with the keys and values from the first hash taking precedence over the second.
+        # Modifies the receiver in place.
+        def reverse_merge!(other_hash)
+          replace(reverse_merge(other_hash))
+        end
+
+        alias_method :reverse_update, :reverse_merge!
+      end
+    end
+  end
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash/slice.rb

@@ -0,0 +1,33 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      # 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))
+      module Slice
+        # Returns a new hash with only the given 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.
+        def slice!(*keys)
+          replace(slice(*keys))
+        end
+      end
+    end
+  end
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/hash.rb

@@ -0,0 +1,14 @@
+%w(keys indifferent_access deep_merge reverse_merge conversions diff slice except).each do |ext|
+  require "active_support/core_ext/hash/#{ext}"
+end
+
+class Hash #:nodoc:
+  include ActiveSupport::CoreExtensions::Hash::Keys
+  include ActiveSupport::CoreExtensions::Hash::IndifferentAccess
+  include ActiveSupport::CoreExtensions::Hash::DeepMerge
+  include ActiveSupport::CoreExtensions::Hash::ReverseMerge
+  include ActiveSupport::CoreExtensions::Hash::Conversions
+  include ActiveSupport::CoreExtensions::Hash::Diff
+  include ActiveSupport::CoreExtensions::Hash::Slice
+  include ActiveSupport::CoreExtensions::Hash::Except
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/integer/even_odd.rb

@@ -0,0 +1,29 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Integer #:nodoc:
+      # For checking if a fixnum is even or odd.
+      #
+      #   2.even?  # => true
+      #   2.odd?   # => false
+      #   1.even?  # => false
+      #   1.odd?   # => true
+      #   0.even?  # => true
+      #   0.odd?   # => false
+      #   -1.even? # => false
+      #   -1.odd?  # => true
+      module EvenOdd
+        def multiple_of?(number)
+          self % number == 0
+        end
+
+        def even?
+          multiple_of? 2
+        end if RUBY_VERSION < '1.9'
+
+        def odd?
+          !even?
+        end if RUBY_VERSION < '1.9'
+      end
+    end
+  end
+end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/pkg/activesupport-2.2.2/lib/active_support/core_ext/integer/inflections.rb

@@ -0,0 +1,20 @@
+require 'active_support/inflector'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Integer #:nodoc:
+      module Inflections
+        # 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"
+        def ordinalize
+          Inflector.ordinalize(self)
+        end
+      end
+    end
+  end
+end