activesupport 3.0.0.beta4 → 3.0.pre

data/lib/active_support/multibyte/unicode_database.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+module ActiveSupport #:nodoc:
+  module Multibyte #:nodoc:
+    # Holds data about a codepoint in the Unicode database
+    class Codepoint
+      attr_accessor :code, :combining_class, :decomp_type, :decomp_mapping, :uppercase_mapping, :lowercase_mapping
+    end
+
+    # Holds static data from the Unicode database
+    class UnicodeDatabase
+      ATTRIBUTES = :codepoints, :composition_exclusion, :composition_map, :boundary, :cp1252
+
+      attr_writer(*ATTRIBUTES)
+
+      def initialize
+        @codepoints = Hash.new(Codepoint.new)
+        @composition_exclusion = []
+        @composition_map = {}
+        @boundary = {}
+        @cp1252 = {}
+      end
+
+      # Lazy load the Unicode database so it's only loaded when it's actually used
+      ATTRIBUTES.each do |attr_name|
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{attr_name}     # def codepoints
+            load               #   load
+            @#{attr_name}      #   @codepoints
+          end                  # end
+        EOS
+      end
+
+      # Loads the Unicode database and returns all the internal objects of UnicodeDatabase.
+      def load
+        begin
+          @codepoints, @composition_exclusion, @composition_map, @boundary, @cp1252 = File.open(self.class.filename, 'rb') { |f| Marshal.load f.read }
+        rescue Exception => e
+            raise IOError.new("Couldn't load the Unicode tables for UTF8Handler (#{e.message}), ActiveSupport::Multibyte is unusable")
+        end
+
+        # Redefine the === method so we can write shorter rules for grapheme cluster breaks
+        @boundary.each do |k,_|
+          @boundary[k].instance_eval do
+            def ===(other)
+              detect { |i| i === other } ? true : false
+            end
+          end if @boundary[k].kind_of?(Array)
+        end
+
+        # define attr_reader methods for the instance variables
+        class << self
+          attr_reader(*ATTRIBUTES)
+        end
+      end
+
+      # Returns the directory in which the data files are stored
+      def self.dirname
+        File.dirname(__FILE__) + '/../values/'
+      end
+
+      # Returns the filename for the data file for this version
+      def self.filename
+        File.expand_path File.join(dirname, "unicode_tables.dat")
+      end
+    end
+
+    # UniCode Database
+    UCD = UnicodeDatabase.new
+  end
+end

data/lib/active_support/multibyte/utils.rb

@@ -26,11 +26,11 @@ module ActiveSupport #:nodoc:
     else
       def self.verify(string)
         if expression = valid_character
-          # Splits the string on character boundaries, which are determined based on $KCODE.
-          string.split(//).all? { |c| expression =~ c }
-        else
-          true
+          for c in string.split(//)
+            return false unless expression.match(c)
+          end
         end
+        true
       end
     end
 
@@ -49,8 +49,9 @@ module ActiveSupport #:nodoc:
     else
       def self.clean(string)
         if expression = valid_character
-          # Splits the string on character boundaries, which are determined based on $KCODE.
-          string.split(//).grep(expression).join
+          stripped = []; for c in string.split(//)
+            stripped << c if expression.match(c)
+          end; stripped.join
         else
           string
         end

data/lib/active_support/notifications.rb

@@ -1,4 +1,6 @@
+require 'thread'
 require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors'
 
 module ActiveSupport
   # Notifications provides an instrumentation API for Ruby. To instrument an
@@ -9,12 +11,12 @@ module ActiveSupport
   #   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:
+  # a subscriber. For instance, let's store all instrumented events in an array:
   #
   #   @events = []
   #
-  #   ActiveSupport::Notifications.subscribe do |*args|
-  #     @events << ActiveSupport::Notifications::Event.new(*args)
+  #   ActiveSupport::Notifications.subscribe do |event|
+  #     @events << event
   #   end
   #
   #   ActiveSupport::Notifications.instrument(:render, :extra => :information) do
@@ -22,6 +24,7 @@ module ActiveSupport
   #   end
   #
   #   event = @events.first
+  #   event.class     #=> ActiveSupport::Notifications::Event
   #   event.name      #=> :render
   #   event.duration  #=> 10 (in miliseconds)
   #   event.result    #=> "Foo"
@@ -35,47 +38,134 @@ module ActiveSupport
   #   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.
+  # to 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'
+    mattr_accessor :queue
 
     class << self
-      attr_writer :notifier
-      delegate :publish, :subscribe, :unsubscribe, :to => :notifier
       delegate :instrument, :to => :instrumenter
 
-      def notifier
-        @notifier ||= Notifier.new
+      def instrumenter
+        Thread.current[:notifications_instrumeter] ||= Instrumenter.new(publisher)
       end
 
-      def instrumenter
-        Thread.current[:"instrumentation_#{notifier.object_id}"] ||= Instrumenter.new(notifier)
+      def publisher
+        @publisher ||= Publisher.new(queue)
+      end
+
+      def subscribe(pattern=nil, &block)
+        Subscriber.new(queue).bind(pattern).subscribe(&block)
+      end
+    end
+
+    class Instrumenter
+      def initialize(publisher)
+        @publisher = publisher
+      end
+
+      def instrument(name, payload={})
+        payload[:time]      = Time.now
+        payload[:thread_id] = Thread.current.object_id
+        payload[:result]    = yield if block_given?
+      ensure
+        payload[:duration] = 1000 * (Time.now.to_f - payload[:time].to_f)
+        @publisher.publish(name, payload)
+      end
+    end
+
+    class Publisher
+      def initialize(queue)
+        @queue = queue
+      end
+
+      def publish(name, payload)
+        @queue.publish(name, payload)
       end
     end
 
-    class Notifier
-      def initialize(queue = Fanout.new)
+    class Subscriber
+      def initialize(queue)
         @queue = queue
       end
 
-      def publish(*args)
-        @queue.publish(*args)
+      def bind(pattern)
+        @pattern = pattern
+        self
+      end
+
+      def subscribe
+        @queue.subscribe(@pattern) do |name, payload|
+          yield Event.new(name, payload)
+        end
+      end
+    end
+
+    class Event
+      attr_reader :name, :time, :duration, :thread_id, :result, :payload
+
+      def initialize(name, payload)
+        @name      = name
+        @payload   = payload.dup
+        @time      = @payload.delete(:time)
+        @thread_id = @payload.delete(:thread_id)
+        @result    = @payload.delete(:result)
+        @duration  = @payload.delete(:duration)
+      end
+
+      def parent_of?(event)
+        start = (self.time - event.time) * 1000
+        start <= 0 && (start + self.duration >= event.duration)
+      end
+    end
+
+    # This is a default queue implementation that ships with Notifications. It
+    # consumes events in a thread and publish them to all registered subscribers.
+    #
+    class LittleFanout
+      def initialize
+        @listeners, @stream = [], Queue.new
+        @thread = Thread.new { consume }
+      end
+
+      def publish(*event)
+        @stream.push(event)
       end
 
-      def subscribe(pattern = nil, &block)
-        @queue.bind(pattern).subscribe(&block)
+      def subscribe(pattern=nil, &block)
+        @listeners << Listener.new(pattern, &block)
       end
 
-      def unsubscribe(subscriber)
-        @queue.unsubscribe(subscriber)
+      def consume
+        while event = @stream.shift
+          @listeners.each { |l| l.publish(*event) }
+        end
       end
 
-      def wait
-        @queue.wait
+      class Listener
+        attr_reader :thread
+
+        def initialize(pattern, &block)
+          @pattern = pattern
+          @subscriber = block
+          @queue = Queue.new
+          @thread = Thread.new { consume }
+        end
+
+        def publish(name, payload)
+          unless @pattern && !(@pattern === name.to_s)
+            @queue << [name, payload]
+          end
+        end
+
+        def consume
+          while event = @queue.shift
+            @subscriber.call(*event)
+          end
+        end
       end
     end
   end
+
+  Notifications.queue = Notifications::LittleFanout.new
 end

data/lib/active_support/ordered_hash.rb

@@ -1,28 +1,10 @@
-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'
+  # Hash is ordered in Ruby 1.9!
+  if RUBY_VERSION >= '1.9'
+    OrderedHash = ::Hash
+  else
+    class OrderedHash < Hash #:nodoc:
       def initialize(*args, &block)
         super
         @keys = []
@@ -70,7 +52,7 @@ module ActiveSupport
         end
         super
       end
-
+      
       def delete_if
         super
         sync_keys!
@@ -138,21 +120,15 @@ module ActiveSupport
         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
+    private
+
+      def sync_keys!
+        @keys.delete_if {|k| !has_key?(k)}
+      end
     end
   end
 end

data/lib/active_support/ordered_options.rb

@@ -18,10 +18,4 @@ module ActiveSupport #:nodoc:
       end
     end
   end
-
-  class InheritableOptions < OrderedOptions
-    def initialize(parent)
-      super() { |h,k| parent[k] }
-    end
-  end
 end

data/lib/active_support/rescuable.rb

@@ -1,8 +1,5 @@
-require 'active_support/concern'
-require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/class/inheritable_attributes'
 require 'active_support/core_ext/proc'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/array/extract_options'
 
 module ActiveSupport
   # Rescuable module adds support for easier exception handling.
@@ -10,7 +7,7 @@ module ActiveSupport
     extend Concern
 
     included do
-      class_attribute :rescue_handlers
+      class_inheritable_accessor :rescue_handlers
       self.rescue_handlers = []
     end
 
@@ -68,7 +65,7 @@ module ActiveSupport
           end
 
           # put the new handler at the end because the list is read in reverse
-          self.rescue_handlers += [[key, options[:with]]]
+          rescue_handlers << [key, options[:with]]
         end
       end
     end
@@ -84,7 +81,7 @@ module ActiveSupport
     def handler_for_rescue(exception)
       # We go from right to left because pairs are pushed onto rescue_handlers
       # as rescue_from declarations are found.
-      _, rescuer = self.class.rescue_handlers.reverse.detect do |klass_name, handler|
+      _, rescuer = Array(rescue_handlers).reverse.detect do |klass_name, handler|
         # The purpose of allowing strings in rescue_from is to support the
         # declaration of handler associations for exception classes whose
         # definition is yet unknown.

data/lib/active_support/ruby/shim.rb

@@ -4,19 +4,21 @@
 # Date        next_year, next_month
 # DateTime    to_date, to_datetime, xmlschema
 # Enumerable  group_by, each_with_object, none?
+# Integer     even?, odd?
+# Object      tap
 # Process     Process.daemon
 # REXML       security fix
 # String      ord
+# Symbol      to_proc
 # Time        to_date, to_time, to_datetime
 require 'active_support'
 require 'active_support/core_ext/date/calculations'
 require 'active_support/core_ext/date_time/conversions'
 require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/integer/even_odd'
+require 'active_support/core_ext/object/tap'
 require 'active_support/core_ext/process/daemon'
 require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/string/interpolation'
-require 'active_support/core_ext/string/encoding'
 require 'active_support/core_ext/rexml'
+require 'active_support/core_ext/symbol/to_proc'
 require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/file/path'
-require 'active_support/core_ext/module/method_names'

data/lib/active_support/test_case.rb

@@ -5,10 +5,9 @@ require 'active_support/testing/deprecation'
 require 'active_support/testing/declarative'
 require 'active_support/testing/pending'
 require 'active_support/testing/isolation'
-require 'active_support/core_ext/kernel/reporting'
 
 begin
-  silence_warnings { require 'mocha' }
+  require 'mocha'
 rescue LoadError
   # Fake Mocha::ExpectationError so we can rescue it in #run. Bleh.
   Object.const_set :Mocha, Module.new
@@ -22,6 +21,12 @@ module ActiveSupport
       alias_method :method_name, :name if method_defined? :name
       alias_method :method_name, :__name__ if method_defined? :__name__
     else
+      # TODO: Figure out how to get the Rails::BacktraceFilter into minitest/unit
+      if defined?(Rails) && ENV['BACKTRACE'].nil?
+        require 'rails/backtrace_cleaner'
+        Test::Unit::Util::BacktraceFilter.module_eval { include Rails::BacktraceFilterForTestUnit }
+      end
+
       Assertion = Test::Unit::AssertionFailedError
 
       require 'active_support/testing/default'