swivel 0.0.146 → 0.0.149

data/vendor/activesupport-2.0.2-/README

@@ -0,0 +1,43 @@
+= Active Support -- Utility classes and standard library extensions from Rails
+
+Active Support is a collection of various utility classes and standard library extensions that were found useful
+for Rails. All these additions have hence been collected in this bundle as way to gather all that sugar that makes
+Ruby sweeter.
+
+
+== Download
+
+The latest version of Active Support can be found at
+
+* http://rubyforge.org/project/showfiles.php?group_id=182
+
+Documentation can be found at 
+
+* http://as.rubyonrails.com
+
+
+== Installation
+
+The preferred method of installing Active Support is through its GEM file. You'll need to have
+RubyGems[http://rubygems.rubyforge.org/wiki/wiki.pl] installed for that, though. If you have it,
+then use:
+
+  % [sudo] gem install activesupport-1.0.0.gem
+
+
+== License
+
+Active Support is released under the MIT license.
+
+
+== Support
+
+The Active Support homepage is http://www.rubyonrails.com. You can find the Active Support
+RubyForge page at http://rubyforge.org/projects/activesupport. And as Jim from Rake says:
+
+   Feel free to submit commits or feature requests.  If you send a patch,
+   remember to update the corresponding unit tests.  If fact, I prefer
+   new feature to be submitted in the form of new unit tests.
+
+For other information, feel free to ask on the ruby-talk mailing list
+(which is mirrored to comp.lang.ruby) or contact mailto:david@loudthinking.com.

data/vendor/activesupport-2.0.2-/lib/active_support.rb

@@ -0,0 +1,49 @@
+#--
+# Copyright (c) 2005 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'active_support/vendor'
+require 'active_support/basic_object'
+require 'active_support/inflector'
+
+require 'active_support/core_ext'
+
+require 'active_support/clean_logger'
+require 'active_support/buffered_logger'
+
+require 'active_support/dependencies'
+require 'active_support/deprecation'
+
+require 'active_support/ordered_options'
+require 'active_support/option_merger'
+
+require 'active_support/values/time_zone'
+require 'active_support/duration'
+
+require 'active_support/json'
+
+require 'active_support/multibyte'
+
+require 'active_support/testing'
+

data/vendor/activesupport-2.0.2-/lib/active_support/basic_object.rb

@@ -0,0 +1,5 @@
+# Ruby 1.9 introduces BasicObject. Use Builder's BlankSlate until then.
+unless defined? BasicObject
+  require 'blankslate'
+  BasicObject = BlankSlate
+end

data/vendor/activesupport-2.0.2-/lib/active_support/buffered_logger.rb

@@ -0,0 +1,107 @@
+module ActiveSupport
+  # Inspired by the buffered logger idea by Ezra
+  class BufferedLogger
+    module Severity
+      DEBUG   = 0
+      INFO    = 1
+      WARN    = 2
+      ERROR   = 3
+      FATAL   = 4
+      UNKNOWN = 5
+    end
+    include Severity
+
+    MAX_BUFFER_SIZE = 1000
+
+    # Set to false to disable the silencer
+    cattr_accessor :silencer
+    self.silencer = true
+
+    # Silences the logger for the duration of the block.
+    def silence(temporary_level = ERROR)
+      if silencer
+        begin
+          old_logger_level, self.level = level, temporary_level
+          yield self
+        ensure
+          self.level = old_logger_level
+        end
+      else
+        yield self
+      end
+    end
+
+    attr_accessor :level
+    attr_reader :auto_flushing
+    attr_reader :buffer
+
+    def initialize(log, level = DEBUG)
+      @level         = level
+      @buffer        = []
+      @auto_flushing = 1
+
+      if log.respond_to?(:write)
+        @log = log
+      elsif File.exist?(log)
+        @log = open(log, (File::WRONLY | File::APPEND))
+        @log.sync = true
+      else
+        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+        @log.sync = true
+        @log.write("# Logfile created on %s" % [Time.now.to_s])
+      end
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      return if @level > severity
+      message = (message || (block && block.call) || progname).to_s
+      # If a newline is necessary then create a new message ending with a newline.
+      # Ensures that the original message is not mutated.
+      message = "#{message}\n" unless message[-1] == ?\n
+      @buffer << message
+      auto_flush
+      message
+    end
+
+    for severity in Severity.constants
+      class_eval <<-EOT, __FILE__, __LINE__
+        def #{severity.downcase}(message = nil, progname = nil, &block)
+          add(#{severity}, message, progname, &block)
+        end
+
+        def #{severity.downcase}?
+          #{severity} >= @level
+        end
+      EOT
+    end
+
+    # Set the auto-flush period. Set to true to flush after every log message,
+    # to an integer to flush every N messages, or to false, nil, or zero to
+    # never auto-flush. If you turn auto-flushing off, be sure to regularly
+    # flush the log yourself -- it will eat up memory until you do.
+    def auto_flushing=(period)
+      @auto_flushing =
+        case period
+        when true;                1
+        when false, nil, 0;       MAX_BUFFER_SIZE
+        when Integer;             period
+        else raise ArgumentError, "Unrecognized auto_flushing period: #{period.inspect}"
+        end
+    end
+
+    def flush
+      @log.write(@buffer.slice!(0..-1).to_s) unless @buffer.empty?
+    end
+
+    def close
+      flush
+      @log.close if @log.respond_to?(:close)
+      @log = nil
+    end
+
+    protected
+      def auto_flush
+        flush if @buffer.size >= @auto_flushing
+      end
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/clean_logger.rb

@@ -0,0 +1,127 @@
+require 'logger'
+require 'active_support/core_ext/class/attribute_accessors'
+
+# Extensions to the built in Ruby logger.
+#
+# If you want to use the default log formatter as defined in the Ruby core, then you 
+# will need to set the formatter for the logger as in:
+#
+#   logger.formatter = Formatter.new
+#
+# You can then specify the datetime format, for example:
+#
+#   logger.datetime_format = "%Y-%m-%d"
+#
+# Note: This logger is deprecated in favor of ActiveSupport::BufferedLogger
+class Logger
+  # Set to false to disable the silencer
+  cattr_accessor :silencer
+  self.silencer = true
+  
+  # Silences the logger for the duration of the block.
+  def silence(temporary_level = Logger::ERROR)
+    if silencer
+      begin
+        old_logger_level, self.level = level, temporary_level
+        yield self
+      ensure
+        self.level = old_logger_level
+      end
+    else
+      yield self
+    end
+  end
+  
+  alias :old_datetime_format= :datetime_format=
+  # Logging date-time format (string passed to +strftime+). Ignored if the formatter
+  # does not respond to datetime_format=.
+  def datetime_format=(datetime_format)
+    formatter.datetime_format = datetime_format if formatter.respond_to?(:datetime_format=)
+  end
+  
+  alias :old_datetime_format :datetime_format
+  # Get the logging datetime format. Returns nil if the formatter does not support
+  # datetime formatting.
+  def datetime_format
+    formatter.datetime_format if formatter.respond_to?(:datetime_format)
+  end
+  
+  alias :old_formatter :formatter if method_defined?(:formatter)
+  # Get the current formatter. The default formatter is a SimpleFormatter which only
+  # displays the log message
+  def formatter
+    @formatter ||= SimpleFormatter.new
+  end
+
+  unless const_defined? :Formatter
+    class Formatter
+      Format = "%s, [%s#%d] %5s -- %s: %s\n"
+
+      attr_accessor :datetime_format
+
+      def initialize
+        @datetime_format = nil
+      end
+
+      def call(severity, time, progname, msg)
+        Format % [severity[0..0], format_datetime(time), $$, severity, progname,
+        msg2str(msg)]
+      end
+
+      private
+        def format_datetime(time)
+          if @datetime_format.nil?
+            time.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % time.usec
+          else
+            time.strftime(@datetime_format)
+          end
+        end
+
+        def msg2str(msg)
+          case msg
+          when ::String
+            msg
+          when ::Exception
+            "#{ msg.message } (#{ msg.class })\n" <<
+            (msg.backtrace || []).join("\n")
+          else
+            msg.inspect
+          end
+        end
+    end
+  end
+  
+  # Simple formatter which only displays the message.
+  class SimpleFormatter < Logger::Formatter
+    # This method is invoked when a log event occurs
+    def call(severity, timestamp, progname, msg)
+      "#{String === msg ? msg : msg.inspect}\n"
+    end
+  end
+
+  private
+    alias old_format_message format_message
+
+    # Ruby 1.8.3 transposed the msg and progname arguments to format_message.
+    # We can't test RUBY_VERSION because some distributions don't keep Ruby
+    # and its standard library in sync, leading to installations of Ruby 1.8.2
+    # with Logger from 1.8.3 and vice versa.
+    if method_defined?(:formatter=)
+      def format_message(severity, timestamp, progname, msg)
+        formatter.call(severity, timestamp, progname, msg)
+      end
+    else
+      def format_message(severity, timestamp, msg, progname)
+        formatter.call(severity, timestamp, progname, msg)
+      end
+      
+      attr_writer :formatter
+      public :formatter=
+
+      alias old_format_datetime format_datetime
+      def format_datetime(datetime) datetime end
+
+      alias old_msg2str msg2str
+      def msg2str(msg) msg end
+    end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext.rb

@@ -0,0 +1,4 @@
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "active_support/core_ext/#{filename}"
+end

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext/array.rb

@@ -0,0 +1,13 @@
+require 'active_support/core_ext/array/access'
+require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/array/grouping'
+require 'active_support/core_ext/array/random_access'
+
+class Array #:nodoc:
+  include ActiveSupport::CoreExtensions::Array::Access
+  include ActiveSupport::CoreExtensions::Array::Conversions
+  include ActiveSupport::CoreExtensions::Array::ExtractOptions
+  include ActiveSupport::CoreExtensions::Array::Grouping
+  include ActiveSupport::CoreExtensions::Array::RandomAccess
+end

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext/array/access.rb

@@ -0,0 +1,28 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      # Makes it easier to access parts of an array.
+      module Access
+        # Returns the remaining of the array from the +position+.
+        #
+        # Examples: 
+        #   %w( a b c d ).from(0)  # => %w( a b c d )
+        #   %w( a b c d ).from(2)  # => %w( c d )
+        #   %w( a b c d ).from(10) # => nil
+        def from(position)
+          self[position..-1]
+        end
+        
+        # Returns the beginning of the array up to the +position+.
+        #
+        # Examples: 
+        #   %w( a b c d ).to(0)  # => %w( a )
+        #   %w( a b c d ).to(2)  # => %w( a b c )
+        #   %w( a b c d ).to(10) # => %w( a b c d )
+        def to(position)
+          self[0..position]
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext/array/conversions.rb

@@ -0,0 +1,94 @@
+require 'builder'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      module Conversions
+        # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
+        # * <tt>:connector</tt> - The word used to join the last element in arrays with two or more elements (default: "and")
+        # * <tt>:skip_last_comma</tt> - Set to true to return "a, b and c" instead of "a, b, and c".
+        def to_sentence(options = {})
+          options.assert_valid_keys(:connector, :skip_last_comma)
+          options.reverse_merge! :connector => 'and', :skip_last_comma => false
+          options[:connector] = "#{options[:connector]} " unless options[:connector].nil? || options[:connector].strip == ''
+
+          case length
+            when 0
+              ""
+            when 1
+              self[0].to_s
+            when 2
+              "#{self[0]} #{options[:connector]}#{self[1]}"
+            else
+              "#{self[0...-1].join(', ')}#{options[:skip_last_comma] ? '' : ','} #{options[:connector]}#{self[-1]}"
+          end
+        end
+
+        # Calls to_param on all its elements and joins the result with slashes. This is used by url_for in Action Pack. 
+        def to_param
+          map(&:to_param).join '/'
+        end
+
+        # Converts an array into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
+        # param name.
+        #
+        # ==== Example:
+        #   ['Rails', 'coding'].to_query('hobbies') => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
+        def to_query(key)
+          collect { |value| value.to_query("#{key}[]") } * '&'
+        end
+
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            alias_method :to_default_s, :to_s
+            alias_method :to_s, :to_formatted_s
+          end
+        end
+
+        def to_formatted_s(format = :default)
+          case format
+            when :db
+              if respond_to?(:empty?) && self.empty?
+                "null"
+              else
+                collect { |element| element.id }.join(",")
+              end
+            else
+              to_default_s
+          end
+        end
+
+        def to_xml(options = {})
+          raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
+
+          options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
+          options[:children] ||= options[:root].singularize
+          options[:indent]   ||= 2
+          options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+          root     = options.delete(:root).to_s
+          children = options.delete(:children)
+
+          if !options.has_key?(:dasherize) || options[:dasherize]
+            root = root.dasherize
+          end
+
+          options[:builder].instruct! unless options.delete(:skip_instruct)
+
+          opts = options.merge({ :root => children })
+
+          xml = options[:builder]
+          if empty?
+            xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
+          else
+            xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) {
+              yield xml if block_given?
+              each { |e| e.to_xml(opts.merge!({ :skip_instruct => true })) }
+            }
+          end
+        end
+
+      end
+    end
+  end
+end