social_url_stats 0.0.1 → 0.0.2

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

@@ -1,78 +0,0 @@
-require 'active_support/core_ext/module/delegation'
-
-module ActiveSupport
-  # Notifications provides an instrumentation API for Ruby. To instrument an
-  # action in Ruby you just need to do:
-  #
-  #   ActiveSupport::Notifications.instrument(:render, :extra => :information) do
-  #     render :text => "Foo"
-  #   end
-  #
-  # You can consume those events and the information they provide by registering
-  # a log subscriber. For instance, let's store all instrumented events in an array:
-  #
-  #   @events = []
-  #
-  #   ActiveSupport::Notifications.subscribe do |*args|
-  #     @events << ActiveSupport::Notifications::Event.new(*args)
-  #   end
-  #
-  #   ActiveSupport::Notifications.instrument(:render, :extra => :information) do
-  #     render :text => "Foo"
-  #   end
-  #
-  #   event = @events.first
-  #   event.name      # => :render
-  #   event.duration  # => 10 (in milliseconds)
-  #   event.payload   # => { :extra => :information }
-  #
-  # When subscribing to Notifications, you can pass a pattern, to only consume
-  # events that match the pattern:
-  #
-  #   ActiveSupport::Notifications.subscribe(/render/) do |event|
-  #     @render_events << event
-  #   end
-  #
-  # Notifications ships with a queue implementation that consumes and publish events
-  # to log subscribers in a thread. You can use any queue implementation you want.
-  #
-  module Notifications
-    autoload :Instrumenter, 'active_support/notifications/instrumenter'
-    autoload :Event, 'active_support/notifications/instrumenter'
-    autoload :Fanout, 'active_support/notifications/fanout'
-
-    @instrumenters = Hash.new { |h,k| h[k] = notifier.listening?(k) }
-
-    class << self
-      attr_writer :notifier
-      delegate :publish, :to => :notifier
-
-      def instrument(name, payload = {})
-        if @instrumenters[name]
-          instrumenter.instrument(name, payload) { yield payload if block_given? }
-        else
-          yield payload if block_given?
-        end
-      end
-
-      def subscribe(*args, &block)
-        notifier.subscribe(*args, &block).tap do
-          @instrumenters.clear
-        end
-      end
-
-      def unsubscribe(*args)
-        notifier.unsubscribe(*args)
-        @instrumenters.clear
-      end
-
-      def notifier
-        @notifier ||= Fanout.new
-      end
-
-      def instrumenter
-        Thread.current[:"instrumentation_#{notifier.object_id}"] ||= Instrumenter.new(notifier)
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module ActiveSupport
-  module Notifications
-    # This is a default queue implementation that ships with Notifications. It
-    # just pushes events to all registered log subscribers.
-    class Fanout
-      def initialize
-        @subscribers = []
-        @listeners_for = {}
-      end
-
-      def subscribe(pattern = nil, block = Proc.new)
-        subscriber = Subscriber.new(pattern, block).tap do |s|
-          @subscribers << s
-        end
-        @listeners_for.clear
-        subscriber
-      end
-
-      def unsubscribe(subscriber)
-        @subscribers.reject! {|s| s.matches?(subscriber)}
-        @listeners_for.clear
-      end
-
-      def publish(name, *args)
-        listeners_for(name).each { |s| s.publish(name, *args) }
-      end
-
-      def listeners_for(name)
-        @listeners_for[name] ||= @subscribers.select { |s| s.subscribed_to?(name) }
-      end
-
-      def listening?(name)
-        listeners_for(name).any?
-      end
-
-      # This is a sync queue, so there is not waiting.
-      def wait
-      end
-
-      class Subscriber #:nodoc:
-        def initialize(pattern, delegate)
-          @pattern = pattern
-          @delegate = delegate
-        end
-
-        def publish(message, *args)
-          @delegate.call(message, *args)
-        end
-
-        def subscribed_to?(name)
-          !@pattern || @pattern === name.to_s
-        end
-
-        def matches?(subscriber_or_name)
-          self === subscriber_or_name ||
-            @pattern && @pattern === subscriber_or_name
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-require 'active_support/secure_random'
-require 'active_support/core_ext/module/delegation'
-
-module ActiveSupport
-  module Notifications
-    class Instrumenter
-      attr_reader :id
-
-      def initialize(notifier)
-        @id = unique_id
-        @notifier = notifier
-      end
-
-      # Instrument the given block by measuring the time taken to execute it
-      # and publish it. Notice that events get sent even if an error occurs
-      # in the passed-in block
-      def instrument(name, payload={})
-        started = Time.now
-
-        begin
-          yield
-        rescue Exception => e
-          payload[:exception] = [e.class.name, e.message]
-          raise e
-        ensure
-          @notifier.publish(name, started, Time.now, @id, payload)
-        end
-      end
-
-      private
-        def unique_id
-          SecureRandom.hex(10)
-        end
-    end
-
-    class Event
-      attr_reader :name, :time, :end, :transaction_id, :payload, :duration
-
-      def initialize(name, start, ending, transaction_id, payload)
-        @name           = name
-        @payload        = payload.dup
-        @time           = start
-        @transaction_id = transaction_id
-        @end            = ending
-        @duration       = 1000.0 * (@end - @time)
-      end
-
-      def parent_of?(event)
-        start = (time - event.time) * 1000
-        start <= 0 && (start + duration >= event.duration)
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require 'active_support/core_ext/hash/deep_merge'
-
-module ActiveSupport
-  class OptionMerger #:nodoc:
-    instance_methods.each do |method|
-      undef_method(method) if method !~ /^(__|instance_eval|class|object_id)/
-    end
-
-    def initialize(context, options)
-      @context, @options = context, options
-    end
-
-    private
-      def method_missing(method, *arguments, &block)
-        if arguments.last.is_a?(Proc)
-          proc = arguments.pop
-          arguments << lambda { |*args| @options.deep_merge(proc.call(*args)) }
-        else
-          arguments << (arguments.last.respond_to?(:to_hash) ? @options.deep_merge(arguments.pop) : @options.dup)
-        end
-
-        @context.__send__(method, *arguments, &block)
-      end
-  end
-end

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

@@ -1,179 +0,0 @@
-require 'yaml'
-
-YAML.add_builtin_type("omap") do |type, val|
-  ActiveSupport::OrderedHash[val.map(&:to_a).map(&:first)]
-end
-
-# OrderedHash is namespaced to prevent conflicts with other implementations
-module ActiveSupport
-  class OrderedHash < ::Hash #:nodoc:
-    def to_yaml_type
-      "!tag:yaml.org,2002:omap"
-    end
-
-    def to_yaml(opts = {})
-      YAML.quick_emit(self, opts) do |out|
-        out.seq(taguri, to_yaml_style) do |seq|
-          each do |k, v|
-            seq.add(k => v)
-          end
-        end
-      end
-    end
-
-    # Hash is ordered in Ruby 1.9!
-    if RUBY_VERSION < '1.9'
-
-      # In MRI the Hash class is core and written in C. In particular, methods are
-      # programmed with explicit C function calls and polymorphism is not honored.
-      #
-      # For example, []= is crucial in this implementation to maintain the @keys
-      # array but hash.c invokes rb_hash_aset() originally. This prevents method
-      # reuse through inheritance and forces us to reimplement stuff.
-      #
-      # For instance, we cannot use the inherited #merge! because albeit the algorithm
-      # itself would work, our []= is not being called at all by the C code.
-
-      def initialize(*args, &block)
-        super
-        @keys = []
-      end
-
-      def self.[](*args)
-        ordered_hash = new
-
-        if (args.length == 1 && args.first.is_a?(Array))
-          args.first.each do |key_value_pair|
-            next unless (key_value_pair.is_a?(Array))
-            ordered_hash[key_value_pair[0]] = key_value_pair[1]
-          end
-
-          return ordered_hash
-        end
-
-        unless (args.size % 2 == 0)
-          raise ArgumentError.new("odd number of arguments for Hash")
-        end
-
-        args.each_with_index do |val, ind|
-          next if (ind % 2 != 0)
-          ordered_hash[val] = args[ind + 1]
-        end
-
-        ordered_hash
-      end
-
-      def initialize_copy(other)
-        super
-        # make a deep copy of keys
-        @keys = other.keys
-      end
-
-      def []=(key, value)
-        @keys << key if !has_key?(key)
-        super
-      end
-
-      def delete(key)
-        if has_key? key
-          index = @keys.index(key)
-          @keys.delete_at index
-        end
-        super
-      end
-
-      def delete_if
-        super
-        sync_keys!
-        self
-      end
-
-      def reject!
-        super
-        sync_keys!
-        self
-      end
-
-      def reject(&block)
-        dup.reject!(&block)
-      end
-
-      def keys
-        @keys.dup
-      end
-
-      def values
-        @keys.collect { |key| self[key] }
-      end
-
-      def to_hash
-        self
-      end
-
-      def to_a
-        @keys.map { |key| [ key, self[key] ] }
-      end
-
-      def each_key
-        @keys.each { |key| yield key }
-      end
-
-      def each_value
-        @keys.each { |key| yield self[key]}
-      end
-
-      def each
-        @keys.each {|key| yield [key, self[key]]}
-      end
-
-      alias_method :each_pair, :each
-
-      def clear
-        super
-        @keys.clear
-        self
-      end
-
-      def shift
-        k = @keys.first
-        v = delete(k)
-        [k, v]
-      end
-
-      def merge!(other_hash)
-        if block_given?
-          other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
-        else
-          other_hash.each { |k, v| self[k] = v }
-        end
-        self
-      end
-
-      alias_method :update, :merge!
-
-      def merge(other_hash, &block)
-        dup.merge!(other_hash, &block)
-      end
-
-      # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
-      def replace(other)
-        super
-        @keys = other.keys
-        self
-      end
-
-      def invert
-        OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
-      end
-
-      def inspect
-        "#<OrderedHash #{super}>"
-      end
-
-      private
-        def sync_keys!
-          @keys.delete_if {|k| !has_key?(k)}
-        end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require 'active_support/ordered_hash'
-
-module ActiveSupport #:nodoc:
-  class OrderedOptions < OrderedHash
-    def []=(key, value)
-      super(key.to_sym, value)
-    end
-
-    def [](key)
-      super(key.to_sym)
-    end
-
-    def method_missing(name, *args)
-      if name.to_s =~ /(.*)=$/
-        self[$1.to_sym] = args.first
-      else
-        self[name]
-      end
-    end
-  end
-
-  class InheritableOptions < OrderedOptions
-    def initialize(parent)
-      super() { |h,k| parent[k] }
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-require "active_support"
-require "rails"
-require "active_support/i18n_railtie"
-
-module ActiveSupport
-  class Railtie < Rails::Railtie
-    config.active_support = ActiveSupport::OrderedOptions.new
-
-    # Loads support for "whiny nil" (noisy warnings when methods are invoked
-    # on +nil+ values) if Configuration#whiny_nils is true.
-    initializer "active_support.initialize_whiny_nils" do |app|
-      require 'active_support/whiny_nil' if app.config.whiny_nils
-    end
-
-    initializer "active_support.deprecation_behavior" do |app|
-      if deprecation = app.config.active_support.deprecation
-        ActiveSupport::Deprecation.behavior = deprecation
-      else
-        defaults = {"development" => :log,
-                    "production"  => :notify,
-                    "test"        => :stderr}
-
-        env = Rails.env
-
-        if defaults.key?(env)
-          msg = "You did not specify how you would like Rails to report " \
-                "deprecation notices for your #{env} environment, please " \
-                "set config.active_support.deprecation to :#{defaults[env]} " \
-                "at config/environments/#{env}.rb"
-
-          warn msg
-          ActiveSupport::Deprecation.behavior = defaults[env]
-        else
-          msg = "You did not specify how you would like Rails to report " \
-                "deprecation notices for your #{env} environment, please " \
-                "set config.active_support.deprecation to :log, :notify or " \
-                ":stderr at config/environments/#{env}.rb"
-
-          warn msg
-          ActiveSupport::Deprecation.behavior = :stderr
-        end
-      end
-    end
-
-    # Sets the default value for Time.zone
-    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
-    initializer "active_support.initialize_time_zone" do |app|
-      require 'active_support/core_ext/time/zones'
-      zone_default = Time.__send__(:get_zone, app.config.time_zone)
-
-      unless zone_default
-        raise \
-          'Value assigned to config.time_zone not recognized.' +
-          'Run "rake -D time" for a list of tasks for finding appropriate time zone names.'
-      end
-
-      Time.zone_default = zone_default
-    end
-  end
-end