messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,151 +0,0 @@
-module ActiveSupport
-  # The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
-  # and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
-  # in inflections.rb.
-  #
-  # The Rails core team has stated patches for the inflections library will not be accepted
-  # in order to avoid breaking legacy applications which may be relying on errant inflections.
-  # If you discover an incorrect inflection and require it for your application, you'll need
-  # to correct it yourself (explained below).
-  module Inflector
-    extend self
-
-    # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
-    # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
-    #
-    # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-    #
-    # Examples:
-    #   "active_record".camelize                # => "ActiveRecord"
-    #   "active_record".camelize(:lower)        # => "activeRecord"
-    #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-    #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
-    #
-    # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+,
-    # though there are cases where that does not hold:
-    #
-    #   "SSLError".underscore.camelize # => "SslError"
-    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-      if first_letter_in_uppercase
-        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      else
-        lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
-      end
-    end
-
-    # Makes an underscored, lowercase form from the expression in the string.
-    #
-    # Changes '::' to '/' to convert namespaces to paths.
-    #
-    # Examples:
-    #   "ActiveRecord".underscore         # => "active_record"
-    #   "ActiveRecord::Errors".underscore # => active_record/errors
-    #
-    # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+,
-    # though there are cases where that does not hold:
-    #
-    #   "SSLError".underscore.camelize # => "SslError"
-    def underscore(camel_cased_word)
-      word = camel_cased_word.to_s.dup
-      word.gsub!(/::/, '/')
-      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
-      word.downcase!
-      word
-    end
-
-    # Replaces underscores with dashes in the string.
-    #
-    # Example:
-    #   "puni_puni" # => "puni-puni"
-    def dasherize(underscored_word)
-      underscored_word.gsub(/_/, '-')
-    end
-
-    # Removes the module part from the expression in the string.
-    #
-    # Examples:
-    #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
-    #   "Inflections".demodulize                                       # => "Inflections"
-    def demodulize(class_name_in_module)
-      class_name_in_module.to_s.gsub(/^.*::/, '')
-    end
-
-    # Creates a foreign key name from a class name.
-    # +separate_class_name_and_id_with_underscore+ sets whether
-    # the method should put '_' between the name and 'id'.
-    #
-    # Examples:
-    #   "Message".foreign_key        # => "message_id"
-    #   "Message".foreign_key(false) # => "messageid"
-    #   "Admin::Post".foreign_key    # => "post_id"
-    def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
-      underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
-    end
-
-    # Ruby 1.9 introduces an inherit argument for Module#const_get and
-    # #const_defined? and changes their default behavior.
-    if Module.method(:const_get).arity == 1
-      # Tries to find a constant with the name specified in the argument string:
-      #
-      #   "Module".constantize     # => Module
-      #   "Test::Unit".constantize # => Test::Unit
-      #
-      # The name is assumed to be the one of a top-level constant, no matter whether
-      # it starts with "::" or not. No lexical context is taken into account:
-      #
-      #   C = 'outside'
-      #   module M
-      #     C = 'inside'
-      #     C               # => 'inside'
-      #     "C".constantize # => 'outside', same as ::C
-      #   end
-      #
-      # NameError is raised when the name is not in CamelCase or the constant is
-      # unknown.
-      def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
-
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-        end
-        constant
-      end
-    else
-      def constantize(camel_cased_word) #:nodoc:
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
-
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
-        end
-        constant
-      end
-    end
-
-    # Turns a number into an ordinal string used to denote the position in an
-    # ordered sequence such as 1st, 2nd, 3rd, 4th.
-    #
-    # Examples:
-    #   ordinalize(1)     # => "1st"
-    #   ordinalize(2)     # => "2nd"
-    #   ordinalize(1002)  # => "1002nd"
-    #   ordinalize(1003)  # => "1003rd"
-    def ordinalize(number)
-      if (11..13).include?(number.to_i % 100)
-        "#{number}th"
-      else
-        case number.to_i % 10
-          when 1; "#{number}st"
-          when 2; "#{number}nd"
-          when 3; "#{number}rd"
-          else    "#{number}th"
-        end
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# encoding: utf-8
-require 'active_support/core_ext/string/multibyte'
-require 'active_support/i18n'
-
-module ActiveSupport
-  module Inflector
-
-    # Replaces non-ASCII characters with an ASCII approximation, or if none
-    # exists, a replacement character which defaults to "?".
-    #
-    #    transliterate("Ærøskøbing")
-    #    # => "AEroskobing"
-    #
-    # Default approximations are provided for Western/Latin characters,
-    # e.g, "ø", "ñ", "é", "ß", etc.
-    #
-    # This method is I18n aware, so you can set up custom approximations for a
-    # locale. This can be useful, for example, to transliterate German's "ü"
-    # and "ö" to "ue" and "oe", or to add support for transliterating Russian
-    # to ASCII.
-    #
-    # In order to make your custom transliterations available, you must set
-    # them as the <tt>i18n.transliterate.rule</tt> i18n key:
-    #
-    #   # Store the transliterations in locales/de.yml
-    #   i18n:
-    #     transliterate:
-    #       rule:
-    #         ü: "ue"
-    #         ö: "oe"
-    #
-    #   # Or set them using Ruby
-    #   I18n.backend.store_translations(:de, :i18n => {
-    #     :transliterate => {
-    #       :rule => {
-    #         "ü" => "ue",
-    #         "ö" => "oe"
-    #       }
-    #     }
-    #   })
-    #
-    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that maps
-    # characters to ASCII approximations as shown above, or, for more complex
-    # requirements, a Proc:
-    #
-    #   I18n.backend.store_translations(:de, :i18n => {
-    #     :transliterate => {
-    #       :rule => lambda {|string| MyTransliterator.transliterate(string)}
-    #     }
-    #   })
-    #
-    # Now you can have different transliterations for each locale:
-    #
-    #   I18n.locale = :en
-    #   transliterate("Jürgen")
-    #   # => "Jurgen"
-    #
-    #   I18n.locale = :de
-    #   transliterate("Jürgen")
-    #   # => "Juergen"
-    def transliterate(string, replacement = "?")
-      I18n.transliterate(ActiveSupport::Multibyte::Unicode.normalize(
-        ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c),
-          :replacement => replacement)
-    end
-
-    # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
-    #
-    # ==== Examples
-    #
-    #   class Person
-    #     def to_param
-    #       "#{id}-#{name.parameterize}"
-    #     end
-    #   end
-    #
-    #   @person = Person.find(1)
-    #   # => #<Person id: 1, name: "Donald E. Knuth">
-    #
-    #   <%= link_to(@person.name, person_path(@person)) %>
-    #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
-    def parameterize(string, sep = '-')
-      # replace accented chars with their ascii equivalents
-      parameterized_string = transliterate(string)
-      # Turn unwanted chars into the separator
-      parameterized_string.gsub!(/[^a-z0-9\-_]+/i, sep)
-      unless sep.nil? || sep.empty?
-        re_sep = Regexp.escape(sep)
-        # No more than one of the separator in a row.
-        parameterized_string.gsub!(/#{re_sep}{2,}/, sep)
-        # Remove leading/trailing separator.
-        parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/i, '')
-      end
-      parameterized_string.downcase
-    end
-
-  end
-end

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

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

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

@@ -1,47 +0,0 @@
-require 'json' unless defined?(JSON)
-
-module ActiveSupport
-  module JSON
-    module Backends
-      module JSONGem
-        ParseError = ::JSON::ParserError
-        extend self
-
-        # Parses a JSON string or IO and convert it into an object
-        def decode(json)
-          if json.respond_to?(:read)
-            json = json.read
-          end
-          data = ::JSON.parse(json)
-          if ActiveSupport.parse_json_times
-            convert_dates_from(data)
-          else
-            data
-          end
-        end
-
-      private
-        def convert_dates_from(data)
-          case data
-          when nil
-            nil
-          when DATE_REGEX
-            begin
-              DateTime.parse(data)
-            rescue ArgumentError
-              data
-            end
-          when Array
-            data.map! { |d| convert_dates_from(d) }
-          when Hash
-            data.each do |key, value|
-              data[key] = convert_dates_from(value)
-            end
-          else
-            data
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require 'yajl' unless defined?(Yajl)
-
-module ActiveSupport
-  module JSON
-    module Backends
-      module Yajl
-        ParseError = ::Yajl::ParseError
-        extend self
-
-        # Parses a JSON string or IO and convert it into an object
-        def decode(json)
-          data = ::Yajl::Parser.new.parse(json)
-          if ActiveSupport.parse_json_times
-            convert_dates_from(data)
-          else
-            data
-          end
-        end
-
-      private
-        def convert_dates_from(data)
-          case data
-          when nil
-            nil
-          when DATE_REGEX
-            begin
-              DateTime.parse(data)
-            rescue ArgumentError
-              data
-            end
-          when Array
-            data.map! { |d| convert_dates_from(d) }
-          when Hash
-            data.each do |key, value|
-              data[key] = convert_dates_from(value)
-            end
-          else
-            data
-          end
-        end
-      end
-    end
-  end
-end

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

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