y_support 2.1.5 → 2.1.12

data/lib/y_support/null_object.rb

@@ -1,8 +1,8 @@
-#encoding: utf-8
+# encoding: utf-8
 
 require 'y_support'
 
-# Null object pattern implementation in YSupport. apart from the expected null
+# Null object pattern implementation in +YSupport+. apart from the expected null
 # object behavior (such as returning self in response to almost all messages),
 # this null object instances can carry a signature specified by the user upon
 # creation, which can serve to hint the origin of the null object. (This
@@ -17,7 +17,7 @@ class NullObject
     @null_object_signature = null_object_signature 
   end
 
-  # Inquirer whether an object is a NullObject. Again, optional signature
+  # Inquirer whether an object is a +NullObject+. Again, optional signature
   # argument can be given to distinguish between different null objects.
   # 
   def null_object? signature=nil
@@ -60,7 +60,7 @@ class NullObject
   # 
   def blank?; true end
 
-  # True if and only if the other object is a NullObject with same signature.
+  # True if and only if the other object is a +NullObject+ with same signature.
   # 
   def == other
     other.is_a?( self.class ) &&
@@ -78,13 +78,13 @@ end # class nullobject
 
 
 class Object
-  # Always false for ordinary objects, overriden in NullObject instances.
+  # Always false for ordinary objects, overriden in +NullObject+ instances.
   # 
   def null_object? signature=nil; false end
   alias :null? :null_object?
 
-  # Converts #nil?-positive objects to a NullObject. Second optional argument
-  # specifies the signature of the null object to be created.
+  # Converts +#nil?+-positive objects to a +NullObject+. Second optional
+  # argument specifies the signature of the null object to be created.
   # 
   def Maybe object, null_object_signature=nil
     object.nil? ? NullObject.new( null_object_signature ) : object
@@ -94,3 +94,4 @@ class Object
   # 
   def Null( signature=nil ); NullObject.new signature end
 end
+

data/lib/y_support/respond_to.rb

@@ -1,5 +1,3 @@
-#encoding: utf-8
-
 require 'y_support'
 
 # RespondTo class for easy use of respond_to? in case statements.
@@ -30,3 +28,4 @@ class Symbol
   # 
   def ~@; RespondTo self end
 end
+

data/lib/y_support/stdlib_ext/matrix/misc.rb

@@ -1,5 +1,3 @@
-#encoding: utf-8
-
 require 'matrix'
 
 class Matrix

data/lib/y_support/stdlib_ext/matrix.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/stdlib_ext/matrix/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/matrix/misc'

data/lib/y_support/stdlib_ext.rb

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

data/lib/y_support/try.rb

@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 
 require 'y_support'
 require 'y_support/core_ext/array/misc'

data/lib/y_support/typing/array/typing.rb

@@ -1,19 +1,17 @@
-#encoding: utf-8
 class Array
-  # === Duck typing support (aka. runtime assertions)
+  # Runtime assertions for Array.
 
   # This method takes a block and fails with TypeError, if the receiver array
   # fails to include the specified element. An optional argument customizes the
   # error message (element description).
   # 
-  def aT_includes element, what_is_self="array", what_is_element=nil
+  def aT_include element, what_is_self="array", what_is_element=nil
     m = "%s is absent from #{what_is_self}!" %
       if what_is_element then what_is_element.to_s.capitalize else
         "Element (#{element.class} instance)"
       end
     tap { include? element or fail TypeError, m }
   end
-  alias :aT_include :aT_includes
 
   # Fails with TypeError if the array contains duplicates (using +#uniq+).
   # 
@@ -21,4 +19,47 @@ class Array
     m = "#{what_is_self.to_s.capitalize} non-uniq!"
     tap { self == uniq or fail TypeError, m }
   end
+
+  # Fails with TypeError unless the receiver's +#empty?+ returns _true_.
+  # 
+  def aT_empty what_is_receiver="array"
+    tap { empty? or fail TypeError, "%s not empty".X!( what_is_receiver ) }
+  end
+
+  # Fails with TypeError unless the receiver's +#empty?+ returns _false_.
+  # 
+  def aT_not_empty what_is_receiver="array"
+    tap { empty? and fail TypeError, "%s empty".X!( what_is_receiver ) }
+  end
+
+  # This method takes a block and fails with +ArgumentError+ if the receiver
+  # array fails to include the specified element. An optional argument
+  # customizes the error message (element description).
+  # 
+  def aA_include element, what_is_self="array", what_is_element=nil
+    m = "%s is absent from #{what_is_self}!" %
+      if what_is_element then what_is_element.to_s.capitalize else
+        "Element (#{element.class} instance)"
+      end
+    tap { include? element or fail ArgumentError, m }
+  end
+
+  # Fails with ArgumentError if the array contains duplicates (using +#uniq+).
+  # 
+  def aA_uniq what_is_self="array"
+    m = "#{what_is_self.to_s.capitalize} non-uniq!"
+    tap { self == uniq or fail ArgumentError, m }
+  end
+
+  # Fails with ArgumentError unless the receiver's +#empty?+ returns _true_.
+  # 
+  def aA_empty what_is_receiver="array"
+    tap { empty? or fail ArgumentError, "%s not empty".X!( what_is_receiver ) }
+  end
+
+  # Fails with ArgumentError unless the receiver's +#empty?+ returns _false_.
+  # 
+  def aA_not_empty what_is_receiver="array"
+    tap { empty? and fail ArgumentError, "%s empty".X!( what_is_receiver ) }
+  end
 end

data/lib/y_support/typing/array.rb

@@ -1 +1 @@
-require 'y_support/core_ext/array/typing'
+require File.dirname( __FILE__ ) + '/array/typing'

data/lib/y_support/typing/enumerable/typing.rb

@@ -1,66 +1,64 @@
-#encoding: utf-8
-
 module Enumerable
-  # Fails with TypeError unless all the members of the collection comply with
-  # the supplied block criterion. Optional arguments customize the error
-  # message. First optional argument describes the collection element, the
-  # second one describes the tested duck type. If the criterion block takes
-  # at least one argument, the receiver elemnts are passed to it (#all?
-  # method). If the criterion block takes no arguments (arity 0), it is
-  # gradually executed inside the elements (using #instance_exec method).
-  # If no block is given, all members are required to be truey.
+  # Fails with +TypeError+ unless all the members of the collection comply with
+  # the supplied block criterion. Optional arguments customize the error message.
+  # First optional argument describes the collection element, the second one
+  # describes the tested duck type. If the criterion block takes at least one
+  # argument, the receiver elemnts are passed to it (+#all?+ method). If the
+  # criterion block takes no arguments (arity 0), it is gradually executed inside
+  # the elements (using +#instance_exec+). If no block is given, all members are
+  # required to be truey.
   # 
   def aT_all what_is_collection_element=nil, how_comply=nil, &b
     e = what_is_collection_element || "collection element"
     if block_given?
       m = "Each #{e} must %s!" %
-        ( how_comply ? how_comply : "comply with the given duck type" )
-      raise TErr, m unless ( b.arity == 0 ?
-                             all? { |e| e.instance_exec( &b ) } :
-                             all? { |e| b.( e ) } )
+        ( how_comply ? how_comply : "comply with the specification" )
+      fail TypeError, m unless ( b.arity == 0 ?
+                                 all? { |e| e.instance_exec( &b ) } :
+                                 all? { |e| b.( e ) } )
     else
       m = "No #{e} must be nil or false!"
-      raise TErr, m unless all? { |e| e }
+      fail TypeError, m unless all? { |e| e }
     end
     return self
   end
 
-  # Fails with TypeError unless all collection members are #kind_of? the
+  # Fails with +TypeError+ unless all collection members are +#kind_of?+ the
   # class supplied as argument. Second optional argument (collection element
   # description) customizes the error message.
   # 
   def aT_all_kind_of klass, what_is_collection_element=nil
     e = what_is_collection_element || "collection element"
     m = "Each #{e} must be kind of #{klass}!"
-    raise TErr, m unless all? { |e| e.kind_of? klass }
+    fail TypeError, m unless all? { |e| e.kind_of? klass }
     return self
   end
 
-  # Fails with TypeError unless all collection members declare compliance with
-  # compliance with the class supplied as argument. Second optional argument
-  # (collection element description) customizes the error message.
+  # Fails with +TypeError+ unless all collection members declare compliance with
+  # the class supplied as an argument. Second optional argument (collection
+  # element description) customizes the error message.
   # 
   def aT_all_comply klass, what_is_collection_element=nil
     e = what_is_collection_element || "collection element"
     m = "Each #{e} must declare compliance to #{klass}!"
-    raise TErr, m unless all? { |e| e.class_complies? klass }
+    fail TypeError, m unless all? { |e| e.class_complies? klass }
     return self
   end
   
-  # Fails with TypeError unless all the collection members declare compliance
-  # with Numeric. Second optional argument (collection element description)
+  # Fails with +TypeError+ unless all the collection members declare compliance
+  # with +Numeric+. Second optional argument (collection element description)
   # customizes the error message.
   # 
   def aT_all_numeric what_is_collection_element=nil
     e = what_is_collection_element || "collection element"
     m = "Each #{e} must declare compliance with Numeric!"
-    raise TErr, m unless all? { |e| e.class_complies? Numeric }
+    fail TypeError, m unless all? { |e| e.class_complies? Numeric }
     return self
   end
   
-  # Fails with TypeError unless all the collection members are included int the
-  # collection supplied as argument. Second optional argument (collection
-  # element description) customizes the error message.
+  # Fails with +TypeError+ unless all the collection members are included in the
+  # collection supplied as argument. Second optional argument (collection element
+  # description) customizes the error message.
   # 
   def aT_subset_of other_collection, what_is_receiver_collection=nil,
                    what_is_other_collection=nil
@@ -69,7 +67,7 @@ module Enumerable
     oc = what_is_other_collection ? what_is_other_collection.to_s.capitalize :
       "the specified collection"
     m = "The #{rc} must be a subset of #{oc}"
-    raise TErr, m unless all? { |e| other_collection.include? e }
+    fail TypeError, m unless all? { |e| other_collection.include? e }
     return self
   end
 end

data/lib/y_support/typing/enumerable.rb

@@ -1 +1 @@
-require 'y_support/core_ext/enumerable/typing'
+require File.dirname( __FILE__ ) + '/enumerable/typing'

data/lib/y_support/typing/hash/typing.rb

@@ -1,12 +1,10 @@
-#encoding: utf-8
-
 class Hash
   # Merges the synonymous hash keys into a single key - useful for argument
   # validation. Returns nil if neither main key, nor synonyms are found.
   # Returns false (no merging) if the main key was found, but no synonym keys.
   # Returns true (yes merging) if any of the synonym keys is found and
   # renamed/merged to the main key. Value collisions in synonym keys (detected
-  # by #==) raise ArgumentError.
+  # by +#==+) raise +ArgumentError+.
   # 
   def merge_synonym_keys!( key, *synonyms )
     synonyms.reduce has_key?( key ) ? false : nil do |acc, syn|
@@ -20,57 +18,77 @@ class Hash
         delete syn
         next true
       else
-        raise TErr, "Value collision between #{key} and its synonym #{syn}!"
+        raise TypeError, "Value collision between #{key} and its synonym #{syn}!"
       end
     end
   end
   
-  # This method uses #merge_synonym_keys! method first and then returns the
-  # value under the key. The first argument is the main key. Synonyms may be
-  # supplied as a named argument :syn!. (Bang indicates that the synonym keys
-  # will be merged with the main key, modifying the hash.)
+  # Calls +#merge_synonym_keys!+ first, then returns the value under the
+  # specified key. The first argument is the main key, synonym keys may be
+  # supplied as a named argument +:syn!+. (Bang indicates that the synonym
+  # keys will be merged with the main key, thus modifying the hash.)
   # 
   def may_have key, options={}
     merge_synonym_keys!( key, *options[:syn!] ).nil?
     return self[key]
   end
 
-  # This method behaves similarly to #may_have, with the difference that it
-  # does not return the value of the key, only true / false to indicate whether
-  # the key or any synonym has been found.
+  # This method behaves like +#may_have+, but it returns _true_/_false_ value
+  # instead of the value under the specified key.
   # 
   def has? key, options={}
-    !merge_synonym_keys!( key, *options[:syn!] ).nil?
+    ! merge_synonym_keys!( key, *options[:syn!] ).nil?
   end
-  
-  # This enforcer method (aka. runtime assertion) raises TypeError when:
+
+  # This runtime assertion raises +TypeError+ when:
   # 1. Neither the required key nor any of its synonyms are present.
   # 2. The supplied criterion block, if any, returns false when applied
   # to the value of the key in question. If the block takes an argument
   # (or more arguments), the value is passed in. If the block takes no
   # arguments (arity 0), it is executed inside the singleton class of the
-  # receiver (using #instance_exec method).
+  # receiver (using +#instance_exec+ method).
   # 
   def aT_has key, options={}, &b
-    raise TErr, "Key '#{key}' absent!" unless has? key, options
-    # Now validate self[key] using the supplied block
-    if block_given?
-      m = "Value for #{key} fails its duck type!"
-      raise TErr, m unless ( b.arity == 0 ? self[key].instance_exec( &b ) :
-                               b.( self[key] ) )
+    fail TypeError, "Key '#{key}' absent!" unless has? key, options
+    self[key].tap do |val|
+      fail TypeError, "Value for #{key} of wrong type!" unless
+        ( b.arity == 0 ? val.instance_exec( &b ) : b.( val ) ) if b
     end
-    return self[key]
   end
   alias :must_have :aT_has
 
-  # This method behaves exactly like #aT_has, but with the difference, that
-  # it raises ArgumentError instead of TypeError
+  # This method behaves exactly like +#aT_has+, but it raises +ArgumentError+
+  # instead of +TypeError+.
   # 
-  def aE_has key, options={}, &b
-    begin
-      options.empty? ? aT_has( key, &b ) : aT_has( key, options, &b )
-    rescue TypeError => e
-      raise AErr, e.message
+  def aA_has key, options={}, &b
+    fail ArgumentError, "Key '#{key}' absent!" unless has? key, options
+    self[key].tap do |val|
+      fail ArgumentError, "Value for #{key} of wrong type!" unless
+        ( b.arity == 0 ? val.instance_exec( &b ) : b.( val ) ) if b
     end
   end
+
+  # Fails with +TypeError+ unless the receiver's +#empty?+ returns _true_.
+  # 
+  def aT_empty what_is_receiver="hash"
+    tap { empty? or fail TypeError, "%s not empty".X!( what_is_receiver ) }
+  end
+
+  # Fails with +TypeError+ unless the receiver's `#empty?` returns _false_.
+  # 
+  def aT_not_empty what_is_receiver="hash"
+    tap { empty? and fail TypeError, "%s empty".X!( what_is_receiver ) }
+  end
+
+  # Fails with +ArgumentError+ unless the receiver's `#empty?` returns _true_.
+  # 
+  def aA_empty what_is_receiver="hash"
+    tap { empty? or fail ArgumentError, "%s not empty".X!( what_is_receiver ) }
+  end
+
+  # Fails with +ArgumentError+ unless the receiver's `#empty?` returns _false_.
+  # 
+  def aA_not_empty what_is_receiver="hash"
+    tap { empty? and fail ArgumentError, "%s empty".X!( what_is_receiver ) }
+  end
 end

data/lib/y_support/typing/hash.rb

@@ -1 +1 @@
-require 'y_support/core_ext/hash/typing'
+require File.dirname( __FILE__ ) + '/hash/typing'

data/lib/y_support/typing/module/typing.rb

@@ -1,16 +1,13 @@
-#encoding: utf-8
-
 class Module
   # === Support for typing by declaration
 
   # Compliance inquirer (declared compliance + ancestors).
   # 
   def complies?( other_module )
-    other_module.aT_kind_of Module, "other module"
-    compliance.include? other_module
+    compliance.include? other_module.aT_kind_of( Module, "other module" )
   end
 
-  # Declared complience inquirer.
+  # Declared compliance inquirer.
   # 
   def declares_compliance?( other_module )
     other_module.aT_kind_of Module, "other module"
@@ -31,7 +28,8 @@ class Module
       }.reduce( [], :+ ) ).uniq
   end
 
-  # Declaration of module / class compliance.
+  # Using this method, the receiver explicitly declares that its interface
+  # complies with another module (class).
   # 
   def declare_compliance! other_module
     other_module.aT_kind_of Module, "other module"

data/lib/y_support/typing/module.rb

@@ -1 +1 @@
-require 'y_support/core_ext/module/typing'
+require File.dirname( __FILE__ ) + '/module/typing'

data/lib/y_support/typing/object/typing.rb

@@ -1,21 +1,19 @@
-#encoding: utf-8
-
 require 'active_support/core_ext/object/blank'
-require 'y_support/core_ext/object/inspection'
-require 'y_support/core_ext/string/misc'
+require File.dirname( __FILE__ ) + '/../../core_ext/object/inspection'
+require File.dirname( __FILE__ ) + '/../../core_ext/string/misc'
 
 class Object
-  # === Support for typing by declaration
+  # === Typing by declaration
 
   # Class compliance inquirer (declared compliance + class ancestors).
   # 
-  def class_complies?( klass )
+  def class_complies? klass
     singleton_class_or_class.complies? klass
   end
 
   # Declared class compliance.
   # 
-  def class_declares_compliance?( klass )
+  def class_declares_compliance? klass
     singleton_class_or_class.declares_compliance? klass
   end
 
@@ -33,31 +31,29 @@ class Object
 
   # Declaration of class compliance.
   # 
-  def declare_class_compliance!( klass )
+  def declare_class_compliance! klass
     singleton_class_or_class.declare_compliance! klass
   end
 
-  # === Duck typing support (aka. runtime assertions)
+  # === Runtime assertions
 
-  # This method takes a block and fails with TypeError, unless the receiver
+  # This method takes a block and fails with +TypeError+, unless the receiver
   # fullfills the block criterion. Optional arguments customize customize
   # the error message. First optional argument describes the receiver, the
   # second one describes the tested duck type. If the criterion block takes
   # at least one argument, the receiver is passed to it. If the criterion block
   # takes no arguments (arity 0), it is executed inside the singleton class of
-  # the receiver (using #instance_exec method). If no block is given, it is
+  # the receiver (using +#instance_exec+ method). If no block is given, it is
   # checked, whether the object is truey.
   # 
   def aT what_is_receiver=insp, how_comply=nil, &b
-    if block_given? then
-      if b.( self ) then self else
-        m = "%s fails " + ( how_comply ? "to #{how_comply}" : "its check" )
-        fail TypeError, m.X!( what_is_receiver ) 
-      end
-    else self or fail TypeError end
-  end
-  
-  # This method takes a block and fails with TypeError, unless the receiver
+    return tap { fail TypeError unless self } unless b
+    return self if b.( self )
+    m = "%s fails " + ( how_comply ? "to #{how_comply}" : "its check" )
+    fail TypeError, m.X!( what_is_receiver ) 
+  end
+
+  # This method takes a block and fails with +TypeError+, unless the receiver
   # causes the supplied block <em>to return falsey value</em>. Optional arguments
   # customize customize the error message. First optional argument describes the
   # receiver, the second one describes the tested duck type. If the criterion
@@ -67,84 +63,91 @@ class Object
   # no block is given, it is checked, whether the object is falsey.
   # 
   def aT_not what_is_receiver=insp, how_comply=nil, &b
-    tap do
-      if block_given? then
-        if b.( self ) then
-          m = how_comply ? "%s must not #{how_comply}" : "%s fails its check"
-          fail TypeError, m.X!( what_is_receiver )
-        end
-      else fail TypeError if self end
-    end
+    return tap { fail TypeError if self } unless b
+    return self unless b.( self )
+    m = how_comply ? "%s must not #{how_comply}" : "%s fails its check"
+    fail TypeError, m.X!( what_is_receiver )
   end
 
-  # Fails with TypeError unless the receiver is of the prescribed class. Second
+  # Fails with +TypeError+ unless the receiver is of the prescribed class. Second
   # optional argument customizes the error message (receiver description).
   # 
   def aT_kind_of klass, what_is_receiver=insp
-    tap do
-      is_a? klass or fail TypeError, "%s not a #{klass}".X!( what_is_receiver )
-    end
+    return self if is_a? klass
+    fail TypeError, "%s not a #{klass}".X!( what_is_receiver )
   end
   alias aT_is_a aT_kind_of
 
-  # Fails with TypeError unless the receiver declares compliance with the
+  # Fails with +TypeError+ unless the receiver declares compliance with the
   # given class, or is a descendant of that class. Second optional argument
   # customizes the error message (receiver description).
   # 
-  def aT_class_complies klass, what_is_receiver=insp
-    if class_complies? klass then
-      fail TypeError, "%s does not comply with #{klass}".X!( what_is_receiver )
-    else self end
+  def aT_complies klass, what_is_receiver=insp
+    return self if class_complies? klass
+    fail TypeError, "%s does not comply with #{klass}".X!( what_is_receiver )
   end
-  
-  # Fails with TypeError unless the receiver responds to the given
-  # method. Second optional argument customizes the error message (receiver
-  # description).
+  alias aT_class_complies aT_complies
+
+  # Fails with +TypeError+ unless the receiver responds to the given method.
+  # Second optional argument customizes the error message (receiver description).
   # 
   def aT_respond_to method_name, what_is_receiver=insp
-    if respond_to? method_name then self else
-      m = "%s does not respond to method '#{method_name}'"
-      fail TypeError, m.X!( what_is_receiver )
-    end
+    return self if respond_to? method_name
+    fail TypeError,
+         "%s does not respond to '#{method_name}'".X!( what_is_receiver )
   end
   alias aT_responds_to aT_respond_to
-  
-  # Fails with TypeError unless the receiver, according to #== method, is
+
+  # Fails with +TypeError+ unless the receiver, according to +#==+ method, is
   # equal to the argument. Two more optional arguments customize the error
   # message (receiver description and the description of the other object).
   # 
   def aT_equal other, what_is_receiver=insp, what_is_other=nil
-    if self == other then self else
-      wo = what_is_other || "the prescribed value (#{other.insp})"
-      fail TypeError, "%s must be equal to %s".X!( [ what_is_receiver, wo ] )
-    end
+    return self if self == other
+    wo = what_is_other || "the prescribed value (#{other.insp})"
+    fail TypeError, "%s must be equal to %s".X!( [ what_is_receiver, wo ] )
   end
 
-  # Fails with TypeError unless the receiver, according to #== method, differs
-  # from to the argument. Two more optional arguments customize the error
+  # Fails with +TypeError+ unless the receiver, according to +#==+ method,
+  # differs from to the argument. Two more optional arguments customize the error
   # message (receiver description and the description of the other object).
   # 
   def aT_not_equal other, what_is_receiver=insp, what_is_other=nil
-    if self == other
-      wo = what_is_other || "the prescribed value (#{other.insp})"
-      fail TypeError, "%s must not == %s".X!( [ what_is_receiver, wo ] )
-    else self end
+    return self unless self == other
+    wo = what_is_other || "the prescribed value (#{other.insp})"
+    fail TypeError, "%s must not == %s".X!( [ what_is_receiver, wo ] )
   end
 
-  # Fails with TypeError unless the ActiveSupport method #blank returns true
-  # for the receiver.
+  # Fails with +TypeError+ unless activesupport's +#blank+ returns true for
+  # the receiver.
   # 
   def aT_blank what_is_receiver=insp
     tap { blank? or fail TypeError, "%s not blank".X!( what_is_receiver ) }
   end
 
-  # Fails with TypeError unless the ActiveSupport method #present returns true
-  # for the receiver.
+  # Fails with +TypeError+ unless activesupport's +#present+ returns true for
+  # the receiver.
   # 
   def aT_present what_is_receiver=insp
     tap { present? or fail TypeError, "%s not present".X!( what_is_receiver ) }
   end
 
+  # Fails with +ArgumentError+ unless the +ActiveSupport+ method +#blank+ returns
+  # true for the receiver.
+  # 
+  def aA_blank what_is_receiver=insp
+    tap { blank? or fail ArgumentError, "%s not blank".X!( what_is_receiver ) }
+  end
+
+  # Fails with +ArgumentError+ unless the +ActiveSupport+ method #present returns
+  # true for the receiver.
+  # 
+  def aA_present what_is_receiver=insp
+    tap {
+      present? or fail ArgumentError, "%s not present".X!( what_is_receiver )
+    }
+  end
+
   private
 
   # Some objects do not have accessible singleton class. This method returns

data/lib/y_support/typing/object.rb

@@ -1 +1 @@
-require 'y_support/core_ext/object/typing'
+require File.dirname( __FILE__ ) + '/object/typing'