messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,146 +0,0 @@
-require "active_support/core_ext/module/remove_method"
-
-class Module
-  # Provides a delegate class method to easily expose contained objects' methods
-  # as your own. Pass one or more methods (specified as symbols or strings)
-  # and the name of the target object via the <tt>:to</tt> option (also a symbol
-  # or string). At least one method and the <tt>:to</tt> option are required.
-  #
-  # Delegation is particularly useful with Active Record associations:
-  #
-  #   class Greeter < ActiveRecord::Base
-  #     def hello
-  #       "hello"
-  #     end
-  #
-  #     def goodbye
-  #       "goodbye"
-  #     end
-  #   end
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, :to => :greeter
-  #   end
-  #
-  #   Foo.new.hello   # => "hello"
-  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
-  #
-  # Multiple delegates to the same target are allowed:
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, :goodbye, :to => :greeter
-  #   end
-  #
-  #   Foo.new.goodbye # => "goodbye"
-  #
-  # Methods can be delegated to instance variables, class variables, or constants
-  # by providing them as a symbols:
-  #
-  #   class Foo
-  #     CONSTANT_ARRAY = [0,1,2,3]
-  #     @@class_array  = [4,5,6,7]
-  #
-  #     def initialize
-  #       @instance_array = [8,9,10,11]
-  #     end
-  #     delegate :sum, :to => :CONSTANT_ARRAY
-  #     delegate :min, :to => :@@class_array
-  #     delegate :max, :to => :@instance_array
-  #   end
-  #
-  #   Foo.new.sum # => 6
-  #   Foo.new.min # => 4
-  #   Foo.new.max # => 11
-  #
-  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
-  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
-  # delegated to.
-  #
-  #   Person = Struct.new(:name, :address)
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, :to => :client, :prefix => true
-  #   end
-  #
-  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.client_name    # => "John Doe"
-  #   invoice.client_address # => "Vimmersvej 13"
-  #
-  # It is also possible to supply a custom prefix.
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, :to => :client, :prefix => :customer
-  #   end
-  #
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.customer_name    # => "John Doe"
-  #   invoice.customer_address # => "Vimmersvej 13"
-  #
-  # If the delegate object is +nil+ an exception is raised, and that happens
-  # no matter whether +nil+ responds to the delegated method. You can get a
-  # +nil+ instead with the +:allow_nil+ option.
-  #
-  #  class Foo
-  #    attr_accessor :bar
-  #    def initialize(bar = nil)
-  #      @bar = bar
-  #    end
-  #    delegate :zoo, :to => :bar
-  #  end
-  #
-  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
-  #
-  #  class Foo
-  #    attr_accessor :bar
-  #    def initialize(bar = nil)
-  #      @bar = bar
-  #    end
-  #    delegate :zoo, :to => :bar, :allow_nil => true
-  #  end
-  #
-  #  Foo.new.zoo   # returns nil
-  #
-  def delegate(*methods)
-    options = methods.pop
-    unless options.is_a?(Hash) && to = options[:to]
-      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
-    end
-
-    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
-      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
-    end
-
-    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_" || ''
-
-    file, line = caller.first.split(':', 2)
-    line = line.to_i
-
-    methods.each do |method|
-      on_nil =
-        if options[:allow_nil]
-          'return'
-        else
-          %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
-        end
-
-      module_eval(<<-EOS, file, line - 5)
-        if instance_methods(false).map(&:to_s).include?("#{prefix}#{method}")
-          remove_possible_method("#{prefix}#{method}")
-        end
-
-        def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
-          #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
-        rescue NoMethodError                                # rescue NoMethodError
-          if #{to}.nil?                                     #   if client.nil?
-            #{on_nil}                                       #     return # depends on :allow_nil
-          else                                              #   else
-            raise                                           #     raise
-          end                                               #   end
-        end                                                 # end
-      EOS
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-require 'active_support/deprecation'
-
-class Module
-  # Declare that a method has been deprecated.
-  #   deprecate :foo
-  #   deprecate :bar => 'message'
-  #   deprecate :foo, :bar, :baz => 'warning!', :qux => 'gone!'
-  def deprecate(*method_names)
-    ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
-  end
-end

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

@@ -1,88 +0,0 @@
-require 'active_support/inflector'
-
-class Module
-  # Returns the name of the module containing this one.
-  #
-  #   M::N.parent_name # => "M"
-  def parent_name
-    unless defined? @parent_name
-      @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
-    end
-    @parent_name
-  end
-
-  # Returns the module which contains this one according to its name.
-  #
-  #   module M
-  #     module N
-  #     end
-  #   end
-  #   X = M::N
-  #
-  #   M::N.parent # => M
-  #   X.parent    # => M
-  #
-  # The parent of top-level and anonymous modules is Object.
-  #
-  #   M.parent          # => Object
-  #   Module.new.parent # => Object
-  #
-  def parent
-    parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
-  end
-
-  # Returns all the parents of this module according to its name, ordered from
-  # nested outwards. The receiver is not contained within the result.
-  #
-  #   module M
-  #     module N
-  #     end
-  #   end
-  #   X = M::N
-  #
-  #   M.parents    # => [Object]
-  #   M::N.parents # => [M, Object]
-  #   X.parents    # => [M, Object]
-  #
-  def parents
-    parents = []
-    if parent_name
-      parts = parent_name.split('::')
-      until parts.empty?
-        parents << ActiveSupport::Inflector.constantize(parts * '::')
-        parts.pop
-      end
-    end
-    parents << Object unless parents.include? Object
-    parents
-  end
-
-  if RUBY_VERSION < '1.9'
-    # Returns the constants that have been defined locally by this object and
-    # not in an ancestor. This method is exact if running under Ruby 1.9. In
-    # previous versions it may miss some constants if their definition in some
-    # ancestor is identical to their definition in the receiver.
-    def local_constants
-      inherited = {}
-
-      ancestors.each do |anc|
-        next if anc == self
-        anc.constants.each { |const| inherited[const] = anc.const_get(const) }
-      end
-
-      constants.select do |const|
-        !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
-      end
-    end
-  else
-    def local_constants #:nodoc:
-      constants(false)
-    end
-  end
-
-  # Returns the names of the constants defined locally rather than the
-  # constants themselves. See <tt>local_constants</tt>.
-  def local_constant_names
-    local_constants.map { |c| c.to_s }
-  end
-end

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

@@ -1,14 +0,0 @@
-class Module
-  if instance_methods[0].is_a?(Symbol)
-    def instance_method_names(*args)
-      instance_methods(*args).map(&:to_s)
-    end
-
-    def method_names(*args)
-      methods(*args).map(&:to_s)
-    end
-  else
-    alias_method :instance_method_names, :instance_methods
-    alias_method :method_names, :methods
-  end
-end

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

@@ -1,10 +0,0 @@
-require 'active_support/core_ext/module/anonymous'
-require 'active_support/core_ext/string/inflections'
-
-class Module
-  def reachable? #:nodoc:
-    !anonymous? && name.constantize.equal?(self)
-  rescue NameError
-    false
-  end
-end

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

@@ -1,11 +0,0 @@
-class Module
-  def remove_possible_method(method)
-    remove_method(method)
-  rescue NameError
-  end
-
-  def redefine_method(method, &block)
-    remove_possible_method(method)
-    define_method(method, &block)
-  end
-end

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

@@ -1,43 +0,0 @@
-require 'thread'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/array/extract_options'
-
-class Module
-  # Synchronize access around a method, delegating synchronization to a
-  # particular mutex. A mutex (either a Mutex, or any object that responds to
-  # #synchronize and yields to a block) must be provided as a final :with option.
-  # The :with option should be a symbol or string, and can represent a method,
-  # constant, or instance or class variable.
-  # Example:
-  #   class SharedCache
-  #     @@lock = Mutex.new
-  #     def expire
-  #       ...
-  #     end
-  #     synchronize :expire, :with => :@@lock
-  #   end
-  def synchronize(*methods)
-    options = methods.extract_options!
-    unless options.is_a?(Hash) && with = options[:with]
-      raise ArgumentError, "Synchronization needs a mutex. Supply an options hash with a :with key as the last argument (e.g. synchronize :hello, :with => :@mutex)."
-    end
-
-    methods.each do |method|
-      aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
-
-      if method_defined?("#{aliased_method}_without_synchronization#{punctuation}")
-        raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
-      end
-
-      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
-          #{with}.synchronize do                                                    #   @@lock.synchronize do
-            #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)
-          end                                                                       #   end
-        end                                                                         # end
-      EOS
-
-      alias_method_chain method, :synchronization
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-class NameError
-  # Extract the name of the missing constant from the exception message.
-  def missing_name
-    if /undefined local variable or method/ !~ message
-      $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
-    end
-  end
-
-  # Was this exception raised because the given name was missing?
-  def missing_name?(name)
-    if name.is_a? Symbol
-      last_name = (missing_name || '').split('::').last
-      last_name == name.to_s
-    else
-      missing_name == name.to_s
-    end
-  end
-end

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

@@ -1,2 +0,0 @@
-require 'active_support/core_ext/numeric/bytes'
-require 'active_support/core_ext/numeric/time'

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

@@ -1,44 +0,0 @@
-class Numeric
-  KILOBYTE = 1024
-  MEGABYTE = KILOBYTE * 1024
-  GIGABYTE = MEGABYTE * 1024
-  TERABYTE = GIGABYTE * 1024
-  PETABYTE = TERABYTE * 1024
-  EXABYTE  = PETABYTE * 1024
-
-  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
-  def bytes
-    self
-  end
-  alias :byte :bytes
-
-  def kilobytes
-    self * KILOBYTE
-  end
-  alias :kilobyte :kilobytes
-
-  def megabytes
-    self * MEGABYTE
-  end
-  alias :megabyte :megabytes
-
-  def gigabytes
-    self * GIGABYTE
-  end
-  alias :gigabyte :gigabytes
-
-  def terabytes
-    self * TERABYTE
-  end
-  alias :terabyte :terabytes
-
-  def petabytes
-    self * PETABYTE
-  end
-  alias :petabyte :petabytes
-
-  def exabytes
-    self * EXABYTE
-  end
-  alias :exabyte :exabytes
-end

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

@@ -1,77 +0,0 @@
-require 'active_support/duration'
-
-class Numeric
-  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
-  #
-  # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
-  # as well as adding or subtracting their results from a Time object. For example:
-  #
-  #   # equivalent to Time.now.advance(:months => 1)
-  #   1.month.from_now
-  #
-  #   # equivalent to Time.now.advance(:years => 2)
-  #   2.years.from_now
-  #
-  #   # equivalent to Time.now.advance(:months => 4, :years => 5)
-  #   (4.months + 5.years).from_now
-  #
-  # While these methods provide precise calculation when used as in the examples above, care
-  # should be taken to note that this is not true if the result of `months', `years', etc is
-  # converted before use:
-  #
-  #   # equivalent to 30.days.to_i.from_now
-  #   1.month.to_i.from_now
-  #
-  #   # equivalent to 365.25.days.to_f.from_now
-  #   1.year.to_f.from_now
-  #
-  # In such cases, Ruby's core
-  # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and
-  # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
-  # date and time arithmetic
-  def seconds
-    ActiveSupport::Duration.new(self, [[:seconds, self]])
-  end
-  alias :second :seconds
-
-  def minutes
-    ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
-  end
-  alias :minute :minutes
-
-  def hours
-    ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
-  end
-  alias :hour :hours
-
-  def days
-    ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
-  end
-  alias :day :days
-
-  def weeks
-    ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
-  end
-  alias :week :weeks
-
-  def fortnights
-    ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
-  end
-  alias :fortnight :fortnights
-
-  # Reads best without arguments:  10.minutes.ago
-  def ago(time = ::Time.current)
-    time - self
-  end
-
-  # Reads best with argument:  10.minutes.until(time)
-  alias :until :ago
-
-  # Reads best with argument:  10.minutes.since(time)
-  def since(time = ::Time.current)
-    time + self
-  end
-
-  # Reads best without arguments:  10.minutes.from_now
-  alias :from_now :since
-end