messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,51 +0,0 @@
-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

@@ -1,279 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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/lazy_load_hooks.rb

@@ -1,46 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-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.rb

@@ -1,122 +0,0 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/class/attribute'
-
-module ActiveSupport
-  # ActiveSupport::LogSubscriber is an object set to consume ActiveSupport::Notifications
-  # with solely purpose of logging. The log subscriber dispatches notifications to a
-  # regirested object based on its given namespace.
-  #
-  # An example would be Active Record log subscriber responsible for logging queries:
-  #
-  #   module ActiveRecord
-  #     class LogSubscriber < ActiveSupport::LogSubscriber
-  #       def sql(event)
-  #         "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
-  #       end
-  #     end
-  #   end
-  #
-  # And it's finally registed as:
-  #
-  #   ActiveRecord::LogSubscriber.attach_to :active_record
-  #
-  # Since we need to know all instance methods before attaching the log subscriber,
-  # the line above should be called after your ActiveRecord::LogSubscriber definition.
-  #
-  # After configured, whenever a "sql.active_record" notification is published,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the sql method.
-  #
-  # Log subscriber also has some helpers to deal with logging and automatically flushes
-  # all logs when the request finishes (via action_dispatch.callback notification) in
-  # a Rails environment.
-  class LogSubscriber
-    # Embed in a String to clear all previous ANSI sequences.
-    CLEAR   = "\e[0m"
-    BOLD    = "\e[1m"
-
-    # Colors
-    BLACK   = "\e[30m"
-    RED     = "\e[31m"
-    GREEN   = "\e[32m"
-    YELLOW  = "\e[33m"
-    BLUE    = "\e[34m"
-    MAGENTA = "\e[35m"
-    CYAN    = "\e[36m"
-    WHITE   = "\e[37m"
-
-    mattr_accessor :colorize_logging
-    self.colorize_logging = true
-
-    class_attribute :logger
-
-    class << self
-      remove_method :logger
-      def logger
-        @logger ||= Rails.logger if defined?(Rails)
-      end
-
-      def attach_to(namespace, log_subscriber=new, notifier=ActiveSupport::Notifications)
-        log_subscribers << log_subscriber
-        @@flushable_loggers = nil
-
-        log_subscriber.public_methods(false).each do |event|
-          next if 'call' == event.to_s
-
-          notifier.subscribe("#{event}.#{namespace}", log_subscriber)
-        end
-      end
-
-      def log_subscribers
-        @@log_subscribers ||= []
-      end
-
-      def flushable_loggers
-        @@flushable_loggers ||= begin
-          loggers = log_subscribers.map(&:logger)
-          loggers.uniq!
-          loggers.select { |l| l.respond_to?(:flush) }
-        end
-      end
-
-      # Flush all log_subscribers' logger.
-      def flush_all!
-        flushable_loggers.each { |log| log.flush }
-      end
-    end
-
-    def call(message, *args)
-      return unless logger
-
-      method = message.split('.').first
-      begin
-        send(method, ActiveSupport::Notifications::Event.new(message, *args))
-      rescue Exception => e
-        logger.error "Could not log #{message.inspect} event. #{e.class}: #{e.message}"
-      end
-    end
-
-  protected
-
-    %w(info debug warn error fatal unknown).each do |level|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{level}(*args, &block)
-          return unless logger
-          logger.#{level}(*args, &block)
-        end
-      METHOD
-    end
-
-    # Set color by using a string or one of the defined constants. If a third
-    # option is set to true, it also adds bold to the string. This is based
-    # on Highline implementation and it automatically appends CLEAR to the end
-    # of the returned String.
-    #
-    def color(text, color, bold=false)
-      return text unless colorize_logging
-      color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
-      bold  = bold ? BOLD : ""
-      "#{bold}#{color}#{text}#{CLEAR}"
-    end
-  end
-end