social_url_stats 0.0.1 → 0.0.2

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

@@ -1,25 +0,0 @@
-require 'zlib'
-require 'stringio'
-
-module ActiveSupport
-  # A convenient wrapper for the zlib standard library that allows compression/decompression of strings with gzip.
-  module Gzip
-    class Stream < StringIO
-      def close; rewind; end
-    end
-
-    # Decompresses a gzipped string.
-    def self.decompress(source)
-      Zlib::GzipReader.new(StringIO.new(source)).read
-    end
-
-    # Compresses a string using gzip.
-    def self.compress(source)
-      output = Stream.new
-      gz = Zlib::GzipWriter.new(output)
-      gz.write(source)
-      gz.close
-      output.string
-    end
-  end
-end

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

@@ -1,151 +0,0 @@
-require 'active_support/core_ext/hash/keys'
-
-# 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.
-
-module ActiveSupport
-  class HashWithIndifferentAccess < Hash
-    def extractable_options?
-      true
-    end
-
-    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
-
-    def self.new_from_hash_copying_default(hash)
-      ActiveSupport::HashWithIndifferentAccess.new(hash).tap do |new_hash|
-        new_hash.default = hash.default
-      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
-
-    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
-    def reverse_merge(other_hash)
-      super self.class.new_from_hash_copying_default(other_hash)
-    end
-
-    def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
-    end
-
-    # Removes a specified key from the hash.
-    def delete(key)
-      super(convert_key(key))
-    end
-
-    def stringify_keys!; self end
-    def stringify_keys; dup end
-    undef :symbolize_keys!
-    def symbolize_keys; to_hash.symbolize_keys 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
-          self.class.new_from_hash_copying_default(value)
-        when Array
-          value.collect { |e| e.is_a?(Hash) ? self.class.new_from_hash_copying_default(e) : e }
-        else
-          value
-        end
-      end
-  end
-end
-
-HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

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

@@ -1,9 +0,0 @@
-begin
-  require 'i18n'
-rescue LoadError => e
-  $stderr.puts "You don't have i18n installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-
-I18n.load_path << "#{File.dirname(__FILE__)}/locale/en.yml"
-ActiveSupport.run_load_hooks(:i18n)

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

@@ -1,81 +0,0 @@
-require "active_support"
-require "rails"
-require "active_support/file_update_checker"
-require "active_support/core_ext/array/wrap"
-
-module I18n
-  class Railtie < Rails::Railtie
-    config.i18n = ActiveSupport::OrderedOptions.new
-    config.i18n.railties_load_path = []
-    config.i18n.load_path = []
-    config.i18n.fallbacks = ActiveSupport::OrderedOptions.new
-
-    def self.reloader
-      @reloader ||= ActiveSupport::FileUpdateChecker.new([]){ I18n.reload! }
-    end
-
-    # Add I18n::Railtie.reloader to ActionDispatch callbacks. Since, at this
-    # point, no path was added to the reloader, I18n.reload! is not triggered
-    # on to_prepare callbacks. This will only happen on the config.after_initialize
-    # callback below.
-    initializer "i18n.callbacks" do
-      ActionDispatch::Callbacks.to_prepare do
-        I18n::Railtie.reloader.execute_if_updated
-      end
-    end
-
-    # Set the i18n configuration only after initialization since a lot of
-    # configuration is still usually done in application initializers.
-    config.after_initialize do |app|
-      fallbacks = app.config.i18n.delete(:fallbacks)
-
-      app.config.i18n.each do |setting, value|
-        case setting
-        when :railties_load_path
-          app.config.i18n.load_path.unshift(*value)
-        when :load_path
-          I18n.load_path += value
-        else
-          I18n.send("#{setting}=", value)
-        end
-      end
-
-      init_fallbacks(fallbacks) if fallbacks && validate_fallbacks(fallbacks)
-
-      reloader.paths.concat I18n.load_path
-      reloader.execute_if_updated
-    end
-
-  protected
-
-    def self.include_fallbacks_module
-      I18n.backend.class.send(:include, I18n::Backend::Fallbacks)
-    end
-
-    def self.init_fallbacks(fallbacks)
-      include_fallbacks_module
-
-      args = case fallbacks
-      when ActiveSupport::OrderedOptions
-        [*(fallbacks[:defaults] || []) << fallbacks[:map]].compact
-      when Hash, Array
-        Array.wrap(fallbacks)
-      else # TrueClass
-        []
-      end
-
-      I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
-    end
-
-    def self.validate_fallbacks(fallbacks)
-      case fallbacks
-      when ActiveSupport::OrderedOptions
-        !fallbacks.empty?
-      when TrueClass, Array, Hash
-        true
-      else
-        raise "Unexpected fallback type #{fallbacks.inspect}"
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-module ActiveSupport
-  Inflector.inflections do |inflect|
-    inflect.plural(/$/, 's')
-    inflect.plural(/s$/i, 's')
-    inflect.plural(/(ax|test)is$/i, '\1es')
-    inflect.plural(/(octop|vir)us$/i, '\1i')
-    inflect.plural(/(alias|status)$/i, '\1es')
-    inflect.plural(/(bu)s$/i, '\1ses')
-    inflect.plural(/(buffal|tomat)o$/i, '\1oes')
-    inflect.plural(/([ti])um$/i, '\1a')
-    inflect.plural(/sis$/i, 'ses')
-    inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
-    inflect.plural(/(hive)$/i, '\1s')
-    inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
-    inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
-    inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
-    inflect.plural(/([m|l])ouse$/i, '\1ice')
-    inflect.plural(/^(ox)$/i, '\1en')
-    inflect.plural(/(quiz)$/i, '\1zes')
-
-    inflect.singular(/s$/i, '')
-    inflect.singular(/(n)ews$/i, '\1ews')
-    inflect.singular(/([ti])a$/i, '\1um')
-    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
-    inflect.singular(/(^analy)ses$/i, '\1sis')
-    inflect.singular(/([^f])ves$/i, '\1fe')
-    inflect.singular(/(hive)s$/i, '\1')
-    inflect.singular(/(tive)s$/i, '\1')
-    inflect.singular(/([lr])ves$/i, '\1f')
-    inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
-    inflect.singular(/(s)eries$/i, '\1eries')
-    inflect.singular(/(m)ovies$/i, '\1ovie')
-    inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
-    inflect.singular(/([m|l])ice$/i, '\1ouse')
-    inflect.singular(/(bus)es$/i, '\1')
-    inflect.singular(/(o)es$/i, '\1')
-    inflect.singular(/(shoe)s$/i, '\1')
-    inflect.singular(/(cris|ax|test)es$/i, '\1is')
-    inflect.singular(/(octop|vir)i$/i, '\1us')
-    inflect.singular(/(alias|status)es$/i, '\1')
-    inflect.singular(/^(ox)en/i, '\1')
-    inflect.singular(/(vert|ind)ices$/i, '\1ex')
-    inflect.singular(/(matr)ices$/i, '\1ix')
-    inflect.singular(/(quiz)zes$/i, '\1')
-    inflect.singular(/(database)s$/i, '\1')
-
-    inflect.irregular('person', 'people')
-    inflect.irregular('man', 'men')
-    inflect.irregular('child', 'children')
-    inflect.irregular('sex', 'sexes')
-    inflect.irregular('move', 'moves')
-    inflect.irregular('cow', 'kine')
-
-    inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
-  end
-end

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

@@ -1,7 +0,0 @@
-# in case active_support/inflector is required without the rest of active_support
-require 'active_support/inflector/inflections'
-require 'active_support/inflector/transliterate'
-require 'active_support/inflector/methods'
-
-require 'active_support/inflections'
-require 'active_support/core_ext/string/inflections'

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

@@ -1,211 +0,0 @@
-module ActiveSupport
-  module Inflector
-    # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
-    # inflection rules. Examples:
-    #
-    #   ActiveSupport::Inflector.inflections do |inflect|
-    #     inflect.plural /^(ox)$/i, '\1\2en'
-    #     inflect.singular /^(ox)en/i, '\1'
-    #
-    #     inflect.irregular 'octopus', 'octopi'
-    #
-    #     inflect.uncountable "equipment"
-    #   end
-    #
-    # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
-    # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
-    # already have been loaded.
-    class Inflections
-      def self.instance
-        @__instance__ ||= new
-      end
-
-      attr_reader :plurals, :singulars, :uncountables, :humans
-
-      def initialize
-        @plurals, @singulars, @uncountables, @humans = [], [], [], []
-      end
-
-      # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
-      # The replacement should always be a string that may include references to the matched data from the rule.
-      def plural(rule, replacement)
-        @uncountables.delete(rule) if rule.is_a?(String)
-        @uncountables.delete(replacement)
-        @plurals.insert(0, [rule, replacement])
-      end
-
-      # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
-      # The replacement should always be a string that may include references to the matched data from the rule.
-      def singular(rule, replacement)
-        @uncountables.delete(rule) if rule.is_a?(String)
-        @uncountables.delete(replacement)
-        @singulars.insert(0, [rule, replacement])
-      end
-
-      # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
-      # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
-      #
-      # Examples:
-      #   irregular 'octopus', 'octopi'
-      #   irregular 'person', 'people'
-      def irregular(singular, plural)
-        @uncountables.delete(singular)
-        @uncountables.delete(plural)
-        if singular[0,1].upcase == plural[0,1].upcase
-          plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
-          plural(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + plural[1..-1])
-          singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
-        else
-          plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
-          plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
-          plural(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
-          plural(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
-          singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1])
-          singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1])
-        end
-      end
-
-      # Add uncountable words that shouldn't be attempted inflected.
-      #
-      # Examples:
-      #   uncountable "money"
-      #   uncountable "money", "information"
-      #   uncountable %w( money information rice )
-      def uncountable(*words)
-        (@uncountables << words).flatten!
-      end
-
-      # Specifies a humanized form of a string by a regular expression rule or by a string mapping.
-      # When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
-      # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
-      #
-      # Examples:
-      #   human /_cnt$/i, '\1_count'
-      #   human "legacy_col_person_name", "Name"
-      def human(rule, replacement)
-        @humans.insert(0, [rule, replacement])
-      end
-
-      # Clears the loaded inflections within a given scope (default is <tt>:all</tt>).
-      # Give the scope as a symbol of the inflection type, the options are: <tt>:plurals</tt>,
-      # <tt>:singulars</tt>, <tt>:uncountables</tt>, <tt>:humans</tt>.
-      #
-      # Examples:
-      #   clear :all
-      #   clear :plurals
-      def clear(scope = :all)
-        case scope
-          when :all
-            @plurals, @singulars, @uncountables = [], [], []
-          else
-            instance_variable_set "@#{scope}", []
-        end
-      end
-    end
-
-    # Yields a singleton instance of Inflector::Inflections so you can specify additional
-    # inflector rules.
-    #
-    # Example:
-    #   ActiveSupport::Inflector.inflections do |inflect|
-    #     inflect.uncountable "rails"
-    #   end
-    def inflections
-      if block_given?
-        yield Inflections.instance
-      else
-        Inflections.instance
-      end
-    end
-
-    # Returns the plural form of the word in the string.
-    #
-    # Examples:
-    #   "post".pluralize             # => "posts"
-    #   "octopus".pluralize          # => "octopi"
-    #   "sheep".pluralize            # => "sheep"
-    #   "words".pluralize            # => "words"
-    #   "CamelOctopus".pluralize     # => "CamelOctopi"
-    def pluralize(word)
-      result = word.to_s.dup
-
-      if word.empty? || inflections.uncountables.include?(result.downcase)
-        result
-      else
-        inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
-        result
-      end
-    end
-
-    # The reverse of +pluralize+, returns the singular form of a word in a string.
-    #
-    # Examples:
-    #   "posts".singularize            # => "post"
-    #   "octopi".singularize           # => "octopus"
-    #   "sheep".singularize            # => "sheep"
-    #   "word".singularize             # => "word"
-    #   "CamelOctopi".singularize      # => "CamelOctopus"
-    def singularize(word)
-      result = word.to_s.dup
-
-      if inflections.uncountables.any? { |inflection| result =~ /#{inflection}\Z/i }
-        result
-      else
-        inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
-        result
-      end
-    end
-
-    # Capitalizes the first word and turns underscores into spaces and strips a
-    # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
-    #
-    # Examples:
-    #   "employee_salary" # => "Employee salary"
-    #   "author_id"       # => "Author"
-    def humanize(lower_case_and_underscored_word)
-      result = lower_case_and_underscored_word.to_s.dup
-
-      inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
-      result.gsub(/_id$/, "").gsub(/_/, " ").capitalize
-    end
-
-    # Capitalizes all the words and replaces some characters in the string to create
-    # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
-    # used in the Rails internals.
-    #
-    # +titleize+ is also aliased as as +titlecase+.
-    #
-    # Examples:
-    #   "man from the boondocks".titleize # => "Man From The Boondocks"
-    #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
-    def titleize(word)
-      humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize }
-    end
-
-    # Create the name of a table like Rails does for models to table names. This method
-    # uses the +pluralize+ method on the last word in the string.
-    #
-    # Examples
-    #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
-    #   "egg_and_ham".tableize     # => "egg_and_hams"
-    #   "fancyCategory".tableize   # => "fancy_categories"
-    def tableize(class_name)
-      pluralize(underscore(class_name))
-    end
-
-    # Create a class name from a plural table name like Rails does for table names to models.
-    # Note that this returns a string and not a Class. (To convert to an actual class
-    # follow +classify+ with +constantize+.)
-    #
-    # Examples:
-    #   "egg_and_hams".classify # => "EggAndHam"
-    #   "posts".classify        # => "Post"
-    #
-    # Singular names are not handled correctly:
-    #   "business".classify     # => "Busines"
-    def classify(table_name)
-      # strip out any leading schema name
-      camelize(singularize(table_name.to_s.sub(/.*\./, '')))
-    end
-  end
-end