social_url_stats 0.0.1

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

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

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

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

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

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

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

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