activesupport 1.3.1 → 1.4.0

data/lib/active_support/multibyte/handlers/utf8_handler_proc.rb

@@ -0,0 +1,44 @@
+# Methods in this handler call functions in the utf8proc ruby extension. These are significantly faster than the
+# pure ruby versions. Chars automatically uses this handler when it can load the utf8proc extension. For
+# documentation on handler methods see UTF8Handler.
+class ActiveSupport::Multibyte::Handlers::UTF8HandlerProc < ActiveSupport::Multibyte::Handlers::UTF8Handler
+  
+  class << self
+    def normalize(str, form=ActiveSupport::Multibyte::DEFAULT_NORMALIZATION_FORM) #:nodoc:
+      codepoints = str.unpack('U*')
+      case form
+        when :d
+          utf8map(str, :stable)
+        when :c
+          utf8map(str, :stable, :compose)
+        when :kd
+          utf8map(str, :stable, :compat)
+        when :kc
+          utf8map(str, :stable, :compose, :compat)
+        else
+          raise ArgumentError, "#{form} is not a valid normalization variant", caller
+      end
+    end
+    
+    def decompose(str) #:nodoc:
+      utf8map(str, :stable)
+    end
+    
+    def downcase(str) #:nodoc:c
+      utf8map(str, :casefold)
+    end
+    
+    protected
+    
+    def utf8map(str, *option_array) #:nodoc:
+      options = 0
+      option_array.each do |option|
+        flag = Utf8Proc::Options[option]
+        raise ArgumentError, "Unknown argument given to utf8map." unless
+          flag
+        options |= flag
+      end
+      return Utf8Proc::utf8map(str, options)
+    end
+  end
+end

data/lib/active_support/option_merger.rb

@@ -1,7 +1,7 @@
 module ActiveSupport
   class OptionMerger #:nodoc:
     instance_methods.each do |method| 
-      undef_method(method) if method !~ /^(__|instance_eval)/
+      undef_method(method) if method !~ /^(__|instance_eval|class)/
     end
     
     def initialize(context, options)
@@ -15,8 +15,8 @@ module ActiveSupport
       end
       
       def merge_argument_options!(arguments)
-        arguments << if arguments.last.respond_to? :merge!
-          arguments.pop.dup.merge!(@options)
+        arguments << if arguments.last.respond_to? :to_hash
+          @options.merge(arguments.pop)
         else
           @options.dup
         end  

data/lib/active_support/ordered_options.rb

@@ -1,34 +1,35 @@
-class OrderedHash < Array #:nodoc:
-  def []=(key, value)    
-    if pair = find_pair(key)
-      pair.pop
-      pair << value
-    else
-      self << [key, value]
+# OrderedHash is namespaced to prevent conflicts with other implementations
+module ActiveSupport
+  class OrderedHash < Array #:nodoc:
+    def []=(key, value)
+      if pair = assoc(key)
+        pair.pop
+        pair << value
+      else
+        self << [key, value]
+      end
     end
-  end
-  
-  def [](key)
-    pair = find_pair(key)
-    pair ? pair.last : nil
-  end
 
-  def keys
-    self.collect { |i| i.first }
-  end
+    def [](key)
+      pair = assoc(key)
+      pair ? pair.last : nil
+    end
 
-  private
-    def find_pair(key)
-      self.each { |i| return i if i.first == key }
-      return false
+    def keys
+      collect { |key, value| key }
     end
+
+    def values
+      collect { |key, value| value }
+    end
+  end
 end
 
-class OrderedOptions < OrderedHash #:nodoc:
+class OrderedOptions < ActiveSupport::OrderedHash #:nodoc:
   def []=(key, value)
     super(key.to_sym, value)
   end
-  
+
   def [](key)
     super(key.to_sym)
   end
@@ -40,4 +41,4 @@ class OrderedOptions < OrderedHash #:nodoc:
       self[name]
     end
   end
-end
+end

data/lib/active_support/reloadable.rb

@@ -1,30 +1,64 @@
-# Classes that include this module will automatically be reloaded
-# by the Rails dispatcher when Dependencies.mechanism = :load.
+require 'active_support/deprecation'
+
+# A deprecated mechanism to mark a class reloadable.
+# 
+# Deprecated as of Rails 1.2.
+# All autoloaded objects are now unloaded.
 module Reloadable
   class << self
+    
     def included(base) #nodoc:
+      unless base.ancestors.include?(Reloadable::Subclasses) # Avoid double warning
+        ActiveSupport::Deprecation.warn "Reloadable has been deprecated and has no effect.", caller
+      end
+      
       raise TypeError, "Only Classes can be Reloadable!" unless base.is_a? Class
       
       unless base.respond_to?(:reloadable?)
         class << base
-          define_method(:reloadable?) { true }
+          define_method(:reloadable?) do
+            ActiveSupport::Deprecation.warn "Reloadable has been deprecated and reloadable? has no effect", caller
+            true
+          end
         end
       end
     end
     
     def reloadable_classes
-      included_in_classes.select { |klass| klass.reloadable? }
+      ActiveSupport::Deprecation.silence do
+        included_in_classes.select { |klass| klass.reloadable? }
+      end
     end
+    deprecate :reloadable_classes
   end
   
   # Captures the common pattern where a base class should not be reloaded,
   # but its subclasses should be.
+  # 
+  # Deprecated as of Rails 1.2.
+  # All autoloaded objects are now unloaded.
   module Subclasses
     def self.included(base) #nodoc:
       base.send :include, Reloadable
+      ActiveSupport::Deprecation.warn "Reloadable::Subclasses has been deprecated and has no effect.", caller
       (class << base; self; end).send(:define_method, :reloadable?) do
-         base != self
+        ActiveSupport::Deprecation.warn "Reloadable has been deprecated and reloadable? has no effect", caller
+        base != self
+      end
+    end
+  end
+  
+  module Deprecated
+    
+    def self.included(base)
+      class << base
+        define_method(:reloadable?) do
+          ActiveSupport::Deprecation.warn "Reloadable has been deprecated and reloadable? has no effect", caller
+          true # This might not have the desired effect, as AR::B.reloadable? => true.
+        end
       end
     end
+    
   end
+  
 end

data/lib/active_support/values/time_zone.rb

@@ -169,7 +169,7 @@ class TimeZone
 
     # A regular expression that matches the names of all time zones in
     # the USA.
-    US_ZONES = /US|Arizona|Indiana|Hawaii|Alaska/
+    US_ZONES = /US|Arizona|Indiana|Hawaii|Alaska/ unless defined?(US_ZONES)
 
     # A convenience method for returning a collection of TimeZone objects
     # for time zones in the USA.

data/lib/active_support/vendor/builder/blankslate.rb

@@ -14,12 +14,15 @@ module Builder #:nodoc:
   # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
   # BlankSlate is useful as a base class when writing classes that
   # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
-  class BlankSlate #:nodoc:
+  class BlankSlate
     class << self
+
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
       def hide(name)
-	      undef_method name if
-	        instance_methods.include?(name.to_s) and
-	        name !~ /^(__|instance_eval)/
+	undef_method name if
+	  instance_methods.include?(name.to_s) and
+	  name !~ /^(__|instance_eval)/
       end
     end
 
@@ -29,10 +32,14 @@ end
 
 # Since Ruby is very dynamic, methods added to the ancestors of
 # BlankSlate <em>after BlankSlate is defined</em> will show up in the
-# list of available BlankSlate methods.  We handle this by defining a hook in the Object and Kernel classes that will hide any defined 
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any defined
 module Kernel #:nodoc:
   class << self
     alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
     def method_added(name)
       blank_slate_method_added(name)
       return if self != Kernel
@@ -44,9 +51,12 @@ end
 class Object #:nodoc:
   class << self
     alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
     def method_added(name)
       blank_slate_method_added(name)
-      return  if self != Object
+      return if self != Object
       Builder::BlankSlate.hide(name)
     end
   end

data/lib/active_support/vendor/builder/xchar.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+
+# The XChar library is provided courtesy of Sam Ruby (See
+# http://intertwingly.net/stories/2005/09/28/xchar.rb)
+
+# --------------------------------------------------------------------
+
+# If the Builder::XChar module is not currently defined, fail on any
+# name clashes in standard library classes.
+
+module Builder
+  def self.check_for_name_collision(klass, method_name, defined_constant=nil)
+    if klass.instance_methods.include?(method_name)
+      fail RuntimeError,
+	"Name Collision: Method '#{method_name}' is already defined in #{klass}"
+    end
+  end
+end
+
+if ! defined?(Builder::XChar)
+  Builder.check_for_name_collision(String, "to_xs")
+  Builder.check_for_name_collision(Fixnum, "xchr")
+end
+
+######################################################################
+module Builder
+
+  ####################################################################
+  # XML Character converter, from Sam Ruby:
+  # (see http://intertwingly.net/stories/2005/09/28/xchar.rb). 
+  #
+  module XChar # :nodoc:
+
+    # See
+    # http://intertwingly.net/stories/2004/04/14/i18n.html#CleaningWindows
+    # for details.
+    CP1252 = {			# :nodoc:
+      128 => 8364,		# euro sign
+      130 => 8218,		# single low-9 quotation mark
+      131 =>  402,		# latin small letter f with hook
+      132 => 8222,		# double low-9 quotation mark
+      133 => 8230,		# horizontal ellipsis
+      134 => 8224,		# dagger
+      135 => 8225,		# double dagger
+      136 =>  710,		# modifier letter circumflex accent
+      137 => 8240,		# per mille sign
+      138 =>  352,		# latin capital letter s with caron
+      139 => 8249,		# single left-pointing angle quotation mark
+      140 =>  338,		# latin capital ligature oe
+      142 =>  381,		# latin capital letter z with caron
+      145 => 8216,		# left single quotation mark
+      146 => 8217,		# right single quotation mark
+      147 => 8220,		# left double quotation mark
+      148 => 8221,		# right double quotation mark
+      149 => 8226,		# bullet
+      150 => 8211,		# en dash
+      151 => 8212,		# em dash
+      152 =>  732,		# small tilde
+      153 => 8482,		# trade mark sign
+      154 =>  353,		# latin small letter s with caron
+      155 => 8250,		# single right-pointing angle quotation mark
+      156 =>  339,		# latin small ligature oe
+      158 =>  382,		# latin small letter z with caron
+      159 =>  376,		# latin capital letter y with diaeresis
+    }
+
+    # See http://www.w3.org/TR/REC-xml/#dt-chardata for details.
+    PREDEFINED = {
+      38 => '&',		# ampersand
+      60 => '<',		# left angle bracket
+      62 => '>',		# right angle bracket
+    }
+
+    # See http://www.w3.org/TR/REC-xml/#charsets for details.
+    VALID = [
+      [0x9, 0xA, 0xD],
+      (0x20..0xD7FF), 
+      (0xE000..0xFFFD),
+      (0x10000..0x10FFFF)
+    ]
+  end
+
+end
+
+
+######################################################################
+# Enhance the Fixnum class with a XML escaped character conversion.
+#
+class Fixnum #:nodoc:
+  XChar = Builder::XChar if ! defined?(XChar)
+
+  # XML escaped version of chr
+  def xchr
+    n = XChar::CP1252[self] || self
+    n = 42 unless XChar::VALID.find {|range| range.include? n}
+    XChar::PREDEFINED[n] or (n<128 ? n.chr : "&##{n};")
+  end
+end
+
+
+######################################################################
+# Enhance the String class with a XML escaped character version of
+# to_s.
+#
+class String #:nodoc:
+  # XML escaped version of to_s
+  def to_xs
+    unpack('U*').map {|n| n.xchr}.join # ASCII, UTF-8
+  rescue
+    unpack('C*').map {|n| n.xchr}.join # ISO-8859-1, WIN-1252
+  end
+end

data/lib/active_support/vendor/builder/xmlbase.rb

@@ -2,7 +2,7 @@
 
 require 'builder/blankslate'
 
-module Builder #:nodoc:
+module Builder
 
   # Generic error for builder
   class IllegalBlockError < RuntimeError #:nodoc:
@@ -14,7 +14,7 @@ module Builder #:nodoc:
 
     # Create an XML markup builder.
     #
-    # out::     Object receiving the markup.1  +out+ must respond to
+    # out::     Object receiving the markup.  +out+ must respond to
     #           <tt><<</tt>.
     # indent::  Number of spaces used for indentation (0 implies no
     #           indentation and no line breaks).
@@ -53,7 +53,7 @@ module Builder #:nodoc:
 	unless text.nil?
 	  raise ArgumentError, "XmlMarkup cannot mix a text argument with a block"
 	end
-	_capture_outer_self(block) if @self.nil?
+	_capture_outer_self(block) unless defined?(@self) && !@self.nil?
 	_indent
 	_start_tag(sym, attrs)
 	_newline
@@ -76,15 +76,15 @@ module Builder #:nodoc:
     end
 
     # Append text to the output target.  Escape any markup.  May be
-    # used within the markup brackets as:
+    # used within the markup brakets as:
     #
-    #   builder.p { br; text! "HI" }   #=>  <p><br/>HI</p>
+    #   builder.p { |b| b.br; b.text! "HI" }   #=>  <p><br/>HI</p>
     def text!(text)
       _text(_escape(text))
     end
     
     # Append text to the output target without escaping any markup.
-    # May be used within the markup brackets as:
+    # May be used within the markup brakets as:
     #
     #   builder.p { |x| x << "<br/>HI" }   #=>  <p><br/>HI</p>
     #
@@ -112,11 +112,13 @@ module Builder #:nodoc:
 
     private
     
+    require 'builder/xchar'
     def _escape(text)
-      text.
-	gsub(%r{&}, '&amp;').
-	gsub(%r{<}, '&lt;').
-	gsub(%r{>}, '&gt;')
+      text.to_xs
+    end
+
+    def _escape_quote(text)
+      _escape(text).gsub(%r{"}, '&quot;')  # " WART
     end
 
     def _capture_outer_self(block)

data/lib/active_support/vendor/builder/xmlmarkup.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #--
-# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# Copyright 2004, 2005 by Jim Weirich (jim@weirichhouse.org).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,
@@ -38,7 +38,6 @@ module Builder
   #       xm.title("History")        #     <title>History</title>
   #     }                            #   </head>
   #     xm.body {                    #   <body>
-  #       xm.comment! "HI"           #     <!-- HI -->
   #       xm.h1("Header")            #     <h1>Header</h1>
   #       xm.p("paragraph")          #     <p>paragraph</p>
   #     }                            #   </body>
@@ -165,13 +164,23 @@ module Builder
     # :target=><em>target_object</em>::
     #    Object receiving the markup.  +out+ must respond to the
     #    <tt><<</tt> operator.  The default is a plain string target.
+    #    
     # :indent=><em>indentation</em>::
     #    Number of spaces used for indentation.  The default is no
     #    indentation and no line breaks.
+    #    
     # :margin=><em>initial_indentation_level</em>::
     #    Amount of initial indentation (specified in levels, not
     #    spaces).
     #    
+    # :escape_attrs=><b>OBSOLETE</em>::
+    #    The :escape_attrs option is no longer supported by builder
+    #    (and will be quietly ignored).  String attribute values are
+    #    now automatically escaped.  If you need unescaped attribute
+    #    values (perhaps you are using entities in the attribute
+    #    values), then give the value as a Symbol.  This allows much
+    #    finer control over escaping attribute values.
+    #    
     def initialize(options={})
       indent = options[:indent] || 0
       margin = options[:margin] || 0
@@ -239,12 +248,13 @@ module Builder
 	[:version, :encoding, :standalone])
     end
 
-    # Surrounds the given text with a CDATA tag
+    # Insert a CDATA section into the XML markup.
     #
     # For example:
     #
-    #   xml.cdata! "blah blah blah"
-    #       # => <![CDATA[blah blah blah]]>
+    #    xml.cdata!("text to be included in cdata")
+    #        #=> <![CDATA[text to be included in cdata]]>
+    #
     def cdata!(text)
       _ensure_no_block block_given?
       _special("<![CDATA[", "]]>", text, nil)
@@ -289,10 +299,19 @@ module Builder
       return if attrs.nil?
       order.each do |k|
 	v = attrs[k]
-	@target << %{ #{k}="#{v}"} if v
+	@target << %{ #{k}="#{_attr_value(v)}"} if v
       end
       attrs.each do |k, v|
-	@target << %{ #{k}="#{v}"} unless order.member?(k)
+	@target << %{ #{k}="#{_attr_value(v)}"} unless order.member?(k)
+      end
+    end
+
+    def _attr_value(value)
+      case value
+      when Symbol
+	value.to_s
+      else
+	_escape_quote(value.to_s)
       end
     end