activesupport 2.3.18 → 3.0.0.beta

data/lib/active_support/multibyte.rb

@@ -1,7 +1,15 @@
 # encoding: utf-8
 
+require 'active_support/core_ext/module/attribute_accessors'
+
 module ActiveSupport #:nodoc:
   module Multibyte
+    autoload :EncodingError, 'active_support/multibyte/exceptions'
+    autoload :Chars, 'active_support/multibyte/chars'
+    autoload :UnicodeDatabase, 'active_support/multibyte/unicode_database'
+    autoload :Codepoint, 'active_support/multibyte/unicode_database'
+    autoload :UCD, 'active_support/multibyte/unicode_database'
+    
     # A list of all available normalization forms. See http://www.unicode.org/reports/tr15/tr15-29.html for more
     # information about normalization.
     NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
@@ -51,7 +59,4 @@ module ActiveSupport #:nodoc:
   end
 end
 
-require 'active_support/multibyte/chars'
-require 'active_support/multibyte/exceptions'
-require 'active_support/multibyte/unicode_database'
-require 'active_support/multibyte/utils'
+require 'active_support/multibyte/utils'

data/lib/active_support/multibyte/chars.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+require 'active_support/core_ext/string/access'
+require 'active_support/core_ext/string/behavior'
 
 module ActiveSupport #:nodoc:
   module Multibyte #:nodoc:
@@ -196,7 +198,7 @@ module ActiveSupport #:nodoc:
       #   'Café périferôl'.mb_chars.index('ô') #=> 12
       #   'Café périferôl'.mb_chars.index(/\w/u) #=> 0
       def index(needle, offset=0)
-        wrapped_offset = self.first(offset).wrapped_string.length
+        wrapped_offset = first(offset).wrapped_string.length
         index = @wrapped_string.index(needle, wrapped_offset)
         index ? (self.class.u_unpack(@wrapped_string.slice(0...index)).size) : nil
       end
@@ -210,7 +212,7 @@ module ActiveSupport #:nodoc:
       #   'Café périferôl'.mb_chars.rindex(/\w/u) #=> 13
       def rindex(needle, offset=nil)
         offset ||= length
-        wrapped_offset = self.first(offset).wrapped_string.length
+        wrapped_offset = first(offset).wrapped_string.length
         index = @wrapped_string.rindex(needle, wrapped_offset)
         index ? (self.class.u_unpack(@wrapped_string.slice(0...index)).size) : nil
       end
@@ -362,6 +364,16 @@ module ActiveSupport #:nodoc:
         slice
       end
 
+      # Limit the byte size of the string to a number of bytes without breaking characters. Usable
+      # when the storage for a string is limited for some reason.
+      #
+      # Example:
+      #   s = 'こんにちは'
+      #   s.mb_chars.limit(7) #=> "こに"
+      def limit(limit)
+        slice(0...translate_offset(limit))
+      end
+
       # Returns the codepoint of the first character in the string.
       #
       # Example:
@@ -373,7 +385,7 @@ module ActiveSupport #:nodoc:
       # Convert characters in the string to uppercase.
       #
       # Example:
-      #   'Laurent, òu sont les tests?'.mb_chars.upcase.to_s #=> "LAURENT, ÒU SONT LES TESTS?"
+      #   'Laurent, où sont les tests ?'.mb_chars.upcase.to_s #=> "LAURENT, OÙ SONT LES TESTS ?"
       def upcase
         apply_mapping :uppercase_mapping
       end
@@ -650,24 +662,20 @@ module ActiveSupport #:nodoc:
       end
 
       protected
-
+        
         def translate_offset(byte_offset) #:nodoc:
           return nil if byte_offset.nil?
           return 0   if @wrapped_string == ''
-          chunk = @wrapped_string[0..byte_offset]
+          
+          if @wrapped_string.respond_to?(:force_encoding)
+            @wrapped_string = @wrapped_string.dup.force_encoding(Encoding::ASCII_8BIT)
+          end
+          
           begin
-            begin
-              chunk.unpack('U*').length - 1
-            rescue ArgumentError => e
-              chunk = @wrapped_string[0..(byte_offset+=1)]
-              # Stop retrying at the end of the string
-              raise e unless byte_offset < chunk.length 
-              # We damaged a character, retry
-              retry
-            end
-          # Catch the ArgumentError so we can throw our own
-          rescue ArgumentError 
-            raise EncodingError, 'malformed UTF-8 character'
+            @wrapped_string[0...byte_offset].unpack('U*').length
+          rescue ArgumentError => e
+            byte_offset -= 1
+            retry
           end
         end
 

data/lib/active_support/multibyte/unicode_database.rb

@@ -24,10 +24,10 @@ module ActiveSupport #:nodoc:
       # 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
+          def #{attr_name}     # def codepoints
+            load               #   load
+            @#{attr_name}      #   @codepoints
+          end                  # end
         EOS
       end
 
@@ -68,4 +68,4 @@ module ActiveSupport #:nodoc:
     # UniCode Database
     UCD = UnicodeDatabase.new
   end
-end
+end

data/lib/active_support/multibyte/utils.rb

@@ -27,7 +27,7 @@ module ActiveSupport #:nodoc:
       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 }
+          string.split(//).all? { |c| expression.match(c) }
         else
           true
         end

data/lib/active_support/notifications.rb

@@ -0,0 +1,77 @@
+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 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 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, :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 wait
+        @queue.wait
+      end
+    end
+  end
+end

data/lib/active_support/notifications/fanout.rb

@@ -0,0 +1,69 @@
+module ActiveSupport
+  module Notifications
+    # This is a default queue implementation that ships with Notifications. It
+    # just pushes events to all registered subscribers.
+    class Fanout
+      def initialize
+        @subscribers = []
+      end
+
+      def bind(pattern)
+        Binding.new(self, pattern)
+      end
+
+      def subscribe(pattern = nil, &block)
+        @subscribers << Subscriber.new(pattern, &block)
+      end
+
+      def publish(*args)
+        @subscribers.each { |s| s.publish(*args) }
+      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)
+          push(*args) if matches?(args.first)
+        end
+
+        def drained?
+          true
+        end
+
+        private
+          def matches?(name)
+            !@pattern || @pattern =~ name.to_s
+          end
+
+          def push(*args)
+            @block.call(*args)
+          end
+      end
+    end
+  end
+end

data/lib/active_support/notifications/instrumenter.rb

@@ -0,0 +1,50 @@
+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.
+      def instrument(name, payload={})
+        time = Time.now
+        result = yield(payload) if block_given?
+        @notifier.publish(name, time, Time.now, @id, payload)
+        result
+      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

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/deep_merge'
+
 module ActiveSupport
   class OptionMerger #:nodoc:
     instance_methods.each do |method|

data/lib/active_support/ordered_hash.rb

@@ -1,28 +1,13 @@
 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"
+  # Hash is ordered in Ruby 1.9!
+  if RUBY_VERSION >= '1.9'
+    class OrderedHash < ::Hash #:nodoc:
     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'
+  else
+    class OrderedHash < Hash #:nodoc:
       def initialize(*args, &block)
         super
         @keys = []
@@ -70,7 +55,7 @@ module ActiveSupport
         end
         super
       end
-
+      
       def delete_if
         super
         sync_keys!
@@ -130,18 +115,12 @@ module ActiveSupport
       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
+        other_hash.each {|k,v| self[k] = v }
         self
       end
 
-      alias_method :update, :merge!
-
-      def merge(other_hash, &block)
-        dup.merge!(other_hash, &block)
+      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.
@@ -151,18 +130,35 @@ module ActiveSupport
         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)}
+    private
+
+      def sync_keys!
+        @keys.delete_if {|k| !has_key?(k)}
+      end
+    end
+  end
+
+  class OrderedHash #: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
   end
+
+  YAML.add_builtin_type("omap") do |type, val|
+    ActiveSupport::OrderedHash[val.map(&:to_a).map(&:first)]
+  end
 end