activesupport 3.0.0.beta4 → 3.0.pre

data/lib/active_support/notifications/fanout.rb

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

@@ -1,56 +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={})
-        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/railtie.rb

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

data/lib/active_support/xml_mini/libxmlsax.rb

@@ -1,85 +0,0 @@
-require 'libxml'
-require 'active_support/core_ext/object/blank'
-
-# = XmlMini LibXML implementation using a SAX-based parser
-module ActiveSupport
-  module XmlMini_LibXMLSAX
-    extend self
-
-    # Class that will build the hash while the XML document
-    # is being parsed using SAX events.
-    class HashBuilder
-
-      include LibXML::XML::SaxParser::Callbacks
-
-      CONTENT_KEY   = '__content__'.freeze
-      HASH_SIZE_KEY = '__hash_size__'.freeze
-
-      attr_reader :hash
-
-      def current_hash
-        @hash_stack.last
-      end
-
-      def on_start_document
-        @hash = { CONTENT_KEY => '' }
-        @hash_stack = [@hash]
-      end
-
-      def on_end_document
-        @hash = @hash_stack.pop
-        @hash.delete(CONTENT_KEY)
-      end
-
-      def on_start_element(name, attrs = {})
-        new_hash = { CONTENT_KEY => '' }.merge(attrs)
-        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
-
-        case current_hash[name]
-          when Array then current_hash[name] << new_hash
-          when Hash  then current_hash[name] = [current_hash[name], new_hash]
-          when nil   then current_hash[name] = new_hash
-        end
-
-        @hash_stack.push(new_hash)
-      end
-
-      def on_end_element(name)
-        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ''
-          current_hash.delete(CONTENT_KEY)
-        end
-        @hash_stack.pop
-      end
-
-      def on_characters(string)
-        current_hash[CONTENT_KEY] << string
-      end
-
-      alias_method :on_cdata_block, :on_characters
-    end
-
-    attr_accessor :document_class
-    self.document_class = HashBuilder
-
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || '')
-      end
-
-      char = data.getc
-      if char.nil?
-        {}
-      else
-        data.ungetc(char)
-
-        LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
-        parser = LibXML::XML::SaxParser.io(data)
-        document = self.document_class.new
-
-        parser.callbacks = document
-        parser.parse
-        document.hash
-      end
-    end
-  end
-end

data/lib/active_support/xml_mini/nokogirisax.rb

@@ -1,83 +0,0 @@
-require 'nokogiri'
-require 'active_support/core_ext/object/blank'
-
-# = XmlMini Nokogiri implementation using a SAX-based parser
-module ActiveSupport
-  module XmlMini_NokogiriSAX
-    extend self
-
-    # Class that will build the hash while the XML document
-    # is being parsed using SAX events.
-    class HashBuilder < Nokogiri::XML::SAX::Document
-
-      CONTENT_KEY   = '__content__'.freeze
-      HASH_SIZE_KEY = '__hash_size__'.freeze
-
-      attr_reader :hash
-
-      def current_hash
-        @hash_stack.last
-      end
-
-      def start_document
-        @hash = {}
-        @hash_stack = [@hash]
-      end
-
-      def end_document
-        raise "Parse stack not empty!" if @hash_stack.size > 1
-      end
-
-      def error(error_message)
-        raise error_message
-      end
-
-      def start_element(name, attrs = [])
-        new_hash = { CONTENT_KEY => '' }
-        new_hash[attrs.shift] = attrs.shift while attrs.length > 0
-        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
-
-        case current_hash[name]
-          when Array then current_hash[name] << new_hash
-          when Hash  then current_hash[name] = [current_hash[name], new_hash]
-          when nil   then current_hash[name] = new_hash
-        end
-
-        @hash_stack.push(new_hash)
-      end
-
-      def end_element(name)
-        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ''
-          current_hash.delete(CONTENT_KEY)
-        end
-        @hash_stack.pop
-      end
-
-      def characters(string)
-        current_hash[CONTENT_KEY] << string
-      end
-
-      alias_method :cdata_block, :characters
-    end
-
-    attr_accessor :document_class
-    self.document_class = HashBuilder
-
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || '')
-      end
-
-      char = data.getc
-      if char.nil?
-        {}
-      else
-        data.ungetc(char)
-        document = self.document_class.new
-        parser = Nokogiri::XML::SAX::Parser.new(document)
-        parser.parse(data)
-        document.hash
-      end
-    end
-  end
-end