social_url_stats 0.0.1

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/hash.rb

@@ -0,0 +1,8 @@
+require 'active_support/core_ext/hash/conversions'
+require 'active_support/core_ext/hash/deep_merge'
+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/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/hash/conversions.rb

@@ -0,0 +1,150 @@
+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. Its
+  #   return value becomes a new node.
+  #
+  # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
+  #
+  # * 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| k != 'type' })
+              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 = 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 = 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) }
+            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"
+            params.inject({}) do |h,(k,v)|
+              h[k.to_s.tr("-", "_")] = unrename_keys(v)
+              h
+            end
+          when "Array"
+            params.map { |v| unrename_keys(v) }
+          else
+            params
+        end
+      end
+  end
+end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/hash/deep_merge.rb

@@ -0,0 +1,16 @@
+class Hash
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  def deep_merge(other_hash)
+    dup.deep_merge!(other_hash)
+  end
+
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  # Modifies the receiver in place.
+  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/ruby/1.9.1/gems/activesupport-3.0.0/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/ruby/1.9.1/gems/activesupport-3.0.0/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/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/hash/indifferent_access.rb

@@ -0,0 +1,12 @@
+require 'active_support/hash_with_indifferent_access'
+
+class Hash
+
+  # Returns an +ActiveSupport::HashWithIndifferentAccess+ out of its receiver:
+  #
+  #   {:a => 1}.with_indifferent_access["a"] # => 1
+  #
+  def with_indifferent_access
+    ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self)
+  end
+end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/hash/keys.rb

@@ -0,0 +1,45 @@
+class Hash
+  # Return a new hash with all keys converted to strings.
+  def stringify_keys
+    dup.stringify_keys!
+  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, as long as
+  # they respond to +to_sym+.
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+.
+  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(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

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/hash/reverse_merge.rb

@@ -0,0 +1,28 @@
+class Hash
+  # 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.
+  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)
+    merge!( other_hash ){|k,o,n| o }
+  end
+
+  alias_method :reverse_update, :reverse_merge!
+end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/hash/slice.rb

@@ -0,0 +1,38 @@
+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
+
+  def extract!(*keys)
+    result = {}
+    keys.each {|key| result[key] = delete(key) }
+    result
+  end
+end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/integer.rb

@@ -0,0 +1,3 @@
+require 'active_support/core_ext/integer/multiple'
+require 'active_support/core_ext/integer/inflections'
+require 'active_support/core_ext/integer/time'

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/integer/inflections.rb

@@ -0,0 +1,14 @@
+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"
+  def ordinalize
+    ActiveSupport::Inflector.ordinalize(self)
+  end
+end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/integer/multiple.rb

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

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/integer/time.rb

@@ -0,0 +1,39 @@
+class Integer
+  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+  #
+  # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
+  # as well as adding or subtracting their results from a Time object. For example:
+  #
+  #   # equivalent to Time.now.advance(:months => 1)
+  #   1.month.from_now
+  #
+  #   # equivalent to Time.now.advance(:years => 2)
+  #   2.years.from_now
+  #
+  #   # equivalent to Time.now.advance(:months => 4, :years => 5)
+  #   (4.months + 5.years).from_now
+  #
+  # While these methods provide precise calculation when used as in the examples above, care
+  # should be taken to note that this is not true if the result of `months', `years', etc is
+  # converted before use:
+  #
+  #   # equivalent to 30.days.to_i.from_now
+  #   1.month.to_i.from_now
+  #
+  #   # equivalent to 365.25.days.to_f.from_now
+  #   1.year.to_f.from_now
+  #
+  # In such cases, Ruby's core
+  # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and
+  # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
+  # date and time arithmetic
+  def months
+    ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
+  end
+  alias :month :months
+
+  def years
+    ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
+  end
+  alias :year :years
+end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/kernel.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/kernel/agnostics'
+require 'active_support/core_ext/kernel/requires'
+require 'active_support/core_ext/kernel/debugger'
+require 'active_support/core_ext/kernel/singleton_class'

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/kernel/agnostics.rb

@@ -0,0 +1,11 @@
+class Object
+  # Makes backticks behave (somewhat more) similarly on all platforms.
+  # On win32 `nonexistent_command` raises Errno::ENOENT; on Unix, the
+  # spawned shell prints a message to stderr and sets $?.  We emulate
+  # Unix on the former but not the latter.
+  def `(command) #:nodoc:
+    super
+  rescue Errno::ENOENT => e
+    STDERR.puts "#$0: #{e}"
+  end
+end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/kernel/debugger.rb

@@ -0,0 +1,16 @@
+module Kernel
+  unless respond_to?(:debugger)
+    # Starts a debugging session if ruby-debug has been loaded (call rails server --debugger to do load it).
+    def debugger
+      message = "\n***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****\n"
+      defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
+    end
+  end
+
+  undef :breakpoint if respond_to?(:breakpoint)
+  def breakpoint
+    message = "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
+    defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
+    debugger
+  end
+end