nbudin-castronaut 0.7.5

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

@@ -0,0 +1,23 @@
+module ActiveSupport
+  # If true, use ISO 8601 format for dates and times. Otherwise, fall back to the Active Support legacy format.
+  mattr_accessor :use_standard_json_time_format
+
+  class << self
+    def escape_html_entities_in_json
+      @escape_html_entities_in_json
+    end
+
+    def escape_html_entities_in_json=(value)
+      ActiveSupport::JSON::Encoding.escape_regex = \
+        if value
+          /[\010\f\n\r\t"\\><&]/
+        else
+          /[\010\f\n\r\t"\\]/
+        end
+      @escape_html_entities_in_json = value
+    end
+  end
+end
+
+require 'active_support/json/encoding'
+require 'active_support/json/decoding'

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

@@ -0,0 +1,63 @@
+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
+            left_pos  = [-1].push(*marks)
+            right_pos = marks << json.length
+            output    = []
+            left_pos.each_with_index do |left, i|
+              output << json[left.succ..right_pos[i]]
+            end
+            output = output * " "
+            
+            times.each { |i| output[i-1] = ' ' }
+            output.gsub!(/\\\//, '/')
+            output
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+class Date
+  # Returns a JSON string representing the date. If ActiveSupport.use_standard_json_time_format is set to true, the
+  # ISO 8601 format is used.
+  #
+  # ==== Examples:
+  #
+  #   # With ActiveSupport.use_standard_json_time_format = true
+  #   Date.new(2005,2,1).to_json
+  #   # => "2005-02-01"
+  #
+  #   # With ActiveSupport.use_standard_json_time_format = false
+  #   Date.new(2005,2,1).to_json
+  #   # => "2005/02/01"
+  def to_json(options = nil)
+    if ActiveSupport.use_standard_json_time_format
+      %("#{strftime("%Y-%m-%d")}")
+    else
+      %("#{strftime("%Y/%m/%d")}")
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+class DateTime
+  # Returns a JSON string representing the datetime. If ActiveSupport.use_standard_json_time_format is set to true, the
+  # ISO 8601 format is used.
+  #
+  # ==== Examples:
+  #
+  #   # With ActiveSupport.use_standard_json_time_format = true
+  #   DateTime.civil(2005,2,1,15,15,10).to_json
+  #   # => "2005-02-01T15:15:10+00:00"
+  #
+  #   # With ActiveSupport.use_standard_json_time_format = false
+  #   DateTime.civil(2005,2,1,15,15,10).to_json
+  #   # => "2005/02/01 15:15:10 +0000"
+  def to_json(options = nil)
+    if ActiveSupport.use_standard_json_time_format
+      xmlschema.inspect
+    else
+      strftime('"%Y/%m/%d %H:%M:%S %z"')
+    end
+  end
+end

data/vendor/activesupport/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/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/lib/active_support/json/encoders/hash.rb

@@ -0,0 +1,47 @@
+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/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/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/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/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/lib/active_support/json/encoders/string.rb

@@ -0,0 +1,36 @@
+module ActiveSupport
+  module JSON
+    module Encoding
+      mattr_accessor :escape_regex
+
+      ESCAPED_CHARS = {
+        "\010" =>  '\b',
+        "\f"   =>  '\f',
+        "\n"   =>  '\n',
+        "\r"   =>  '\r',
+        "\t"   =>  '\t',
+        '"'    =>  '\"',
+        '\\'   =>  '\\\\',
+        '>'    =>  '\u003E',
+        '<'    =>  '\u003C',
+        '&'    =>  '\u0026'
+      }
+    end
+  end
+end
+
+ActiveSupport.escape_html_entities_in_json = true
+
+class String
+  def to_json(options = nil) #:nodoc:
+    json = '"' + gsub(ActiveSupport::JSON::Encoding.escape_regex) { |s|
+      ActiveSupport::JSON::Encoding::ESCAPED_CHARS[s]
+    }
+    json.force_encoding('ascii-8bit') if respond_to?(:force_encoding)
+    json.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/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/lib/active_support/json/encoders/time.rb

@@ -0,0 +1,21 @@
+class Time
+  # Returns a JSON string representing the time. If ActiveSupport.use_standard_json_time_format is set to true, the
+  # ISO 8601 format is used.
+  #
+  # ==== Examples:
+  #
+  #   # With ActiveSupport.use_standard_json_time_format = true
+  #   Time.utc(2005,2,1,15,15,10).to_json
+  #   # => "2005-02-01T15:15:10Z"
+  #
+  #   # With ActiveSupport.use_standard_json_time_format = false
+  #   Time.utc(2005,2,1,15,15,10).to_json
+  #   # => "2005/02/01 15:15:10 +0000"
+  def to_json(options = nil)
+    if ActiveSupport.use_standard_json_time_format
+      xmlschema.inspect
+    else
+      %("#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)}")
+    end
+  end
+end

data/vendor/activesupport/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/lib/active_support/json/encoding.rb

@@ -0,0 +1,37 @@
+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/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/lib/active_support/locale/en.yml

@@ -0,0 +1,32 @@
+en:
+  date:
+    formats:
+      # Use the strftime parameters for formats.
+      # When no format has been given, it uses default.
+      # You can provide other formats here if you like!
+      default: "%Y-%m-%d"
+      short: "%b %d"
+      long: "%B %d, %Y"
+      
+    day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
+    abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
+      
+    # Don't forget the nil at the beginning; there's no such thing as a 0th month
+    month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
+    abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
+    # Used in date_select and datime_select.
+    order: [ :year, :month, :day ]
+
+  time:
+    formats:
+      default: "%a, %d %b %Y %H:%M:%S %z"
+      short: "%d %b %H:%M"
+      long: "%B %d, %Y %H:%M"
+    am: "am"
+    pm: "pm"
+      
+# Used in array.to_sentence.
+  support:
+    array:
+      sentence_connector: "and"
+      skip_last_comma: false

data/vendor/activesupport/lib/active_support/memoizable.rb

@@ -0,0 +1,82 @@
+module ActiveSupport
+  module Memoizable
+    MEMOIZED_IVAR = Proc.new do |symbol|
+      "@_memoized_#{symbol.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')}".to_sym
+    end
+
+    module Freezable
+      def self.included(base)
+        base.class_eval do
+          unless base.method_defined?(:freeze_without_memoizable)
+            alias_method_chain :freeze, :memoizable
+          end
+        end
+      end
+
+      def freeze_with_memoizable
+        memoize_all unless frozen?
+        freeze_without_memoizable
+      end
+
+      def memoize_all
+        methods.each do |m|
+          if m.to_s =~ /^_unmemoized_(.*)/
+            if method(m).arity == 0
+              __send__($1)
+            else
+              ivar = MEMOIZED_IVAR.call($1)
+              instance_variable_set(ivar, {})
+            end
+          end
+        end
+      end
+
+      def unmemoize_all
+        methods.each do |m|
+          if m.to_s =~ /^_unmemoized_(.*)/
+            ivar = MEMOIZED_IVAR.call($1)
+            instance_variable_get(ivar).clear if instance_variable_defined?(ivar)
+          end
+        end
+      end
+    end
+
+    def memoize(*symbols)
+      symbols.each do |symbol|
+        original_method = :"_unmemoized_#{symbol}"
+        memoized_ivar = MEMOIZED_IVAR.call(symbol)
+
+        class_eval <<-EOS, __FILE__, __LINE__
+          include Freezable
+
+          raise "Already memoized #{symbol}" if method_defined?(:#{original_method})
+          alias #{original_method} #{symbol}
+
+          if instance_method(:#{symbol}).arity == 0
+            def #{symbol}(reload = false)
+              if reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?
+                #{memoized_ivar} = [#{original_method}.freeze]
+              end
+              #{memoized_ivar}[0]
+            end
+          else
+            def #{symbol}(*args)
+              #{memoized_ivar} ||= {} unless frozen?
+              reload = args.pop if args.last == true || args.last == :reload
+
+              if defined?(#{memoized_ivar}) && #{memoized_ivar}
+                if !reload && #{memoized_ivar}.has_key?(args)
+                  #{memoized_ivar}[args]
+                elsif #{memoized_ivar}
+                  #{memoized_ivar}[args] = #{original_method}(*args).freeze
+                end
+              else
+                #{original_method}(*args)
+              end
+            end
+          end
+        EOS
+      end
+    end
+  end
+end