backbone-deep-rails 0.0.2 → 0.0.3

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/notifications.rb

@@ -1,154 +0,0 @@
-module ActiveSupport
-  # = Notifications
-  #
-  # +ActiveSupport::Notifications+ provides an instrumentation API for Ruby.
-  #
-  # == Instrumenters
-  #
-  # To instrument an event you just need to do:
-  #
-  #   ActiveSupport::Notifications.instrument("render", :extra => :information) do
-  #     render :text => "Foo"
-  #   end
-  #
-  # That executes the block first and notifies all subscribers once done.
-  #
-  # In the example above "render" is the name of the event, and the rest is called
-  # the _payload_. The payload is a mechanism that allows instrumenters to pass
-  # extra information to subscribers. Payloads consist of a hash whose contents
-  # are arbitrary and generally depend on the event.
-  #
-  # == Subscribers
-  #
-  # You can consume those events and the information they provide by registering
-  # a subscriber. For instance, let's store all "render" events in an array:
-  #
-  #   events = []
-  #
-  #   ActiveSupport::Notifications.subscribe("render") do |*args|
-  #     events << ActiveSupport::Notifications::Event.new(*args)
-  #   end
-  #
-  # That code returns right away, you are just subscribing to "render" events.
-  # The block will be called asynchronously whenever someone instruments "render":
-  #
-  #   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 }
-  #
-  # The block in the +subscribe+ call gets the name of the event, start
-  # timestamp, end timestamp, a string with a unique identifier for that event
-  # (something like "535801666f04d0298cd6"), and a hash with the payload, in
-  # that order.
-  #
-  # If an exception happens during that particular instrumentation the payload will
-  # have a key +:exception+ with an array of two elements as value: a string with
-  # the name of the exception class, and the exception message.
-  #
-  # As the previous example depicts, the class +ActiveSupport::Notifications::Event+
-  # is able to take the arguments as they come and provide an object-oriented
-  # interface to that data.
-  #
-  # You can also subscribe to all events whose name matches a certain regexp:
-  #
-  #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
-  #     ...
-  #   end
-  #
-  # and even pass no argument to +subscribe+, in which case you are subscribing
-  # to all events.
-  #
-  # == Temporary Subscriptions
-  #
-  # Sometimes you do not want to subscribe to an event for the entire life of
-  # the application. There are two ways to unsubscribe.
-  #
-  # WARNING: The instrumentation framework is designed for long-running subscribers,
-  # use this feature sparingly because it wipes some internal caches and that has
-  # a negative impact on performance.
-  #
-  # === Subscribe While a Block Runs
-  #
-  # You can subscribe to some event temporarily while some block runs. For
-  # example, in
-  #
-  #   callback = lambda {|*args| ... }
-  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
-  #     ...
-  #   end
-  #
-  # the callback will be called for all "sql.active_record" events instrumented
-  # during the execution of the block. The callback is unsubscribed automatically
-  # after that.
-  #
-  # === Manual Unsubscription
-  #
-  # The +subscribe+ method returns a subscriber object:
-  #
-  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |*args|
-  #     ...
-  #   end
-  #
-  # To prevent that block from being called anymore, just unsubscribe passing
-  # that reference:
-  #
-  #   ActiveSupport::Notifications.unsubscribe(subscriber)
-  #
-  # == Default Queue
-  #
-  # 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_accessor :notifier
-
-      def publish(name, *args)
-        notifier.publish(name, *args)
-      end
-
-      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 subscribed(callback, *args, &block)
-        subscriber = subscribe(*args, &callback)
-        yield
-      ensure
-        unsubscribe(subscriber)
-      end
-
-      def unsubscribe(args)
-        notifier.unsubscribe(args)
-        @instrumenters.clear
-      end
-
-      def instrumenter
-        Thread.current[:"instrumentation_#{notifier.object_id}"] ||= Instrumenter.new(notifier)
-      end
-    end
-
-    self.notifier = Fanout.new
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/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 no 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/bundle/gems/activesupport-3.2.11/lib/active_support/notifications/instrumenter.rb

@@ -1,53 +0,0 @@
-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/bundle/gems/activesupport-3.2.11/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/bundle/gems/activesupport-3.2.11/lib/active_support/ordered_hash.rb

@@ -1,222 +0,0 @@
-begin
-  require 'psych'
-rescue LoadError
-end
-
-require 'yaml'
-
-YAML.add_builtin_type("omap") do |type, val|
-  ActiveSupport::OrderedHash[val.map{ |v| v.to_a.first }]
-end
-
-module ActiveSupport
-  # The order of iteration over hashes in Ruby 1.8 is undefined. For example, you do not know the
-  # order in which +keys+ will return keys, or +each+ yield pairs. <tt>ActiveSupport::OrderedHash</tt>
-  # implements a hash that preserves insertion order, as in Ruby 1.9:
-  #
-  #   oh = ActiveSupport::OrderedHash.new
-  #   oh[:a] = 1
-  #   oh[:b] = 2
-  #   oh.keys # => [:a, :b], this order is guaranteed
-  #
-  # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts with other implementations.
-  class OrderedHash < ::Hash
-    def to_yaml_type
-      "!tag:yaml.org,2002:omap"
-    end
-
-    def encode_with(coder)
-      coder.represent_seq '!omap', map { |k,v| { k => v } }
-    end
-
-    def to_yaml(opts = {})
-      if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
-        return super
-      end
-
-      YAML.quick_emit(self, opts) do |out|
-        out.seq(taguri) do |seq|
-          each do |k, v|
-            seq.add(k => v)
-          end
-        end
-      end
-    end
-
-    def nested_under_indifferent_access
-      self
-    end
-
-    # Returns true to make sure that this hash is extractable via <tt>Array#extract_options!</tt>
-    def extractable_options?
-      true
-    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 unless 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
-        return to_enum(:each_key) unless block_given?
-        @keys.each { |key| yield key }
-        self
-      end
-
-      def each_value
-        return to_enum(:each_value) unless block_given?
-        @keys.each { |key| yield self[key]}
-        self
-      end
-
-      def each
-        return to_enum(:each) unless block_given?
-        @keys.each {|key| yield [key, self[key]]}
-        self
-      end
-
-      def each_pair
-        return to_enum(:each_pair) unless block_given?
-        @keys.each {|key| yield key, self[key]}
-        self
-      end
-
-      alias_method :select, :find_all
-
-      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