social_url_stats 0.0.1 → 0.0.2

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

@@ -1,8 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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