qualitysmith_extensions 0.0.34 → 0.0.49

data/lib/qualitysmith_extensions/module/module_methods.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+# Alias for:
+require 'qualitysmith_extensions/module/class_methods'
+

data/lib/qualitysmith_extensions/module/namespace.rb

@@ -0,0 +1,111 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+
+require 'rubygems'
+require 'qualitysmith_extensions/symbol/constantize'
+require 'qualitysmith_extensions/module/split'
+
+
+class Module
+  # Return the module which contains this one; if this is a root module, such as
+  # +::MyModule+, then Object is returned.
+  def namespace
+    namespace_name = name.split('::')[0..-2].join('::')
+    namespace_name.empty? ? Object : namespace_name.constantize
+  end
+
+  # Gets the "dirname" of a "module path" (the string/symbol representing the namespace modules that it is contained in), 
+  # in the same sense that <tt>File.dirname</tt> returns the dirname of a _filesystem_ path.
+  #
+  # Same as +namespace_of+, only this just returns the _name_ of the namespace module (as a string), rather than returning the
+  # constant itself.
+  #
+  # See also <tt>Module.basename</tt>
+  def self.dirname(module_or_name)
+    case module_or_name
+      when Module
+        module_or_name.namespace.name
+      when Symbol
+        Module.split_name(module_or_name)[0..-2].join('::')
+      when String
+        Module.split_name(module_or_name)[0..-2].join('::')
+    end
+  end
+  class << self
+    alias_method :namespace_name_of, :dirname
+  end
+
+  def self.namespace_of(module_or_name)
+    namespace_name_of(module_or_name).constantize
+  end
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+module OuterModule; end
+module OuterModule::MiddleModule; end
+module OuterModule::MiddleModule::InnerModule; end
+
+class NamespaceTest < Test::Unit::TestCase
+  module InnerModule; end
+  def test_1
+    assert_equal Object, OuterModule.namespace
+  end
+  def test_nesting
+    assert_equal OuterModule::MiddleModule, 
+                 OuterModule::MiddleModule::InnerModule.namespace
+  end
+  def test_nesting_2
+    assert_equal NamespaceTest, InnerModule.namespace
+  end
+end
+
+class NamespaceOfTest < Test::Unit::TestCase
+  module InnerModule; end
+  def test_1
+    assert_equal Object, Module.namespace_of(OuterModule)
+  end
+  def test_nesting
+    assert_equal OuterModule::MiddleModule,
+                 Module.namespace_of(OuterModule::MiddleModule::InnerModule)
+    assert_equal OuterModule::MiddleModule,
+                 Module.namespace_of(:'OuterModule::MiddleModule::InnerModule')
+    assert_equal OuterModule::MiddleModule,
+                 Module.namespace_of('OuterModule::MiddleModule::InnerModule')
+  end
+end
+
+class NamespaceNameOfTest < Test::Unit::TestCase
+  module InnerModule; end
+  def test_1
+    assert_equal 'Object',
+                 Module.namespace_name_of(OuterModule)
+  end
+  def test_nesting
+    assert_equal 'OuterModule::MiddleModule',
+                 Module.namespace_name_of(OuterModule::MiddleModule::InnerModule)
+    assert_equal 'OuterModule::MiddleModule',
+                 Module.namespace_name_of(:'OuterModule::MiddleModule::InnerModule')
+    assert_equal 'OuterModule::MiddleModule',
+                 Module.namespace_name_of('OuterModule::MiddleModule::InnerModule')
+  end
+end
+=end
+

data/lib/qualitysmith_extensions/module/parents.rb

@@ -0,0 +1,61 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) ActiveSupport authors
+# License::   
+# Submit to Facets?:: Yes.
+# Developer notes::
+# * Tests incomplete...
+# Changes::
+# * Copied from ActiveSupport.
+#++
+
+
+require 'rubygems'
+require 'facets/core/kernel/constant'
+
+
+class Module
+  # Return all the parents of this module, ordered from nested outwards. The
+  # receiver is not contained within the result.
+  def parents
+    parents = []
+    parts = name.split('::')[0..-2]
+    until parts.empty?
+      #parents << (parts * '::').constantize
+      parents << constant(parts * '::')
+      parts.pop
+    end
+    parents << Object unless parents.include? Object
+    parents
+  end
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+module OuterModule; end
+module OuterModule::InnerModule; end
+
+class TheTest < Test::Unit::TestCase
+  module InnerModule; end
+  def test_1
+    assert_equal [Object], OuterModule.parents
+  end
+  def test_nesting
+    assert_equal [OuterModule, Object], OuterModule::InnerModule.parents
+  end
+  def test_nesting_2
+    assert_equal [TheTest, Object], InnerModule.parents
+  end
+end
+=end
+

data/lib/qualitysmith_extensions/module/remove_const.rb

@@ -0,0 +1,117 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+#++
+
+require 'rubygems'
+require 'qualitysmith_extensions/object/ignore_access'
+require 'qualitysmith_extensions/module/split'
+require 'facets/core/module/by_name'
+require 'facets/core/module/modspace'
+
+module Kernel
+  # This is similar to +Kernel#remove_const+, but it _only_ works for modules/classes.
+  #
+  # This is similar to the built-in <tt>Module#remove_module</tt>, but it lets you do it in a more object oriented manner,
+  # calling +remove!+ on the module/class/constant itself that you want to remove, rather than on its parent.
+  #
+  # Makes it possible to write simply:
+  #   A::B::C.remove_const!
+  # rather than having to think about which module the constant is actually defined in and calling +remove_const+ on that module.
+  # This is how you would have to otherwise do it:
+  #   A::B.send(:remove_const, :C)
+  #
+  def remove_const!
+    if split.size > 1
+      parent_module = modspace      # For example, would be A::B for A::B::C
+      const_to_remove = split.last  # For example, would be :C   for A::B::C
+      parent_module.ignore_access.remove_const(const_to_remove)
+    else
+      Object.ignore_access.remove_const(name)
+    end
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'qualitysmith_extensions/kernel/remove_const'     # Test for compatibility. Just in case the remove_const_before_was_added_to_Kernel alias might have thrown something off.
+
+# How it would be done *without* this extension:
+module TestRemoveABC_TheOldWay
+  module A
+    module B
+      class C
+      end
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B::C }
+      A::B.send(:remove_const, :C)
+      assert_raise(NameError) { A::B::C }
+    end
+  end
+end
+
+# How it would be done *with* this extension:
+module TestRemoveABC
+  module A
+    module B
+      class C
+      end
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B::C }
+      A::B::C.remove_const!
+      assert_raise(NameError) { A::B::C }
+    end
+  end
+end
+
+module TestRemoveAB
+  module A
+    module B
+      module C
+      end
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B }
+      A::B.remove_const!
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+module A
+end
+module TestRemoveA_FromObject
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A }
+      A.remove_const!
+      assert_raise(NameError) { A }
+    end
+  end
+end
+
+=end
+
+
+

data/lib/qualitysmith_extensions/module/split.rb

@@ -0,0 +1,55 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes!
+# Developer notes::
+#++
+
+require 'rubygems'
+require 'facets/core/symbol/to_proc'
+
+class Module
+  # Very similar to Facets' +Module#nesting+, but, whereas +nesting+ will break <tt>A::B</tt> into an array of _constants_ represting nesting
+  # (<tt>[A, A::B]</tt>), this method will split it into an array of _symbols_: <tt>[:A, :B]</tt>.
+  #
+  # Note that the second element in this array, <tt>:B</tt>, is _not_ fully qualified, so you could not do a <tt>const_get</tt>
+  # on that symbol.
+  def split
+    name.split(/::/).map(&:to_sym)
+  end
+
+  # Like Module#split, only this operates on a string/symbol. Useful for when you don't want to or can't actually instantiate
+  # the module represented by the symbol.
+  def self.split_name(name)
+    name.to_s.split(/::/).map(&:to_sym)
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+module A
+  module B
+  end
+end
+
+class TheTest < Test::Unit::TestCase
+  def test_A
+    assert_equal [:A], A.split
+  end
+  def test_A_B
+    assert_equal [:A, :B], A::B.split
+  end
+
+end
+=end
+
+

data/lib/qualitysmith_extensions/object/ancestry_of_method.rb

@@ -0,0 +1,257 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# * May not have taken every single case into consideration. Needs a bit more testing.
+#   * public/private/protected?
+# * Rename to origin_of_method (or source_of_method)?? Since strictly speaking it may return a method that is not from any *ancestors* but is from the Class class.
+#++
+
+require 'rubygems'
+require 'qualitysmith_extensions/module/class_methods'
+require 'qualitysmith_extensions/module/ancestry_of_instance_method'
+
+
+class Object
+  # Returns the module/class which defined the given method. If more than one module/class defined the method, returns the _closest_
+  # ancestor to have defined it (would be +self+ if it is defined in +self+).
+  #
+  # This is (as far as I know -- patches welcome) <b>the method that would _would_ be called if you actually called the method</b>.
+  # So if you override 
+  #
+  # It does this by first checking
+  # searching the methods defined in each ancestor in turn (in the order that <tt>self.ancestors</tt> returns them) and
+  # returning the first module/class that satisfies the search.
+  #
+  # This looks at the results of <tt>methods</tt>, which means that if you call this on a module/class, it will _not_ return
+  # any instance methods, only _class_ methods.
+  #
+  #   class Base
+  #     def self.it; end
+  #   end
+  #   class SubWithIt < Base
+  #     def self.it; end
+  #   end
+  #   class SubWithoutIt < Base
+  #   end
+  #   SubWithIt.ancestry_of_instance_method(:it)    # => SubWithIt  # (Stops with self)
+  #   SubWithoutIt.ancestry_of_instance_method(:it) # => Base       # (Goes one step up the ancestry tree)
+  #
+  # If you call this on an object that is _not_ a module or a class (in other words, if you call it on an _instance_ of some
+  # class), then it will assume you actually want to know about an _instance_ method defined in self.class or one of the
+  # ancestors of self.class. (Since non-modules don't even technically have the concept of _ancestors_.) Therefore, this:
+  #   class Klass
+  #     def it; end
+  #   end
+  #   o = Klass.new
+  #   o.ancestry_of_method(:it)                      # => Klass
+  # is really just a shorthand way of doing:
+  #   o.class.ancestry_of_instance_method(:it)       # => Klass
+  #
+  # If the method is a singleton method of +self+, it will return +self+:
+  #   class << (foo = SubWithIt.new)
+  #     def it; end
+  #   end
+  #   foo.ancestry_of_method(:it) # => #<SubWithIt:0xb7e5614c>
+  #
+  # Returns nil if it cannot be found in self or in any ancestor.
+  def ancestry_of_method(method_name)
+    method_name = method_name.to_s
+    (self if self.methods(false).include?(method_name)) \
+    ||
+    if self.is_a?(Module)
+      self.ancestors.find do |ancestor|
+        ancestor.methods(false).include? method_name
+      end or
+      # The above search does not take into account *instance* methods provided by Class, Module, or Kernel.
+      # Remember that ancestors and instances/class/superclass are different concepts, and that although classes/modules
+      # do not have Class or Module as an "ancestor", they are still *instances* of Module or Class (which is a subclass of module).
+      # self.ancestors does NOT include Class or Module, and yet we're still able to "inherit" instance methods from Class or Module.
+      # So we have to do this extra search in case the method came from one of the instance methods of Class or Module or Kernel
+      # (are there any other cases I'm missing?).
+      begin
+        # self.class.ancestors is usually [Class, Module, Object, PP::ObjectMixin, Kernel]
+        self.class.ancestors.find do |ancestor|
+          ancestor.instance_methods(false).include? method_name 
+          # || ancestor.private_instance_method_defined?( method_name.to_sym )
+        end
+      end
+    else
+      self.class.ancestry_of_instance_method(method_name)
+    end
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'rubygems'
+require 'qualitysmith_extensions/test/assert_anything'
+
+class Base
+  def it; end
+end
+class SubWithIt < Base
+  def it; end
+end
+class SubWithoutIt < Base
+end
+
+class << ($with_singleton_method = SubWithIt.new)
+  def it; end
+end
+
+class ClassyBase
+  def self.classy_it; end
+end
+class ClassySubWithIt < ClassyBase
+  def self.classy_it; end
+end
+class ClassySubWithoutIt < ClassyBase
+end
+
+class << ($class_with_singleton_method = ClassySubWithIt)
+  def classy_it; end
+end
+
+class ATest < Test::Unit::TestCase
+  def test_non_existent_method
+    assert_equal nil,      Base.ancestry_of_method(:not_a_method)
+    assert_equal nil,      Base.ancestry_of_instance_method(:not_a_method)
+  end
+end
+
+class InstanceMethodsTest < Test::Unit::TestCase
+  def test_1
+    assert_equal [SubWithoutIt, Base, Object, PP::ObjectMixin, Kernel], SubWithoutIt.ancestors
+    assert_equal Base,      Base.ancestry_of_instance_method(:it)
+    assert_equal Base,      SubWithoutIt.ancestry_of_instance_method(:it)
+    assert_equal SubWithIt, SubWithIt.ancestry_of_instance_method(:it)
+    assert_equal SubWithIt, SubWithIt.ancestry_of_instance_method(:it)
+  end
+  def test_ancestry_of_method__falls_back_to_using__ancestry_of_instance_method__if_is_an_instance
+    assert_include?         Base.instance_methods, :it.to_s
+    assert_equal Base,      Base.new.ancestry_of_method(:it)
+    assert_equal Base,      SubWithoutIt.new.ancestry_of_method(:it)
+    assert_equal SubWithIt, SubWithIt.new.ancestry_of_method(:it)
+
+    # In other words, it's a *shortcut*. See?:
+    o = SubWithIt.new
+    assert_equal o.class.ancestry_of_instance_method(:it), o.ancestry_of_method(:it)
+  end
+  def test_singleton_method
+    assert_equal $with_singleton_method, $with_singleton_method.ancestry_of_method(:it)
+  end
+  def test_that_you_cant_use_ancestry_of_instance_method_for_instances
+    # undefined method `ancestors' for #<SubWithIt:0xb7e0fbc0>
+    assert_raise(NoMethodError) { SubWithIt.new.ancestry_of_instance_method(:it) }
+    assert_raise(NoMethodError) { $with_singleton_method.ancestry_of_instance_method(:it) }
+  end
+end
+class ClassMethodsTest < Test::Unit::TestCase
+  def test_ancestry_of_method_doesnt_return_instance_methods
+    assert_include?     Base.instance_methods, :it.to_s
+    assert_not_include? Base.methods,          :it.to_s
+
+    assert_equal [SubWithoutIt, Base, Object, PP::ObjectMixin, Kernel], SubWithoutIt.ancestors
+
+    assert_equal nil, Base.ancestry_of_method(:it)
+    assert_equal nil, SubWithoutIt.ancestry_of_method(:it)
+    assert_equal nil, SubWithIt.ancestry_of_method(:it)
+  end
+  def test_ancestry_of_method_does_return_class_methods
+    assert_include?     ClassyBase.methods,          :classy_it.to_s
+    assert_not_include? ClassyBase.instance_methods, :classy_it.to_s
+
+    assert_equal [ClassySubWithoutIt, ClassyBase, Object, PP::ObjectMixin, Kernel], ClassySubWithoutIt.ancestors
+
+    assert_equal ClassyBase,      ClassySubWithoutIt.ancestry_of_method(:classy_it)
+    assert_equal ClassyBase,      ClassyBase.ancestry_of_method(:classy_it)
+    assert_equal ClassySubWithIt, ClassySubWithIt.ancestry_of_method(:classy_it)
+  end
+  def test_singleton_method
+    assert_equal $class_with_singleton_method, $class_with_singleton_method.ancestry_of_method(:classy_it)
+    assert_equal nil,                          $class_with_singleton_method.ancestry_of_instance_method(:classy_it)
+  end
+end
+
+class BuiltInMethodsTest < Test::Unit::TestCase
+  def test_1
+    assert_equal [Object, PP::ObjectMixin, Kernel], Object.ancestors
+    assert_equal Kernel, Object.ancestry_of_method(:binding)
+    assert_equal Kernel, Object.ancestry_of_method(:require)
+    assert_equal Kernel, Object.ancestry_of_method(:proc)
+  end
+
+  def test_looks_at_Class_Module_and_Kernel_instance_methods_if_necessary
+    # Sometimes it inherits a method NOT from any of its ancestors, but from Class (one of the *instance methods* of Class).
+
+    # (Class is *not* an ancestor of Object and yet that appears to be where these methods come from.)
+    assert_not_include? Object.ancestors, Class
+    assert_equal Class, Object.class
+    [
+      :superclass,
+      :new,
+      :allocate,
+    ].each do |method|
+      assert_ancestry_of_method_is Object, method, Class
+    end
+
+    # superclass (and others) comes from Class, but instance_variable_get (and others) come from Module or Kernel.
+    # (See below for more examples)
+    assert_equal true, Class.instance_methods(false).include?('superclass')
+    assert_equal false, Class.instance_methods(false).include?('instance_variable_get')
+    assert_equal true, Kernel.instance_methods(false).include?('instance_variable_get')
+
+    # (Module is *not* an ancestor of Object and yet that appears to be where these methods come from.)
+    assert_not_include? Object.ancestors, Module
+    [
+      :instance_methods,
+      :included_modules,
+      :constants,
+      :ancestors,
+      :public_method_defined?,
+    ].each do |method|
+      assert_equal Module, Object.ancestry_of_method(method), "Failed for #{method}"
+    end
+
+    # (Kernel *is* an ancestor of Object, but these methods come from Kernel.instance_methods and *not* from Kernel.methods.)
+    assert_include? Object.ancestors, Kernel
+    [
+      :puts,
+      :system,
+      :inspect,
+      :send,
+      :private_methods,
+      :instance_variable_get,
+    ].each do |method|
+      assert_equal Kernel, Object.ancestry_of_method(method)
+    end
+
+    # proc apparently comes from *class method* Kernel.proc,
+    # while instance_variable_get comes from *intance method* Kernel.instance_variable_get
+    assert_equal true,  Kernel.class_methods(false).include?('proc')
+    assert_equal false, Kernel.instance_methods(false).include?('proc')
+    assert_equal false, Kernel.class_methods(false).include?('instance_variable_get')
+    assert_equal true,  Kernel.instance_methods(false).include?('instance_variable_get')
+
+    # Where does this method come from then???
+    [
+      :remove_class_variable,
+      :remove_const,
+      :remove_method,
+      :undef_method,
+      :nesting,
+    ].each do |method|
+      assert_equal nil, Object.ancestry_of_method(method)
+    end
+  end
+end
+=end