csd 0.0.15 → 0.0.16

data/lib/active_support/notifications.rb

@@ -0,0 +1,81 @@
+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 miliseconds)
+  #   event.result    #=> "Foo"
+  #   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'
+
+    class << self
+      attr_writer :notifier
+      delegate :publish, :subscribe, :unsubscribe, :to => :notifier
+      delegate :instrument, :to => :instrumenter
+
+      def notifier
+        @notifier ||= Notifier.new
+      end
+
+      def instrumenter
+        Thread.current[:"instrumentation_#{notifier.object_id}"] ||= Instrumenter.new(notifier)
+      end
+    end
+
+    class Notifier
+      def initialize(queue = Fanout.new)
+        @queue = queue
+      end
+
+      def publish(*args)
+        @queue.publish(*args)
+      end
+
+      def subscribe(pattern = nil, &block)
+        @queue.bind(pattern).subscribe(&block)
+      end
+
+      def unsubscribe(subscriber)
+        @queue.unsubscribe(subscriber)
+      end
+
+      def wait
+        @queue.wait
+      end
+    end
+  end
+end

data/lib/active_support/notifications/fanout.rb

@@ -0,0 +1,93 @@
+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 bind(pattern)
+        Binding.new(self, pattern)
+      end
+
+      def subscribe(pattern = nil, &block)
+        @listeners_for.clear
+        @subscribers << Subscriber.new(pattern, &block)
+        @subscribers.last
+      end
+
+      def unsubscribe(subscriber)
+        @listeners_for.clear
+        @subscribers.reject! {|s| s.matches?(subscriber)}
+      end
+
+      def publish(name, *args)
+        if listeners = @listeners_for[name]
+          listeners.each { |s| s.publish(name, *args) }
+        else
+          @listeners_for[name] = @subscribers.select { |s| s.publish(name, *args) }
+        end
+      end
+
+      # This is a sync queue, so there is not waiting.
+      def wait
+      end
+
+      # Used for internal implementation only.
+      class Binding #:nodoc:
+        def initialize(queue, pattern)
+          @queue = queue
+          @pattern =
+            case pattern
+            when Regexp, NilClass
+              pattern
+            else
+              /^#{Regexp.escape(pattern.to_s)}$/
+            end
+        end
+
+        def subscribe(&block)
+          @queue.subscribe(@pattern, &block)
+        end
+      end
+
+      class Subscriber #:nodoc:
+        def initialize(pattern, &block)
+          @pattern = pattern
+          @block = block
+        end
+
+        def publish(*args)
+          return unless subscribed_to?(args.first)
+          push(*args)
+          true
+        end
+
+        def drained?
+          true
+        end
+
+        def subscribed_to?(name)
+          !@pattern || @pattern =~ name.to_s
+        end
+
+        def matches?(subscriber_or_name)
+          case subscriber_or_name
+          when String
+            @pattern && @pattern =~ subscriber_or_name
+          when self
+            true
+          end
+        end
+
+        private
+
+          def push(*args)
+            @block.call(*args)
+          end
+      end
+    end
+  end
+end

data/lib/active_support/notifications/instrumenter.rb

@@ -0,0 +1,56 @@
+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={})
+        time = Time.now
+        begin
+          yield(payload) if block_given?
+        rescue Exception => e
+          payload[:exception] = [e.class.name, e.message]
+          raise e
+        ensure
+          @notifier.publish(name, time, 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
+
+      def initialize(name, start, ending, transaction_id, payload)
+        @name           = name
+        @payload        = payload.dup
+        @time           = start
+        @transaction_id = transaction_id
+        @end            = ending
+      end
+
+      def duration
+        @duration ||= 1000.0 * (@end - @time)
+      end
+
+      def parent_of?(event)
+        start = (self.time - event.time) * 1000
+        start <= 0 && (start + duration >= event.duration)
+      end
+    end
+  end
+end

data/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/lib/active_support/ordered_hash.rb

@@ -0,0 +1,158 @@
+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'
+      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)
+        other_hash.each {|k,v| self[k] = v }
+        self
+      end
+
+      def merge(other_hash)
+        dup.merge!(other_hash)
+      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 inspect
+        "#<OrderedHash #{super}>"
+      end
+
+      private
+        def sync_keys!
+          @keys.delete_if {|k| !has_key?(k)}
+        end
+    end
+  end
+end

data/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/lib/active_support/railtie.rb

@@ -0,0 +1,100 @@
+require "active_support"
+require "rails"
+
+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
+
+    # 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
+
+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
+
+    initializer "i18n.initialize" do
+      ActiveSupport.on_load(:i18n) do
+        I18n.reload!
+
+        ActionDispatch::Callbacks.to_prepare do
+          I18n.reload!
+        end
+      end
+    end
+
+    # Set the i18n configuration from config.i18n but special-case for
+    # the load_path which should be appended to what's already set instead of overwritten.
+    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)
+      I18n.reload!
+    end
+
+    class << self
+      protected
+
+        def 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 include_fallbacks_module
+          I18n.backend.class.send(:include, I18n::Backend::Fallbacks)
+        end
+      
+        def 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
+end