swivel 0.0.146 → 0.0.149

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

@@ -0,0 +1,31 @@
+require 'active_support/json/encoding'
+require 'active_support/json/decoding'
+
+module ActiveSupport
+  module JSON
+    RESERVED_WORDS = %w(
+      abstract      delete        goto          private       transient
+      boolean       do            if            protected     try
+      break         double        implements    public        typeof
+      byte          else          import        return        var
+      case          enum          in            short         void
+      catch         export        instanceof    static        volatile
+      char          extends       int           super         while
+      class         final         interface     switch        with
+      const         finally       long          synchronized
+      continue      float         native        this
+      debugger      for           new           throw
+      default       function      package       throws
+    ) #:nodoc:
+
+    class << self
+      def valid_identifier?(key) #:nodoc:
+        key.to_s =~ /^[[:alpha:]_$][[:alnum:]_$]*$/ && !reserved_word?(key)
+      end
+
+      def reserved_word?(key) #:nodoc:
+        RESERVED_WORDS.include?(key.to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'yaml'
+require 'strscan'
+
+module ActiveSupport
+  module JSON
+    class ParseError < StandardError
+    end
+    
+    class << self
+      # Converts a JSON string into a Ruby object.
+      def decode(json)
+        YAML.load(convert_json_to_yaml(json))
+      rescue ArgumentError => e
+        raise ParseError, "Invalid JSON string"
+      end
+      
+      protected
+        # matches YAML-formatted dates
+        DATE_REGEX = /^\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[ \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?$/
+
+        # Ensure that ":" and "," are always followed by a space
+        def convert_json_to_yaml(json) #:nodoc:
+          scanner, quoting, marks, pos, times = StringScanner.new(json), false, [], nil, []
+          while scanner.scan_until(/(\\['"]|['":,\\]|\\.)/)
+            case char = scanner[1]
+            when '"', "'"
+              if !quoting
+                quoting = char
+                pos = scanner.pos
+              elsif quoting == char
+                if json[pos..scanner.pos-2] =~ DATE_REGEX
+                  # found a date, track the exact positions of the quotes so we can remove them later.
+                  # oh, and increment them for each current mark, each one is an extra padded space that bumps
+                  # the position in the final yaml output
+                  total_marks = marks.size
+                  times << pos+total_marks << scanner.pos+total_marks
+                end
+                quoting = false
+              end
+            when ":",","
+              marks << scanner.pos - 1 unless quoting
+            end
+          end
+
+          if marks.empty?
+            json.gsub(/\\\//, '/')
+          else
+            # FIXME: multiple slow enumerations
+            output = ([0] + marks.map(&:succ)).
+                      zip(marks + [json.length]).
+                      map { |left, right| json[left..right] }.
+                      join(" ")
+            times.each { |i| output[i-1] = ' ' }
+            output.gsub!(/\\\//, '/')
+            output
+          end
+        end
+    end
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/date.rb

@@ -0,0 +1,5 @@
+class Date
+  def to_json(options = nil) #:nodoc:
+    %("#{strftime("%Y/%m/%d")}")
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/date_time.rb

@@ -0,0 +1,5 @@
+class DateTime
+  def to_json(options = nil) #:nodoc:
+    %("#{strftime("%Y/%m/%d %H:%M:%S %z")}")
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/enumerable.rb

@@ -0,0 +1,12 @@
+module Enumerable
+  # Returns a JSON string representing the enumerable. Any +options+
+  # given will be passed on to its elements. For example:
+  #
+  # users = User.find(:all)
+  # users.to_json(:only => :name)
+  #
+  # will pass the <tt>:only => :name</tt> option to each user.
+  def to_json(options = {}) #:nodoc:
+    "[#{map { |value| ActiveSupport::JSON.encode(value, options) } * ', '}]"
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/false_class.rb

@@ -0,0 +1,5 @@
+class FalseClass
+  def to_json(options = nil) #:nodoc:
+    'false'
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/hash.rb

@@ -0,0 +1,50 @@
+class Hash
+  # Returns a JSON string representing the hash.
+  #
+  # Without any +options+, the returned JSON string will include all
+  # the hash keys. For example:
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json
+  #
+  #   {"name": "Konata Izumi", 1: 2, "age": 16}
+  #
+  # The keys in the JSON string are unordered due to the nature of hashes.
+  #
+  # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the
+  # attributes included, and will accept 1 or more hash keys to include/exclude.
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json(:only => [:name, 'age'])
+  #
+  #   {"name": "Konata Izumi", "age": 16}
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json(:except => 1)
+  #
+  #   {"name": "Konata Izumi", "age": 16}
+  #
+  # The +options+ also filter down to any hash values. This is particularly
+  # useful for converting hashes containing ActiveRecord objects or any object
+  # that responds to options in their <tt>to_json</tt> method. For example:
+  #
+  #   users = User.find(:all)
+  #   { :users => users, :count => users.size }.to_json(:include => :posts)
+  #
+  # would pass the <tt>:include => :posts</tt> option to <tt>users</tt>,
+  # allowing the posts association in the User model to be converted to JSON
+  # as well.
+  def to_json(options = {}) #:nodoc:
+    hash_keys = self.keys
+
+    if options[:except]
+      hash_keys = hash_keys - Array(options[:except])
+    elsif options[:only]
+      hash_keys = hash_keys & Array(options[:only])
+    end
+
+    returning result = '{' do
+      result << hash_keys.map do |key|
+        "#{ActiveSupport::JSON.encode(key)}: #{ActiveSupport::JSON.encode(self[key], options)}"
+      end * ', '
+      result << '}'
+    end
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/nil_class.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def to_json(options = nil) #:nodoc:
+    'null'
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/numeric.rb

@@ -0,0 +1,5 @@
+class Numeric
+  def to_json(options = nil) #:nodoc:
+    to_s
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/object.rb

@@ -0,0 +1,6 @@
+class Object
+  # Dumps object in JSON (JavaScript Object Notation).  See www.json.org for more info.
+  def to_json(options = {})
+    ActiveSupport::JSON.encode(instance_values, options)
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/regexp.rb

@@ -0,0 +1,5 @@
+class Regexp
+  def to_json(options = nil) #:nodoc:
+    inspect
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/string.rb

@@ -0,0 +1,30 @@
+module ActiveSupport
+  module JSON
+    module Encoding
+      ESCAPED_CHARS = {
+        "\010" =>  '\b',
+        "\f"   =>  '\f',
+        "\n"   =>  '\n',
+        "\r"   =>  '\r',
+        "\t"   =>  '\t',
+        '"'    =>  '\"',
+        '\\'   =>  '\\\\',
+        '>'    =>  '\u003E',
+        '<'    =>  '\u003C',
+        '&'    =>  '\u0026'
+      }
+    end
+  end
+end
+
+class String
+  def to_json(options = nil) #:nodoc:
+    '"' + gsub(/[\010\f\n\r\t"\\><&]/) { |s|
+      ActiveSupport::JSON::Encoding::ESCAPED_CHARS[s]
+    }.gsub(/([\xC0-\xDF][\x80-\xBF]|
+             [\xE0-\xEF][\x80-\xBF]{2}|
+             [\xF0-\xF7][\x80-\xBF]{3})+/nx) { |s|
+      s.unpack("U*").pack("n*").unpack("H*")[0].gsub(/.{4}/, '\\\\u\&')
+    } + '"'
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/symbol.rb

@@ -0,0 +1,5 @@
+class Symbol
+  def to_json(options = {}) #:nodoc:
+    ActiveSupport::JSON.encode(to_s, options)
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/time.rb

@@ -0,0 +1,5 @@
+class Time
+  def to_json(options = nil) #:nodoc:
+    to_datetime.to_json(options)
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/json/encoders/true_class.rb

@@ -0,0 +1,5 @@
+class TrueClass
+  def to_json(options = nil) #:nodoc:
+    'true'
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'active_support/json/variable'
+
+require 'active_support/json/encoders/object' # Require explicitly for rdoc.
+Dir["#{File.dirname(__FILE__)}/encoders/**/*.rb"].each do |file|
+  basename = File.basename(file, '.rb')
+  unless basename == 'object'
+    require "active_support/json/encoders/#{basename}"
+  end
+end
+
+module ActiveSupport
+  module JSON
+    class CircularReferenceError < StandardError
+    end
+
+    class << self
+      REFERENCE_STACK_VARIABLE = :json_reference_stack #:nodoc:
+
+      # Converts a Ruby object into a JSON string.
+      def encode(value, options = {})
+        raise_on_circular_reference(value) do
+          value.send(:to_json, options)
+        end
+      end
+
+      protected
+        def raise_on_circular_reference(value) #:nodoc:
+          stack = Thread.current[REFERENCE_STACK_VARIABLE] ||= []
+          raise CircularReferenceError, 'object references itself' if
+            stack.include? value
+          stack << value
+          yield
+        ensure
+          stack.pop
+        end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module ActiveSupport
+  module JSON
+    # A string that returns itself as its JSON-encoded form.
+    class Variable < String
+      def to_json(options=nil)
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module ActiveSupport
+  module Multibyte #:nodoc:
+    DEFAULT_NORMALIZATION_FORM = :kc
+    NORMALIZATIONS_FORMS = [:c, :kc, :d, :kd]
+    UNICODE_VERSION = '5.0.0'
+  end
+end
+
+require 'active_support/multibyte/chars'

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

@@ -0,0 +1,141 @@
+require 'active_support/multibyte/handlers/utf8_handler'
+require 'active_support/multibyte/handlers/passthru_handler'
+
+# Encapsulates all the functionality related to the Chars proxy.
+module ActiveSupport::Multibyte #:nodoc:
+  # Chars enables you to work transparently with multibyte encodings in the Ruby String class without having extensive
+  # knowledge about the encoding. A Chars object accepts a string upon initialization and proxies String methods in an
+  # encoding safe manner. All the normal String methods are also implemented on the proxy.
+  #
+  # String methods are proxied through the Chars object, and can be accessed through the +chars+ method. Methods
+  # which would normally return a String object now return a Chars object so methods can be chained.
+  #
+  #   "The Perfect String  ".chars.downcase.strip.normalize #=> "the perfect string"
+  #
+  # Chars objects are perfectly interchangeable with String objects as long as no explicit class checks are made.
+  # If certain methods do explicitly check the class, call +to_s+ before you pass chars objects to them.
+  #
+  #   bad.explicit_checking_method "T".chars.downcase.to_s
+  #
+  # The actual operations on the string are delegated to handlers. Theoretically handlers can be implemented for
+  # any encoding, but the default handler handles UTF-8. This handler is set during initialization, if you want to
+  # use you own handler, you can set it on the Chars class. Look at the UTF8Handler source for an example how to
+  # implement your own handler. If you your own handler to work on anything but UTF-8 you probably also
+  # want to override Chars#handler.
+  #
+  #   ActiveSupport::Multibyte::Chars.handler = MyHandler
+  #
+  # Note that a few methods are defined on Chars instead of the handler because they are defined on Object or Kernel
+  # and method_missing can't catch them.
+  class Chars
+    
+    attr_reader :string # The contained string
+    alias_method :to_s, :string
+    
+    include Comparable
+    
+    # The magic method to make String and Chars comparable
+    def to_str
+      # Using any other ways of overriding the String itself will lead you all the way from infinite loops to
+      # core dumps. Don't go there.
+      @string
+    end
+    
+    # Make duck-typing with String possible
+    def respond_to?(method)
+      super || @string.respond_to?(method) || handler.respond_to?(method) ||
+        (method.to_s =~ /(.*)!/ && handler.respond_to?($1)) || false
+    end
+    
+    # Create a new Chars instance.
+    def initialize(str)
+      @string = str.respond_to?(:string) ? str.string : str
+    end
+    
+    # Returns -1, 0 or +1 depending on whether the Chars object is to be sorted before, equal or after the
+    # object on the right side of the operation. It accepts any object that implements +to_s+. See String.<=>
+    # for more details.
+    def <=>(other); @string <=> other.to_s; end
+    
+    # Works just like String#split, with the exception that the items in the resulting list are Chars
+    # instances instead of String. This makes chaining methods easier.
+    def split(*args)
+      @string.split(*args).map { |i| i.chars }
+    end
+    
+    # Gsub works exactly the same as gsub on a normal string.
+    def gsub(*a, &b); @string.gsub(*a, &b).chars; end
+    
+    # Like String.=~ only it returns the character offset (in codepoints) instead of the byte offset.
+    def =~(other)
+      handler.translate_offset(@string, @string =~ other)
+    end
+    
+    # Try to forward all undefined methods to the handler, when a method is not defined on the handler, send it to
+    # the contained string. Method_missing is also responsible for making the bang! methods destructive.
+    def method_missing(m, *a, &b)
+      begin
+        # Simulate methods with a ! at the end because we can't touch the enclosed string from the handlers.
+        if m.to_s =~ /^(.*)\!$/ && handler.respond_to?($1)
+          result = handler.send($1, @string, *a, &b)
+          if result == @string
+            result = nil
+          else
+            @string.replace result
+          end
+        elsif handler.respond_to?(m)
+          result = handler.send(m, @string, *a, &b)
+        else
+          result = @string.send(m, *a, &b)
+        end
+      rescue Handlers::EncodingError
+        @string.replace handler.tidy_bytes(@string)
+        retry
+      end
+      
+      if result.kind_of?(String)
+        result.chars
+      else
+        result
+      end
+    end
+    
+    # Set the handler class for the Char objects.
+    def self.handler=(klass)
+      @@handler = klass
+    end
+
+    # Returns the proper handler for the contained string depending on $KCODE and the encoding of the string. This
+    # method is used internally to always redirect messages to the proper classes depending on the context.
+    def handler
+      if utf8_pragma?
+        @@handler
+      else
+        ActiveSupport::Multibyte::Handlers::PassthruHandler
+      end
+    end
+
+    private
+      
+      # +utf8_pragma+ checks if it can send this string to the handlers. It makes sure @string isn't nil and $KCODE is
+      # set to 'UTF8'.
+      if RUBY_VERSION < '1.9'
+        def utf8_pragma?
+          !@string.nil? && ($KCODE == 'UTF8')
+        end
+      else
+        def utf8_pragma?
+          !@string.nil? && (Encoding.default_external == Encoding::UTF_8)
+        end
+      end
+  end
+end
+
+# When we can load the utf8proc library, override normalization with the faster methods
+begin
+  require 'utf8proc_native'
+  require 'active_support/multibyte/handlers/utf8_handler_proc'
+  ActiveSupport::Multibyte::Chars.handler = ActiveSupport::Multibyte::Handlers::UTF8HandlerProc
+rescue LoadError
+  ActiveSupport::Multibyte::Chars.handler = ActiveSupport::Multibyte::Handlers::UTF8Handler
+end