radiant 0.5.2 → 0.6.0

data/vendor/rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler_proc.rb

@@ -0,0 +1,43 @@
+# 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 #:nodoc:
+  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/vendor/rails/activesupport/lib/active_support/option_merger.rb

@@ -0,0 +1,25 @@
+module ActiveSupport
+  class OptionMerger #:nodoc:
+    instance_methods.each do |method| 
+      undef_method(method) if method !~ /^(__|instance_eval|class)/
+    end
+    
+    def initialize(context, options)
+      @context, @options = context, options
+    end
+    
+    private
+      def method_missing(method, *arguments, &block)
+        merge_argument_options! arguments
+        @context.send(method, *arguments, &block)
+      end
+      
+      def merge_argument_options!(arguments)
+        arguments << if arguments.last.respond_to? :to_hash
+          @options.merge(arguments.pop)
+        else
+          @options.dup
+        end  
+      end
+  end
+end

data/vendor/rails/activesupport/lib/active_support/ordered_options.rb

@@ -0,0 +1,44 @@
+# 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
+
+    def [](key)
+      pair = assoc(key)
+      pair ? pair.last : nil
+    end
+
+    def keys
+      collect { |key, value| key }
+    end
+
+    def values
+      collect { |key, value| value }
+    end
+  end
+end
+
+class OrderedOptions < ActiveSupport::OrderedHash #:nodoc:
+  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

data/vendor/rails/activesupport/lib/active_support/reloadable.rb

@@ -0,0 +1,60 @@
+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 #:nodoc:
+  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?) do
+            ActiveSupport::Deprecation.warn "Reloadable has been deprecated and reloadable? has no effect", caller
+            true
+          end
+        end
+      end
+    end
+    
+    def reloadable_classes
+      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 #:nodoc:
+    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
+        ActiveSupport::Deprecation.warn "Reloadable has been deprecated and reloadable? has no effect", caller
+        base != self
+      end
+    end
+  end
+  
+  module Deprecated #:nodoc:
+    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/vendor/rails/activesupport/lib/active_support/values/time_zone.rb

@@ -0,0 +1,180 @@
+# A value object representing a time zone. A time zone is simply a named
+# offset (in seconds) from GMT. Note that two time zone objects are only
+# equivalent if they have both the same offset, and the same name.
+#
+# A TimeZone instance may be used to convert a Time value to the corresponding
+# time zone.
+#
+# The class also includes #all, which returns a list of all TimeZone objects.
+class TimeZone
+  include Comparable
+
+  attr_reader :name, :utc_offset
+
+  # Create a new TimeZone object with the given name and offset. The offset is
+  # the number of seconds that this time zone is offset from UTC (GMT). Seconds
+  # were chosen as the offset unit because that is the unit that Ruby uses
+  # to represent time zone offsets (see Time#utc_offset).
+  def initialize(name, utc_offset)
+    @name = name
+    @utc_offset = utc_offset
+  end
+
+  # Returns the offset of this time zone as a formatted string, of the
+  # format "+HH:MM". If the offset is zero, this returns the empty
+  # string. If +colon+ is false, a colon will not be inserted into the
+  # result.
+  def formatted_offset( colon=true )
+    return "" if utc_offset == 0
+    sign = (utc_offset < 0 ? -1 : 1)
+    hours = utc_offset.abs / 3600
+    minutes = (utc_offset.abs % 3600) / 60
+    "%+03d%s%02d" % [ hours * sign, colon ? ":" : "", minutes ]
+  end
+
+  # Compute and return the current time, in the time zone represented by
+  # +self+.
+  def now
+    adjust(Time.now)
+  end
+
+  # Return the current date in this time zone.
+  def today
+    now.to_date
+  end
+
+  # Adjust the given time to the time zone represented by +self+.
+  def adjust(time)
+    time = time.to_time
+    time + utc_offset - time.utc_offset
+  end
+
+  # Reinterprets the given time value as a time in the current time
+  # zone, and then adjusts it to return the corresponding time in the
+  # local time zone.
+  def unadjust(time)
+    time = Time.local(*time.to_time.to_a)
+    time - utc_offset + time.utc_offset
+  end
+
+  # Compare this time zone to the parameter. The two are comapred first on
+  # their offsets, and then by name.
+  def <=>(zone)
+    result = (utc_offset <=> zone.utc_offset)
+    result = (name <=> zone.name) if result == 0
+    result
+  end
+
+  # Returns a textual representation of this time zone.
+  def to_s
+    "(GMT#{formatted_offset}) #{name}"
+  end
+
+  @@zones = nil
+
+  class << self
+    # Create a new TimeZone instance with the given name and offset.
+    def create(name, offset)
+      zone = allocate
+      zone.send :initialize, name, offset
+      zone
+    end
+
+    # Return a TimeZone instance with the given name, or +nil+ if no
+    # such TimeZone instance exists. (This exists to support the use of
+    # this class with the #composed_of macro.)
+    def new(name)
+      self[name]
+    end
+
+    # Return an array of all TimeZone objects. There are multiple TimeZone
+    # objects per time zone, in many cases, to make it easier for users to
+    # find their own time zone.
+    def all
+      unless @@zones
+        @@zones = []
+        [[-43_200, "International Date Line West" ],
+         [-39_600, "Midway Island", "Samoa" ],
+         [-36_000, "Hawaii" ],
+         [-32_400, "Alaska" ],
+         [-28_800, "Pacific Time (US & Canada)", "Tijuana" ],
+         [-25_200, "Mountain Time (US & Canada)", "Chihuahua", "La Paz",
+                   "Mazatlan", "Arizona" ],
+         [-21_600, "Central Time (US & Canada)", "Saskatchewan", "Guadalajara",
+                   "Mexico City", "Monterrey", "Central America" ],
+         [-18_000, "Eastern Time (US & Canada)", "Indiana (East)", "Bogota",
+                   "Lima", "Quito" ],
+         [-14_400, "Atlantic Time (Canada)", "Caracas", "La Paz", "Santiago" ],
+         [-12_600, "Newfoundland" ],
+         [-10_800, "Brasilia", "Buenos Aires", "Georgetown", "Greenland" ],
+         [ -7_200, "Mid-Atlantic" ],
+         [ -3_600, "Azores", "Cape Verde Is." ],
+         [      0, "Dublin", "Edinburgh", "Lisbon", "London", "Casablanca",
+                   "Monrovia" ],
+         [  3_600, "Belgrade", "Bratislava", "Budapest", "Ljubljana", "Prague",
+                   "Sarajevo", "Skopje", "Warsaw", "Zagreb", "Brussels",
+                   "Copenhagen", "Madrid", "Paris", "Amsterdam", "Berlin",
+                   "Bern", "Rome", "Stockholm", "Vienna",
+                   "West Central Africa" ],
+         [  7_200, "Bucharest", "Cairo", "Helsinki", "Kyev", "Riga", "Sofia",
+                   "Tallinn", "Vilnius", "Athens", "Istanbul", "Minsk",
+                   "Jerusalem", "Harare", "Pretoria" ],
+         [ 10_800, "Moscow", "St. Petersburg", "Volgograd", "Kuwait", "Riyadh",
+                   "Nairobi", "Baghdad" ],
+         [ 12_600, "Tehran" ],
+         [ 14_400, "Abu Dhabi", "Muscat", "Baku", "Tbilisi", "Yerevan" ],
+         [ 16_200, "Kabul" ],
+         [ 18_000, "Ekaterinburg", "Islamabad", "Karachi", "Tashkent" ],
+         [ 19_800, "Chennai", "Kolkata", "Mumbai", "New Delhi" ],
+         [ 20_700, "Kathmandu" ],
+         [ 21_600, "Astana", "Dhaka", "Sri Jayawardenepura", "Almaty",
+                   "Novosibirsk" ],
+         [ 23_400, "Rangoon" ],
+         [ 25_200, "Bangkok", "Hanoi", "Jakarta", "Krasnoyarsk" ],
+         [ 28_800, "Beijing", "Chongqing", "Hong Kong", "Urumqi",
+                   "Kuala Lumpur", "Singapore", "Taipei", "Perth", "Irkutsk",
+                   "Ulaan Bataar" ],
+         [ 32_400, "Seoul", "Osaka", "Sapporo", "Tokyo", "Yakutsk" ],
+         [ 34_200, "Darwin", "Adelaide" ],
+         [ 36_000, "Canberra", "Melbourne", "Sydney", "Brisbane", "Hobart",
+                   "Vladivostok", "Guam", "Port Moresby" ],
+         [ 39_600, "Magadan", "Solomon Is.", "New Caledonia" ],
+         [ 43_200, "Fiji", "Kamchatka", "Marshall Is.", "Auckland",
+                   "Wellington" ],
+         [ 46_800, "Nuku'alofa" ]].
+        each do |offset, *places|
+          places.each { |place| @@zones << create(place, offset).freeze }
+        end
+        @@zones.sort!
+      end
+      @@zones
+    end
+
+    # Locate a specific time zone object. If the argument is a string, it
+    # is interpreted to mean the name of the timezone to locate. If it is a
+    # numeric value it is either the hour offset, or the second offset, of the
+    # timezone to find. (The first one with that offset will be returned.)
+    # Returns +nil+ if no such time zone is known to the system.
+    def [](arg)
+      case arg
+        when String
+          all.find { |z| z.name == arg }
+        when Numeric
+          arg *= 3600 if arg.abs <= 13
+          all.find { |z| z.utc_offset == arg.to_i }
+        else
+          raise ArgumentError, "invalid argument to TimeZone[]: #{arg.inspect}"
+      end
+    end
+
+    # A regular expression that matches the names of all time zones in
+    # the USA.
+    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.
+    def us_zones
+      all.find_all { |z| z.name =~ US_ZONES }
+    end
+  end
+end

data/vendor/rails/activesupport/lib/active_support/vendor/builder.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+#--
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+require 'builder/xmlmarkup'
+require 'builder/xmlevents'

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

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+module Builder #:nodoc:
+
+  # BlankSlate provides an abstract base class with no predefined
+  # 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
+    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)/
+      end
+    end
+
+    instance_methods.each { |m| hide(m) }
+  end
+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
+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
+      Builder::BlankSlate.hide(name)
+    end
+  end
+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
+      Builder::BlankSlate.hide(name)
+    end
+  end
+end

data/vendor/rails/activesupport/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