messagebus_ruby_api 0.4.0 → 0.4.4

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/json/backends/yaml.rb

@@ -0,0 +1,107 @@
+require 'active_support/core_ext/string/starts_ends_with'
+
+module ActiveSupport
+  module JSON
+    module Backends
+      module Yaml
+        ParseError = ::StandardError
+        extend self
+
+        EXCEPTIONS = [::ArgumentError] # :nodoc:
+        begin
+          require 'psych'
+          EXCEPTIONS << Psych::SyntaxError
+        rescue LoadError
+        end
+
+        # Parses a JSON string or IO and converts it into an object
+        def decode(json)
+          if json.respond_to?(:read)
+            json = json.read
+          end
+          YAML.load(convert_json_to_yaml(json))
+        rescue *EXCEPTIONS => e
+          raise ParseError, "Invalid JSON string: '%s'" % json
+        end
+
+        protected
+          # Ensure that ":" and "," are always followed by a space
+          def convert_json_to_yaml(json) #:nodoc:
+            require 'strscan' unless defined? ::StringScanner
+            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 valid_date?(json[pos..scanner.pos-2])
+                    # found a date, track the exact positions of the quotes so we can
+                    # overwrite them with spaces later.
+                    times << pos
+                  end
+                  quoting = false
+                end
+              when ":",","
+                marks << scanner.pos - 1 unless quoting
+              when "\\"
+                scanner.skip(/\\/)
+              end
+            end
+
+            if marks.empty?
+              json.gsub(/\\([\\\/]|u[[:xdigit:]]{4})/) do
+                ustr = $1
+                if ustr.start_with?('u')
+                  [ustr[1..-1].to_i(16)].pack("U")
+                elsif ustr == '\\'
+                  '\\\\'
+                else
+                  ustr
+                end
+              end
+            else
+              left_pos  = [-1].push(*marks)
+              right_pos = marks << scanner.pos + scanner.rest_size
+              output    = []
+              left_pos.each_with_index do |left, i|
+                scanner.pos = left.succ
+                chunk = scanner.peek(right_pos[i] - scanner.pos + 1)
+                # overwrite the quotes found around the dates with spaces
+                while times.size > 0 && times[0] <= right_pos[i]
+                  chunk.insert(times.shift - scanner.pos - 1, '! ')
+                end
+                chunk.gsub!(/\\([\\\/]|u[[:xdigit:]]{4})/) do
+                  ustr = $1
+                  if ustr.start_with?('u')
+                    [ustr[1..-1].to_i(16)].pack("U")
+                  elsif ustr == '\\'
+                    '\\\\'
+                  else
+                    ustr
+                  end
+                end
+                output << chunk
+              end
+              output = output * " "
+
+              output.gsub!(/\\\//, '/')
+              output
+            end
+          end
+
+        private
+          def valid_date?(date_string)
+            begin
+              date_string =~ DATE_REGEX && DateTime.parse(date_string)
+            rescue ArgumentError
+              false
+            end
+          end
+
+      end
+    end
+  end
+end
+

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/json/decoding.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/delegation'
+
+module ActiveSupport
+  # Look for and parse json strings that look like ISO 8601 times.
+  mattr_accessor :parse_json_times
+
+  module JSON
+    # Listed in order of preference.
+    DECODERS = %w(Yajl Yaml)
+
+    class << self
+      attr_reader :parse_error
+      delegate :decode, :to => :backend
+
+      def backend
+        set_default_backend unless defined?(@backend)
+        @backend
+      end
+
+      def backend=(name)
+        if name.is_a?(Module)
+          @backend = name
+        else
+          require "active_support/json/backends/#{name.to_s.downcase}"
+          @backend = ActiveSupport::JSON::Backends::const_get(name)
+        end
+        @parse_error = @backend::ParseError
+      end
+
+      def with_backend(name)
+        old_backend, self.backend = backend, name
+        yield
+      ensure
+        self.backend = old_backend
+      end
+
+      def set_default_backend
+        DECODERS.find do |name|
+          begin
+            self.backend = name
+            true
+          rescue LoadError
+            # Try next decoder.
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/json/encoding.rb

@@ -0,0 +1,279 @@
+require 'active_support/core_ext/object/to_json'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/deprecation'
+require 'active_support/json/variable'
+
+require 'bigdecimal'
+require 'active_support/core_ext/big_decimal/conversions' # for #to_s
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/object/instance_variables'
+require 'time'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/date_time/conversions'
+require 'active_support/core_ext/date/conversions'
+
+module ActiveSupport
+  class << self
+    delegate :use_standard_json_time_format, :use_standard_json_time_format=,
+      :escape_html_entities_in_json, :escape_html_entities_in_json=,
+      :to => :'ActiveSupport::JSON::Encoding'
+  end
+
+  module JSON
+    # matches YAML-formatted dates
+    DATE_REGEX = /^(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?))$/
+
+    # Dumps object in JSON (JavaScript Object Notation). See www.json.org for more info.
+    def self.encode(value, options = nil)
+      Encoding::Encoder.new(options).encode(value)
+    end
+
+    module Encoding #:nodoc:
+      class CircularReferenceError < StandardError; end
+
+      class Encoder
+        attr_reader :options
+
+        def initialize(options = nil)
+          @options = options
+          @seen = []
+        end
+
+        def encode(value, use_options = true)
+          check_for_circular_references(value) do
+            jsonified = use_options ? value.as_json(options_for(value)) : value.as_json
+            jsonified.encode_json(self)
+          end
+        end
+
+        # like encode, but only calls as_json, without encoding to string
+        def as_json(value)
+          check_for_circular_references(value) do
+            value.as_json(options_for(value))
+          end
+        end
+
+        def options_for(value)
+          if value.is_a?(Array) || value.is_a?(Hash)
+            # hashes and arrays need to get encoder in the options, so that they can detect circular references
+            (options || {}).merge(:encoder => self)
+          else
+            options
+          end
+        end
+
+        def escape(string)
+          Encoding.escape(string)
+        end
+
+        private
+          def check_for_circular_references(value)
+            if @seen.any? { |object| object.equal?(value) }
+              raise CircularReferenceError, 'object references itself'
+            end
+            @seen.unshift value
+            yield
+          ensure
+            @seen.shift
+          end
+      end
+
+
+      ESCAPED_CHARS = {
+        "\x00" => '\u0000', "\x01" => '\u0001', "\x02" => '\u0002',
+        "\x03" => '\u0003', "\x04" => '\u0004', "\x05" => '\u0005',
+        "\x06" => '\u0006', "\x07" => '\u0007', "\x0B" => '\u000B',
+        "\x0E" => '\u000E', "\x0F" => '\u000F', "\x10" => '\u0010',
+        "\x11" => '\u0011', "\x12" => '\u0012', "\x13" => '\u0013',
+        "\x14" => '\u0014', "\x15" => '\u0015', "\x16" => '\u0016',
+        "\x17" => '\u0017', "\x18" => '\u0018', "\x19" => '\u0019',
+        "\x1A" => '\u001A', "\x1B" => '\u001B', "\x1C" => '\u001C',
+        "\x1D" => '\u001D', "\x1E" => '\u001E', "\x1F" => '\u001F',
+        "\010" =>  '\b',
+        "\f"   =>  '\f',
+        "\n"   =>  '\n',
+        "\r"   =>  '\r',
+        "\t"   =>  '\t',
+        '"'    =>  '\"',
+        '\\'   =>  '\\\\',
+        '>'    =>  '\u003E',
+        '<'    =>  '\u003C',
+        '&'    =>  '\u0026' }
+
+      class << self
+        # If true, use ISO 8601 format for dates and times. Otherwise, fall back to the Active Support legacy format.
+        attr_accessor :use_standard_json_time_format
+
+        attr_accessor :escape_regex
+        attr_reader :escape_html_entities_in_json
+
+        def escape_html_entities_in_json=(value)
+          self.escape_regex = \
+            if @escape_html_entities_in_json = value
+              /[\x00-\x1F"\\><&]/
+            else
+              /[\x00-\x1F"\\]/
+            end
+        end
+
+        def escape(string)
+          if string.respond_to?(:force_encoding)
+            string = string.encode(::Encoding::UTF_8, :undef => :replace).force_encoding(::Encoding::BINARY)
+          end
+          json = string.
+            gsub(escape_regex) { |s| 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}/n, '\\\\u\&')
+          }
+          json = %("#{json}")
+          json.force_encoding(::Encoding::UTF_8) if json.respond_to?(:force_encoding)
+          json
+        end
+      end
+
+      self.use_standard_json_time_format = true
+      self.escape_html_entities_in_json  = false
+    end
+
+    CircularReferenceError = Deprecation::DeprecatedConstantProxy.new('ActiveSupport::JSON::CircularReferenceError', Encoding::CircularReferenceError)
+  end
+end
+
+class Object
+  def as_json(options = nil) #:nodoc:
+    if respond_to?(:to_hash)
+      to_hash
+    else
+      instance_values
+    end
+  end
+end
+
+class TrueClass
+  AS_JSON = ActiveSupport::JSON::Variable.new('true').freeze
+  def as_json(options = nil) AS_JSON end #:nodoc:
+end
+
+class FalseClass
+  AS_JSON = ActiveSupport::JSON::Variable.new('false').freeze
+  def as_json(options = nil) AS_JSON end #:nodoc:
+end
+
+class NilClass
+  AS_JSON = ActiveSupport::JSON::Variable.new('null').freeze
+  def as_json(options = nil) AS_JSON end #:nodoc:
+end
+
+class String
+  def as_json(options = nil) self end #:nodoc:
+  def encode_json(encoder) encoder.escape(self) end #:nodoc:
+end
+
+class Symbol
+  def as_json(options = nil) to_s end #:nodoc:
+end
+
+class Numeric
+  def as_json(options = nil) self end #:nodoc:
+  def encode_json(encoder) to_s end #:nodoc:
+end
+
+class BigDecimal
+  # A BigDecimal would be naturally represented as a JSON number. Most libraries,
+  # however, parse non-integer JSON numbers directly as floats. Clients using
+  # those libraries would get in general a wrong number and no way to recover
+  # other than manually inspecting the string with the JSON code itself.
+  #
+  # That's why a JSON string is returned. The JSON literal is not numeric, but if
+  # the other end knows by contract that the data is supposed to be a BigDecimal,
+  # it still has the chance to post-process the string and get the real value.
+  def as_json(options = nil) to_s end #:nodoc:
+end
+
+class Regexp
+  def as_json(options = nil) to_s end #:nodoc:
+end
+
+module Enumerable
+  def as_json(options = nil) to_a end #:nodoc:
+end
+
+class Array
+  def as_json(options = nil) #:nodoc:
+    # use encoder as a proxy to call as_json on all elements, to protect from circular references
+    encoder = options && options[:encoder] || ActiveSupport::JSON::Encoding::Encoder.new(options)
+    map { |v| encoder.as_json(v) }
+  end
+
+  def encode_json(encoder) #:nodoc:
+    # we assume here that the encoder has already run as_json on self and the elements, so we run encode_json directly
+    "[#{map { |v| v.encode_json(encoder) } * ','}]"
+  end
+end
+
+class Hash
+  def as_json(options = nil) #:nodoc:
+    # create a subset of the hash by applying :only or :except
+    subset = if options
+      if attrs = options[:only]
+        slice(*Array.wrap(attrs))
+      elsif attrs = options[:except]
+        except(*Array.wrap(attrs))
+      else
+        self
+      end
+    else
+      self
+    end
+
+    # use encoder as a proxy to call as_json on all values in the subset, to protect from circular references
+    encoder = options && options[:encoder] || ActiveSupport::JSON::Encoding::Encoder.new(options)
+    pairs = subset.map { |k, v| [k.to_s, encoder.as_json(v)] }
+    result = self.is_a?(ActiveSupport::OrderedHash) ? ActiveSupport::OrderedHash.new : Hash.new
+    pairs.inject(result) { |hash, pair| hash[pair.first] = pair.last; hash }
+  end
+
+  def encode_json(encoder)
+    # values are encoded with use_options = false, because we don't want hash representations from ActiveModel to be
+    # processed once again with as_json with options, as this could cause unexpected results (i.e. missing fields);
+
+    # on the other hand, we need to run as_json on the elements, because the model representation may contain fields
+    # like Time/Date in their original (not jsonified) form, etc.
+
+    "{#{map { |k,v| "#{encoder.encode(k.to_s)}:#{encoder.encode(v, false)}" } * ','}}"
+  end
+end
+
+class Time
+  def as_json(options = nil) #:nodoc:
+    if ActiveSupport.use_standard_json_time_format
+      xmlschema
+    else
+      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
+    end
+  end
+end
+
+class Date
+  def as_json(options = nil) #:nodoc:
+    if ActiveSupport.use_standard_json_time_format
+      strftime("%Y-%m-%d")
+    else
+      strftime("%Y/%m/%d")
+    end
+  end
+end
+
+class DateTime
+  def as_json(options = nil) #:nodoc:
+    if ActiveSupport.use_standard_json_time_format
+      xmlschema
+    else
+      strftime('%Y/%m/%d %H:%M:%S %z')
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/json/variable.rb

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

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/json.rb

@@ -0,0 +1,2 @@
+require 'active_support/json/decoding'
+require 'active_support/json/encoding'

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/lazy_load_hooks.rb

@@ -0,0 +1,46 @@
+# lazy_load_hooks allows rails to lazily load a lot of components and thus making the app boot faster. Because of
+# this feature now there is no need to require <tt>ActiveRecord::Base</tt> at boot time purely to apply configuration. Instead
+# a hook is registered that applies configuration once <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is used
+# as example but this feature can be applied elsewhere too.
+#
+# Here is an example where +on_load+ method is called to register a hook.
+#
+#  initializer "active_record.initialize_timezone" do
+#    ActiveSupport.on_load(:active_record) do
+#      self.time_zone_aware_attributes = true
+#      self.default_timezone = :utc
+#    end
+#  end
+#
+# When the entirety of +activerecord/lib/active_record/base.rb+ has been evaluated then +run_load_hooks+ is invoked.
+# The very last line of +activerecord/lib/active_record/base.rb+ is:
+#
+#  ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+#
+module ActiveSupport
+  @load_hooks = Hash.new {|h,k| h[k] = [] }
+  @loaded = {}
+
+  def self.on_load(name, options = {}, &block)
+    if base = @loaded[name]
+      execute_hook(base, options, block)
+    else
+      @load_hooks[name] << [block, options]
+    end
+  end
+
+  def self.execute_hook(base, options, block)
+    if options[:yield]
+      block.call(base)
+    else
+      base.instance_eval(&block)
+    end
+  end
+
+  def self.run_load_hooks(name, base = Object)
+    @loaded[name] = base
+    @load_hooks[name].each do |hook, options|
+      execute_hook(base, options, hook)
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/locale/en.yml

@@ -0,0 +1,36 @@
+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 datetime_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:
+      words_connector: ", "
+      two_words_connector: " and "
+      last_word_connector: ", and "

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/log_subscriber/test_helper.rb

@@ -0,0 +1,99 @@
+require 'active_support/log_subscriber'
+require 'active_support/buffered_logger'
+
+module ActiveSupport
+  class LogSubscriber
+    # Provides some helpers to deal with testing log subscribers by setting up
+    # notifications. Take for instance Active Record subscriber tests:
+    #
+    #   class SyncLogSubscriberTest < ActiveSupport::TestCase
+    #     include ActiveSupport::LogSubscriber::TestHelper
+    #
+    #     def setup
+    #       ActiveRecord::LogSubscriber.attach_to(:active_record)
+    #     end
+    #
+    #     def test_basic_query_logging
+    #       Developer.all
+    #       wait
+    #       assert_equal 1, @logger.logged(:debug).size
+    #       assert_match /Developer Load/, @logger.logged(:debug).last
+    #       assert_match /SELECT \* FROM "developers"/, @logger.logged(:debug).last
+    #     end
+    #   end
+    #
+    # All you need to do is to ensure that your log subscriber is added to Rails::Subscriber,
+    # as in the second line of the code above. The test helpers is reponsible for setting
+    # up the queue, subscriptions and turning colors in logs off.
+    #
+    # The messages are available in the @logger instance, which is a logger with limited
+    # powers (it actually do not send anything to your output), and you can collect them
+    # doing @logger.logged(level), where level is the level used in logging, like info,
+    # debug, warn and so on.
+    #
+    module TestHelper
+      def setup
+        @logger   = MockLogger.new
+        @notifier = ActiveSupport::Notifications::Fanout.new
+
+        ActiveSupport::LogSubscriber.colorize_logging = false
+
+        set_logger(@logger)
+        ActiveSupport::Notifications.notifier = @notifier
+      end
+
+      def teardown
+        set_logger(nil)
+        ActiveSupport::Notifications.notifier = nil
+      end
+
+      class MockLogger
+        include ActiveSupport::BufferedLogger::Severity
+
+        attr_reader :flush_count
+        attr_accessor :level
+
+        def initialize(level = DEBUG)
+          @flush_count = 0
+          @level = level
+          @logged = Hash.new { |h,k| h[k] = [] }
+        end
+
+        def method_missing(level, message)
+          @logged[level] << message
+        end
+
+        def logged(level)
+          @logged[level].compact.map { |l| l.to_s.strip }
+        end
+
+        def flush
+          @flush_count += 1
+        end
+
+        ActiveSupport::BufferedLogger::Severity.constants.each do |severity|
+          class_eval <<-EOT, __FILE__, __LINE__ + 1
+            def #{severity.downcase}?
+              #{severity} >= @level
+            end
+          EOT
+        end
+      end
+
+      # Wait notifications to be published.
+      def wait
+        @notifier.wait
+      end
+
+      # Overwrite if you use another logger in your log subscriber:
+      #
+      #   def logger
+      #     ActiveRecord::Base.logger = @logger
+      #   end
+      #
+      def set_logger(logger)
+        ActiveSupport::LogSubscriber.logger = logger
+      end
+    end
+  end
+end