messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,64 +0,0 @@
-# A typical module looks like this
-#
-#   module M
-#     def self.included(base)
-#       base.send(:extend, ClassMethods)
-#       base.send(:include, InstanceMethods)
-#       scope :foo, :conditions => { :created_at => nil }
-#     end
-#
-#     module ClassMethods
-#       def cm; puts 'I am a class method'; end
-#     end
-#
-#     module InstanceMethods
-#       def im; puts 'I am an instance method'; end
-#     end
-#   end
-#
-# By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
-#
-#   module M
-#     extend ActiveSupport::Concern
-#
-#     included do
-#       scope :foo, :conditions => { :created_at => nil }
-#     end
-#
-#     module ClassMethods
-#       def cm; puts 'I am a class method'; end
-#     end
-#
-#     module InstanceMethods
-#       def im; puts 'I am an instance method'; end
-#     end
-#   end
-module ActiveSupport
-  module Concern
-    def self.extended(base)
-      base.instance_variable_set("@_dependencies", [])
-    end
-
-    def append_features(base)
-      if base.instance_variable_defined?("@_dependencies")
-        base.instance_variable_get("@_dependencies") << self
-        return false
-      else
-        return false if base < self
-        @_dependencies.each { |dep| base.send(:include, dep) }
-        super
-        base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
-        base.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
-        base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
-      end
-    end
-
-    def included(base = nil, &block)
-      if base.nil?
-        @_included_block = block
-      else
-        super
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'active_support/concern'
-require 'active_support/ordered_options'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/delegation'
-
-module ActiveSupport
-  module Configurable
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def config
-        @_config ||= ActiveSupport::InheritableOptions.new(superclass.respond_to?(:config) ? superclass.config : {})
-      end
-
-      def configure
-        yield config
-      end
-
-      # Allows you to add shortcut so that you don't have to refer to attribute through config.
-      # Also look at the example for config to contrast.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :allowed_access
-      #   end
-      #
-      #   user = User.new
-      #   user.allowed_access = true
-      #   user.allowed_access # => true
-      #
-      def config_accessor(*names)
-        names.each do |name|
-          code, line = <<-RUBY, __LINE__ + 1
-            def #{name}; config.#{name}; end
-            def #{name}=(value); config.#{name} = value; end
-          RUBY
-
-          singleton_class.class_eval code, __FILE__, line
-          class_eval code, __FILE__, line
-        end
-      end
-    end
-
-    def config
-      @_config ||= ActiveSupport::InheritableOptions.new(self.class.config)
-    end
-  end
-end

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

@@ -1,3 +0,0 @@
-Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].sort.each do |path|
-  require "active_support/core_ext/#{File.basename(path, '.rb')}"
-end

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

@@ -1,7 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/array/access'
-require 'active_support/core_ext/array/uniq_by'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/array/grouping'
-require 'active_support/core_ext/array/random_access'

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/core_ext/array/access.rb

@@ -1,46 +0,0 @@
-class Array
-  # Returns the tail of the array from +position+.
-  #
-  #   %w( a b c d ).from(0)  # => %w( a b c d )
-  #   %w( a b c d ).from(2)  # => %w( c d )
-  #   %w( a b c d ).from(10) # => nil
-  #   %w().from(0)           # => %w()
-  def from(position)
-    self[position..-1]
-  end
-
-  # Returns the beginning of the array up to +position+.
-  #
-  #   %w( a b c d ).to(0)  # => %w( a )
-  #   %w( a b c d ).to(2)  # => %w( a b c )
-  #   %w( a b c d ).to(10) # => %w( a b c d )
-  #   %w().to(0)           # => %w()
-  def to(position)
-    self[0..position]
-  end
-
-  # Equal to <tt>self[1]</tt>.
-  def second
-    self[1]
-  end
-
-  # Equal to <tt>self[2]</tt>.
-  def third
-    self[2]
-  end
-
-  # Equal to <tt>self[3]</tt>.
-  def fourth
-    self[3]
-  end
-
-  # Equal to <tt>self[4]</tt>.
-  def fifth
-    self[4]
-  end
-
-  # Equal to <tt>self[41]</tt>. Also known as accessing "the reddit".
-  def forty_two
-    self[41]
-  end
-end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/core_ext/array/conversions.rb

@@ -1,164 +0,0 @@
-require 'active_support/xml_mini'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/core_ext/string/inflections'
-
-class Array
-  # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
-  # * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
-  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
-  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
-  def to_sentence(options = {})
-    if defined?(I18n)
-      default_words_connector     = I18n.translate(:'support.array.words_connector',     :locale => options[:locale])
-      default_two_words_connector = I18n.translate(:'support.array.two_words_connector', :locale => options[:locale])
-      default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])
-    else
-      default_words_connector     = ", "
-      default_two_words_connector = " and "
-      default_last_word_connector = ", and "
-    end
-
-    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
-    options.reverse_merge! :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector
-
-    case length
-      when 0
-        ""
-      when 1
-        self[0].to_s.dup
-      when 2
-        "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
-      else
-        "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
-    end
-  end
-
-  # Converts a collection of elements into a formatted string by calling
-  # <tt>to_s</tt> on all elements and joining them:
-  #
-  #   Blog.find(:all).to_formatted_s # => "First PostSecond PostThird Post"
-  #
-  # Adding in the <tt>:db</tt> argument as the format yields a prettier
-  # output:
-  #
-  #   Blog.find(:all).to_formatted_s(:db) # => "First Post,Second Post,Third Post"
-  def to_formatted_s(format = :default)
-    case format
-      when :db
-        if respond_to?(:empty?) && self.empty?
-          "null"
-        else
-          collect { |element| element.id }.join(",")
-        end
-      else
-        to_default_s
-    end
-  end
-  alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
-
-  # Returns a string that represents the array in XML by invoking +to_xml+
-  # on each element. Active Record collections delegate their representation
-  # in XML to this method.
-  #
-  # All elements are expected to respond to +to_xml+, if any of them does
-  # not then an exception is raised.
-  #
-  # The root node reflects the class name of the first element in plural
-  # if all elements belong to the same type and that's not Hash:
-  #
-  #   customer.projects.to_xml
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <projects type="array">
-  #     <project>
-  #       <amount type="decimal">20000.0</amount>
-  #       <customer-id type="integer">1567</customer-id>
-  #       <deal-date type="date">2008-04-09</deal-date>
-  #       ...
-  #     </project>
-  #     <project>
-  #       <amount type="decimal">57230.0</amount>
-  #       <customer-id type="integer">1567</customer-id>
-  #       <deal-date type="date">2008-04-15</deal-date>
-  #       ...
-  #     </project>
-  #   </projects>
-  #
-  # Otherwise the root element is "records":
-  #
-  #   [{:foo => 1, :bar => 2}, {:baz => 3}].to_xml
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <records type="array">
-  #     <record>
-  #       <bar type="integer">2</bar>
-  #       <foo type="integer">1</foo>
-  #     </record>
-  #     <record>
-  #       <baz type="integer">3</baz>
-  #     </record>
-  #   </records>
-  #
-  # If the collection is empty the root element is "nil-classes" by default:
-  #
-  #   [].to_xml
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <nil-classes type="array"/>
-  #
-  # To ensure a meaningful root element use the <tt>:root</tt> option:
-  #
-  #   customer_with_no_projects.projects.to_xml(:root => "projects")
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <projects type="array"/>
-  #
-  # By default name of the node for the children of root is <tt>root.singularize</tt>.
-  # You can change it with the <tt>:children</tt> option.
-  #
-  # The +options+ hash is passed downwards:
-  #
-  #   Message.all.to_xml(:skip_types => true)
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <messages>
-  #     <message>
-  #       <created-at>2008-03-07T09:58:18+01:00</created-at>
-  #       <id>1</id>
-  #       <name>1</name>
-  #       <updated-at>2008-03-07T09:58:18+01:00</updated-at>
-  #       <user-id>1</user-id>
-  #     </message>
-  #   </messages>
-  #
-  def to_xml(options = {})
-    require 'active_support/builder' unless defined?(Builder)
-
-    options = options.dup
-    options[:indent]  ||= 2
-    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-    options[:root]    ||= if first.class.to_s != "Hash" && all? { |e| e.is_a?(first.class) }
-      underscored = ActiveSupport::Inflector.underscore(first.class.name)
-      ActiveSupport::Inflector.pluralize(underscored).tr('/', '_')
-    else
-      "objects"
-    end
-
-    builder = options[:builder]
-    builder.instruct! unless options.delete(:skip_instruct)
-
-    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
-    children = options.delete(:children) || root.singularize
-
-    attributes = options[:skip_types] ? {} : {:type => "array"}
-    return builder.tag!(root, attributes) if empty?
-
-    builder.__send__(:method_missing, root, attributes) do
-      each { |value| ActiveSupport::XmlMini.to_tag(children, value, options) }
-      yield builder if block_given?
-    end
-  end
-
-end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/core_ext/array/extract_options.rb

@@ -1,29 +0,0 @@
-class Hash
-  # By default, only instances of Hash itself are extractable.
-  # Subclasses of Hash may implement this method and return
-  # true to declare themselves as extractable. If a Hash
-  # is extractable, Array#extract_options! pops it from
-  # the Array when it is the last element of the Array.
-  def extractable_options?
-    instance_of?(Hash)
-  end
-end
-
-class Array
-  # Extracts options from a set of arguments. Removes and returns the last
-  # element in the array if it's a hash, otherwise returns a blank hash.
-  #
-  #   def options(*args)
-  #     args.extract_options!
-  #   end
-  #
-  #   options(1, 2)           # => {}
-  #   options(1, 2, :a => :b) # => {:a=>:b}
-  def extract_options!
-    if last.is_a?(Hash) && last.extractable_options?
-      pop
-    else
-      {}
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/core_ext/array/grouping.rb

@@ -1,100 +0,0 @@
-require 'enumerator'
-
-class Array
-  # Splits or iterates over the array in groups of size +number+,
-  # padding any remaining slots with +fill_with+ unless it is +false+.
-  #
-  #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5", "6"]
-  #   ["7", nil, nil]
-  #
-  #   %w(1 2 3).in_groups_of(2, ' ') {|group| p group}
-  #   ["1", "2"]
-  #   ["3", " "]
-  #
-  #   %w(1 2 3).in_groups_of(2, false) {|group| p group}
-  #   ["1", "2"]
-  #   ["3"]
-  def in_groups_of(number, fill_with = nil)
-    if fill_with == false
-      collection = self
-    else
-      # size % number gives how many extra we have;
-      # subtracting from number gives how many to add;
-      # modulo number ensures we don't add group of just fill.
-      padding = (number - size % number) % number
-      collection = dup.concat([fill_with] * padding)
-    end
-
-    if block_given?
-      collection.each_slice(number) { |slice| yield(slice) }
-    else
-      groups = []
-      collection.each_slice(number) { |group| groups << group }
-      groups
-    end
-  end
-
-  # Splits or iterates over the array in +number+ of groups, padding any
-  # remaining slots with +fill_with+ unless it is +false+.
-  #
-  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
-  #   ["1", "2", "3", "4"]
-  #   ["5", "6", "7", nil]
-  #   ["8", "9", "10", nil]
-  #
-  #   %w(1 2 3 4 5 6 7).in_groups(3, '&nbsp;') {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5", "&nbsp;"]
-  #   ["6", "7", "&nbsp;"]
-  #
-  #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5"]
-  #   ["6", "7"]
-  def in_groups(number, fill_with = nil)
-    # size / number gives minor group size;
-    # size % number gives how many objects need extra accommodation;
-    # each group hold either division or division + 1 items.
-    division = size / number
-    modulo = size % number
-
-    # create a new array avoiding dup
-    groups = []
-    start = 0
-
-    number.times do |index|
-      length = division + (modulo > 0 && modulo > index ? 1 : 0)
-      padding = fill_with != false &&
-        modulo > 0 && length == division ? 1 : 0
-      groups << slice(start, length).concat([fill_with] * padding)
-      start += length
-    end
-
-    if block_given?
-      groups.each { |g| yield(g) }
-    else
-      groups
-    end
-  end
-
-  # Divides the array into one or more subarrays based on a delimiting +value+
-  # or the result of an optional block.
-  #
-  #   [1, 2, 3, 4, 5].split(3)                # => [[1, 2], [4, 5]]
-  #   (1..10).to_a.split { |i| i % 3 == 0 }   # => [[1, 2], [4, 5], [7, 8], [10]]
-  def split(value = nil)
-    using_block = block_given?
-
-    inject([[]]) do |results, element|
-      if (using_block && yield(element)) || (value == element)
-        results << []
-      else
-        results.last << element
-      end
-
-      results
-    end
-  end
-end