social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/README.rdoc

@@ -1,33 +0,0 @@
-= Active Support -- Utility classes and Ruby extensions from Rails
-
-Active Support is a collection of utility classes and standard library
-extensions that were found useful for the Rails framework. These additions
-reside in this package so they can be loaded as needed in Ruby projects
-outside of Rails.
-
-
-== Download and installation
-
-The latest version of Active Support can be installed with Rubygems:
-
-  % [sudo] gem install activesupport
-
-Source code can be downloaded as part of the Rails project on GitHub
-
-* http://github.com/rails/rails/tree/master/activesupport/
-
-
-== License
-
-Active Support is released under the MIT license.
-
-
-== Support
-
-API documentation is at
-
-* http://api.rubyonrails.com
-
-Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
-
-* https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets

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

@@ -1,79 +0,0 @@
-#--
-# Copyright (c) 2005 David Heinemeier Hansson
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
-
-module ActiveSupport
-  class << self
-    attr_accessor :load_all_hooks
-    def on_load_all(&hook) load_all_hooks << hook end
-    def load_all!; load_all_hooks.each { |hook| hook.call } end
-  end
-  self.load_all_hooks = []
-
-  on_load_all do
-    [Dependencies, Deprecation, Gzip, MessageVerifier, Multibyte, SecureRandom]
-  end
-end
-
-require "active_support/dependencies/autoload"
-
-module ActiveSupport
-  extend ActiveSupport::Autoload
-
-  autoload :DescendantsTracker
-  autoload :FileUpdateChecker
-  autoload :LogSubscriber
-  autoload :Notifications
-
-  # TODO: Narrow this list down
-  eager_autoload do
-    autoload :BacktraceCleaner
-    autoload :Base64
-    autoload :BasicObject
-    autoload :Benchmarkable
-    autoload :BufferedLogger
-    autoload :Cache
-    autoload :Callbacks
-    autoload :Concern
-    autoload :Configurable
-    autoload :Deprecation
-    autoload :Gzip
-    autoload :Inflector
-    autoload :JSON
-    autoload :Memoizable
-    autoload :MessageEncryptor
-    autoload :MessageVerifier
-    autoload :Multibyte
-    autoload :OptionMerger
-    autoload :OrderedHash
-    autoload :OrderedOptions
-    autoload :Rescuable
-    autoload :SecureRandom
-    autoload :StringInquirer
-    autoload :XmlMini
-  end
-
-  autoload :SafeBuffer, "active_support/core_ext/string/output_safety"
-  autoload :TestCase
-end
-
-autoload :I18n, "active_support/i18n"

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

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

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

@@ -1,94 +0,0 @@
-module ActiveSupport
-  # Many backtraces include too much information that's not relevant for the context. This makes it hard to find the signal
-  # in the backtrace and adds debugging time. With a BacktraceCleaner, you can setup filters and silencers for your particular
-  # context, so only the relevant lines are included.
-  #
-  # If you need to reconfigure an existing BacktraceCleaner, like the one in Rails, to show as much as possible, you can always
-  # call BacktraceCleaner#remove_silencers! Also, if you need to reconfigure an existing BacktraceCleaner so that it does not
-  # filter or modify the paths of any lines of the backtrace, you can call BacktraceCleaner#remove_filters! These two methods
-  # will give you a completely untouched backtrace.
-  #
-  # Example:
-  #
-  #   bc = BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root, '') }
-  #   bc.add_silencer { |line| line =~ /mongrel|rubygems/ }
-  #   bc.clean(exception.backtrace) # will strip the Rails.root prefix and skip any lines from mongrel or rubygems
-  #
-  # Inspired by the Quiet Backtrace gem by Thoughtbot.
-  class BacktraceCleaner
-    def initialize
-      @filters, @silencers = [], []
-    end
-
-    # Returns the backtrace after all filters and silencers has been run against it. Filters run first, then silencers.
-    def clean(backtrace, kind = :silent)
-      filtered = filter(backtrace)
-
-      case kind
-      when :silent
-        silence(filtered)
-      when :noise
-        noise(filtered)
-      else
-        filtered
-      end
-    end
-
-    # Adds a filter from the block provided. Each line in the backtrace will be mapped against this filter.
-    #
-    # Example:
-    #
-    #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
-    #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
-    def add_filter(&block)
-      @filters << block
-    end
-
-    # Adds a silencer from the block provided. If the silencer returns true for a given line, it'll be excluded from the
-    # clean backtrace.
-    #
-    # Example:
-    #
-    #   # Will reject all lines that include the word "mongrel", like "/gems/mongrel/server.rb" or "/app/my_mongrel_server/rb"
-    #   backtrace_cleaner.add_silencer { |line| line =~ /mongrel/ }
-    def add_silencer(&block)
-      @silencers << block
-    end
-
-    # Will remove all silencers, but leave in the filters. This is useful if your context of debugging suddenly expands as
-    # you suspect a bug in the libraries you use.
-    def remove_silencers!
-      @silencers = []
-    end
-
-    def remove_filters!
-      @filters = []
-    end
-
-    private
-      def filter(backtrace)
-        @filters.each do |f|
-          backtrace = backtrace.map { |line| f.call(line) }
-        end
-
-        backtrace
-      end
-
-      def silence(backtrace)
-        @silencers.each do |s|
-          backtrace = backtrace.reject { |line| s.call(line) }
-        end
-
-        backtrace
-      end
-
-      def noise(backtrace)
-        @silencers.each do |s|
-          backtrace = backtrace.select { |line| s.call(line) }
-        end
-
-        backtrace
-      end
-  end
-end

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

@@ -1,42 +0,0 @@
-begin
-  require 'base64'
-rescue LoadError
-end
-
-module ActiveSupport
-  if defined? ::Base64
-    Base64 = ::Base64
-  else
-    # Base64 provides utility methods for encoding and de-coding binary data
-    # using a base 64 representation. A base 64 representation of binary data
-    # consists entirely of printable US-ASCII characters. The Base64 module
-    # is included in Ruby 1.8, but has been removed in Ruby 1.9.
-    module Base64
-      # Encodes a string to its base 64 representation. Each 60 characters of
-      # output is separated by a newline character.
-      #
-      #  ActiveSupport::Base64.encode64("Original unencoded string")
-      #  # => "T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw==\n"
-      def self.encode64(data)
-        [data].pack("m")
-      end
-
-      # Decodes a base 64 encoded string to its original representation.
-      #
-      #  ActiveSupport::Base64.decode64("T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw==")
-      #  # => "Original unencoded string"
-      def self.decode64(data)
-        data.unpack("m").first
-      end
-    end
-  end
-
-  # Encodes the value as base64 without the newline breaks. This makes the base64 encoding readily usable as URL parameters
-  # or memcache keys without further processing.
-  #
-  #  ActiveSupport::Base64.encode64s("Original unencoded string")
-  #  # => "T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw=="
-  def Base64.encode64s(value)
-    encode64(value).gsub(/\n/, '')
-  end
-end

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

@@ -1,21 +0,0 @@
-module ActiveSupport
-  if defined? ::BasicObject
-    # A class with no predefined methods that behaves similarly to Builder's
-    # BlankSlate. Used for proxy classes.
-    class BasicObject < ::BasicObject
-      undef_method :==
-      undef_method :equal?
-
-      # Let ActiveSupport::BasicObject at least raise exceptions.
-      def raise(*args)
-        ::Object.send(:raise, *args)
-      end
-    end
-  else
-    class BasicObject #:nodoc:
-      instance_methods.each do |m|
-        undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$)/
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-require 'active_support/core_ext/benchmark'
-require 'active_support/core_ext/hash/keys'
-
-module ActiveSupport
-  module Benchmarkable
-    # Allows you to measure the execution time of a block
-    # in a template and records the result to the log. Wrap this block around
-    # expensive operations or possible bottlenecks to get a time reading
-    # for the operation.  For example, let's say you thought your file
-    # processing method was taking too long; you could wrap it in a benchmark block.
-    #
-    #  <% benchmark "Process data files" do %>
-    #    <%= expensive_files_operation %>
-    #  <% end %>
-    #
-    # That would add something like "Process data files (345.2ms)" to the log,
-    # which you can then use to compare timings when optimizing your code.
-    #
-    # You may give an optional logger level as the :level option.
-    # (:debug, :info, :warn, :error); the default value is :info.
-    #
-    #  <% benchmark "Low-level files", :level => :debug do %>
-    #    <%= lowlevel_files_operation %>
-    #  <% end %>
-    #
-    # Finally, you can pass true as the third argument to silence all log activity
-    # inside the block. This is great for boiling down a noisy block to just a single statement:
-    #
-    #  <% benchmark "Process data files", :level => :info, :silence => true do %>
-    #    <%= expensive_and_chatty_files_operation %>
-    #  <% end %>
-    def benchmark(message = "Benchmarking", options = {})
-      if logger
-        if options.is_a?(Symbol)
-          ActiveSupport::Deprecation.warn("use benchmark('#{message}', :level => :#{options}) instead", caller)
-          options = { :level => options, :silence => false }
-        else
-          options.assert_valid_keys(:level, :silence)
-          options[:level] ||= :info
-        end
-
-        result = nil
-        ms = Benchmark.ms { result = options[:silence] ? logger.silence { yield } : yield }
-        logger.send(options[:level], '%s (%.1fms)' % [ message, ms ])
-        result
-      else
-        yield
-      end
-    end
-
-    # Silence the logger during the execution of the block.
-    #
-    def silence
-      old_logger_level, logger.level = logger.level, ::Logger::ERROR if logger
-      yield
-    ensure
-      logger.level = old_logger_level if logger
-    end
-  end
-end

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

@@ -1,136 +0,0 @@
-require 'active_support/core_ext/class/attribute_accessors'
-
-module ActiveSupport
-  # Inspired by the buffered logger idea by Ezra
-  class BufferedLogger
-    module Severity
-      DEBUG   = 0
-      INFO    = 1
-      WARN    = 2
-      ERROR   = 3
-      FATAL   = 4
-      UNKNOWN = 5
-    end
-    include Severity
-
-    MAX_BUFFER_SIZE = 1000
-
-    ##
-    # :singleton-method:
-    # Set to false to disable the silencer
-    cattr_accessor :silencer
-    self.silencer = true
-
-    # Silences the logger for the duration of the block.
-    def silence(temporary_level = ERROR)
-      if silencer
-        begin
-          old_logger_level, self.level = level, temporary_level
-          yield self
-        ensure
-          self.level = old_logger_level
-        end
-      else
-        yield self
-      end
-    end
-
-    attr_accessor :level
-    attr_reader :auto_flushing
-
-    def initialize(log, level = DEBUG)
-      @level         = level
-      @buffer        = {}
-      @auto_flushing = 1
-      @guard = Mutex.new
-
-      if log.respond_to?(:write)
-        @log = log
-      elsif File.exist?(log)
-        @log = open(log, (File::WRONLY | File::APPEND))
-        @log.sync = true
-      else
-        FileUtils.mkdir_p(File.dirname(log))
-        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
-        @log.sync = true
-      end
-    end
-
-    def add(severity, message = nil, progname = nil, &block)
-      return if @level > severity
-      message = (message || (block && block.call) || progname).to_s
-      # If a newline is necessary then create a new message ending with a newline.
-      # Ensures that the original message is not mutated.
-      message = "#{message}\n" unless message[-1] == ?\n
-      buffer << message
-      auto_flush
-      message
-    end
-
-    # Dynamically add methods such as:
-    # def info
-    # def warn
-    # def debug
-    for severity in Severity.constants
-      class_eval <<-EOT, __FILE__, __LINE__ + 1
-        def #{severity.downcase}(message = nil, progname = nil, &block) # def debug(message = nil, progname = nil, &block)
-          add(#{severity}, message, progname, &block)                   #   add(DEBUG, message, progname, &block)
-        end                                                             # end
-
-        def #{severity.downcase}?                                       # def debug?
-          #{severity} >= @level                                         #   DEBUG >= @level
-        end                                                             # end
-      EOT
-    end
-
-    # Set the auto-flush period. Set to true to flush after every log message,
-    # to an integer to flush every N messages, or to false, nil, or zero to
-    # never auto-flush. If you turn auto-flushing off, be sure to regularly
-    # flush the log yourself -- it will eat up memory until you do.
-    def auto_flushing=(period)
-      @auto_flushing =
-        case period
-        when true;                1
-        when false, nil, 0;       MAX_BUFFER_SIZE
-        when Integer;             period
-        else raise ArgumentError, "Unrecognized auto_flushing period: #{period.inspect}"
-        end
-    end
-
-    def flush
-      @guard.synchronize do
-        unless buffer.empty?
-          old_buffer = buffer
-          all_content = StringIO.new
-          old_buffer.each do |content|
-            all_content << content
-          end
-          @log.write(all_content.string)
-        end
-
-        # Important to do this even if buffer was empty or else @buffer will
-        # accumulate empty arrays for each request where nothing was logged.
-        clear_buffer
-      end
-    end
-
-    def close
-      flush
-      @log.close if @log.respond_to?(:close)
-      @log = nil
-    end
-
-    protected
-      def auto_flush
-        flush if buffer.size >= @auto_flushing
-      end
-
-      def buffer
-        @buffer[Thread.current] ||= []
-      end
-
-      def clear_buffer
-        @buffer.delete(Thread.current)
-      end
-  end
-end