qualitysmith_extensions 0.0.34 → 0.0.49

data/lib/qualitysmith_extensions/array/shell_escape.rb

@@ -2,11 +2,11 @@
 # Author::    Tyler Rick
 # Copyright:: Copyright (c) 2007 QualitySmith, Inc.
 # License::   Ruby License
-# Submit to Facets?:: Yes. Symbol#to_proc -> Facets
+# Submit to Facets?:: Yes.
 #++
 
 require 'rubygems'
-require 'extensions/symbol' unless Symbol.method_defined?(:to_proc)
+require 'facets/core/symbol/to_proc' unless Symbol.method_defined?(:to_proc)
 require 'facets/core/kernel/require_local'
 require_local '../string/shell_escape.rb'
 

data/lib/qualitysmith_extensions/kernel/remove_const.rb

@@ -0,0 +1,178 @@
+#--
+# 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'
+
+class Module
+  alias_method :remove_const_before_was_added_to_Kernel, :remove_const
+end
+module Kernel
+  # This is similar to the built-in <tt>Module#remove_const</tt>, but it is accessible from all "levels" (because it is defined
+  # in +Kernel+) and can handle hierarchy.
+  #
+  # Makes it possible to write simply:
+  #   remove_const(A::B::C.name)
+  # 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 otherwise have to do it:
+  #   A::B.send(:remove_const, :C)
+  #
+  # +const_name+ must be an object that responds to +to_s+.
+  #
+  # +const_name+ must be a <i>fully qualified name</i>. For example, this will not work as expected:
+  #
+  #   module Mod
+  #     Foo = 'foo'
+  #     remove_const(:Foo)
+  #   end
+  #
+  # because it will try to remove ::Foo instead of Mod::Foo. Fortunately, however, this will work as expected:
+  #
+  #   module Mod
+  #     Foo = 'foo'
+  #     remove_const(Foo.name)
+  #   end
+  #
+  # This method is partially inspired by Facets' Kernel#constant method, which provided a more user-friendly alternative to const_get.
+  #
+  def remove_const(const_name)
+    #require 'pp'
+    #puts "remove_const(#{const_name})"
+    raise ArgumentError unless const_name.respond_to?(:to_s)
+    nesting = const_name.to_s.split(/::/).map(&:to_sym)
+    if nesting.size > 1
+      parent_module = constant(nesting[0..-2].join('::')) # For example, would be A::B for A::B::C
+      const_to_remove = nesting[-1]                       # For example, would be :C   for A::B::C
+      parent_module.ignore_access.remove_const_before_was_added_to_Kernel(const_to_remove)
+    else
+      ignore_access.remove_const_before_was_added_to_Kernel(const_name)
+    end
+  end
+end
+
+#p Module.private_instance_methods.grep(/remove_const/) # Lists it
+Module.send(:remove_method, :remove_const)
+#p Module.instance_methods.grep(/remove_const/)         # Does list it, because inherits *public* remove_const from Kernel
+#p Module.private_instance_methods.grep(/remove_const/) # Does not list it, because it's no longer private
+Module.send(:define_method, :remove_const, Kernel.method(:remove_const))
+#p Module.private_instance_methods.grep(/remove_const/) # Lists it
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+# Important regression test. This was failing at one point.
+module A
+  B = nil
+  remove_const :B
+end
+
+# How it would be done *without* this extension:
+module TestRemoveABC_TheOldWay
+  module A
+    module B
+      C = 'foo'
+    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 (all tests that follow):
+
+module TestRemoveABC_CIsString
+  module A
+    module B
+      C = 'foo'
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B::C }
+      assert_raise(NoMethodError) { remove_const(A::B::C.name) } # Because C is a *string*, not a *module*
+      assert_nothing_raised   { remove_const A::B.name + '::C' }
+      assert_raise(NameError) { A::B::C }
+    end
+  end
+end
+
+module TestRemoveAB_UsingName
+  module A
+    module B
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B }
+      remove_const(A::B.name)
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+module TestRemoveAB_Symbol
+  module A
+    module B
+      Foo = :Foo
+    end
+  end
+
+  remove_const(:'A::B::Foo')      # This tests that Module#remove_const was overriden as well.
+                                  # If we hadn't also overriden Module#remove_const, then this would have caused this error:
+                                  #   in `remove_const': `A::B::Foo' is not allowed as a constant name (NameError)
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B }
+
+      assert_equal 'TestRemoveAB_Symbol::A', A.name
+      assert_raise(NameError) { remove_const(:'A::B') }   # This doesn't work because A, when evaluated in this context, 
+                                                          # is TestRemoveAB_Symbol::TheTest::A, which is *not* defined.
+ 
+      remove_const(:'TestRemoveAB_Symbol::A::B')
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+module TestRemoveAB_Symbol2
+  class TheTest < Test::Unit::TestCase
+    module A
+      module B
+      end
+    end
+    def test_1
+      assert_nothing_raised   { A::B }
+
+      assert_equal 'TestRemoveAB_Symbol2::TheTest::A', A.name
+      remove_const(:'A::B')        # Does work, because A is defined *within* TheTest this time.
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+=end
+
+

data/lib/qualitysmith_extensions/kernel/remove_module.rb

@@ -0,0 +1,127 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: No.
+# Developer notes::
+# * Deprecated by qualitysmith_extensions/module/remove.rb
+#++
+
+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 +remove_const+, but it _only_ works for modules/classes.
+  #
+  # This is similar to the built-in <tt>Module#remove_module</tt>, but it is accessible from all "levels" (because it is defined
+  # in +Kernel+) and can handle hierarchy.
+  #
+  # Makes it possible to write simply:
+  #   remove_module(A::B::C)
+  # 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)
+  #
+  # You can pass in either a constant or a symbol. Passing in a constant is preferred
+  #
+  # This method is partially inspired by Facets' Kernel#constant method, which provided a more user-friendly alternative to const_get.
+  #
+  def remove_module(const)
+    const = Module.by_name(const.to_s) if const.is_a?(Symbol)
+    if const.split.size > 1
+      parent_module = const.modspace      # For example, would be A::B for A::B::C
+      const_to_remove = const.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(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 }
+      remove_module(A::B::C)
+      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 }
+      remove_module(A::B)
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+module TestRemoveAB_Symbol
+  module A
+    module B
+      module C
+      end
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B }
+      assert_raise(NameError) { remove_module(:'A::B') }   # This is why passing in the module itself is preferred.
+      remove_module(:'TestRemoveAB_Symbol::A::B')
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+=end
+
+

data/lib/qualitysmith_extensions/module/ancestry_of_instance_method.rb

@@ -0,0 +1,43 @@
+#--
+# 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?
+# * Tests for this method can be found in ../object/ancestry_of_method.rb . It made more sense to test those two methods together;
+#   yet it's still to _use_ module/ancestry_of_instance_method.rb without using ../object/ancestry_of_method.rb.
+#++
+
+class Module
+
+  # Returns the module/class which defined the given instance 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 looks at the results of <tt>instance_methods</tt>, which means that if you call this on a module/class, it will _only_ look 
+  # at _instance_ methods. Thus, (unlike +ancestry_of_method+) it _only_ makes sense to call this method on modules/classes, 
+  # not _instances_ of those modules/classes.
+  #
+  # Example:
+  #   class Base
+  #     def it; end
+  #   end
+  #   class SubWithIt < Base
+  #     def it; end
+  #   end
+  #   class SubWithoutIt < Base
+  #   end
+  #   SubWithIt.ancestors # => [SubWithIt, Base, Object, Kernel]
+  #   SubWithIt.ancestry_of_instance_method(:it)    # => SubWithIt  # (Stops with self)
+  #   SubWithoutIt.ancestry_of_instance_method(:it) # => Base       # (Goes one step up the ancestry tree)
+  #
+  # Returns nil if it cannot be found in self or in any ancestor.
+  def ancestry_of_instance_method(method_name)
+    method_name = method_name.to_s
+    self.ancestors.find do |ancestor|
+      ancestor.instance_methods(false).include? method_name
+    end
+  end
+
+end

data/lib/qualitysmith_extensions/module/attribute_accessors.rb

@@ -20,6 +20,7 @@ class Module # :nodoc:
       EOS
     end
   end
+  alias_method :cattr_reader, :mattr_reader
   
   def mattr_writer(*syms)
     syms.each do |sym|
@@ -38,9 +39,11 @@ class Module # :nodoc:
       EOS
     end
   end
+  alias_method :cattr_writer, :mattr_writer
   
   def mattr_accessor(*syms)
     mattr_reader(*syms)
     mattr_writer(*syms)
   end
+  alias_method :cattr_accessor, :mattr_accessor
 end

data/lib/qualitysmith_extensions/module/basename.rb

@@ -0,0 +1,76 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+
+require 'rubygems'
+require 'facets/core/module/basename'
+require 'facets/core/string/basename'
+require 'qualitysmith_extensions/module/namespace'
+
+class Module
+  # Gets the basename of a "module path" (the name of the module without any of the namespace modules that it is contained in), 
+  # in the same sense that <tt>File.basename</tt> returns the basename of a _filesystem_ path.
+  #
+  # This is identical to Facets' String#basename ('facets/core/string/basename') except that:
+  # * it is a class method instead of an instance method of String,
+  # * it accepts modules, strings, and symbols.
+  #
+  # See also <tt>Module.dirname</tt>/<tt>Module.namespace_name_of</tt>.
+  #
+  # These can be used together, such that the following is always true:
+  #   OuterModule::MiddleModule::InnerModule == Module.join(Module.dirname(some_module), Module.basename(some_module)).constantize
+  #   
+  def self.basename(module_or_name)
+    case module_or_name
+      when Module
+        module_or_name.basename
+      when Symbol
+        module_or_name.to_s.basename
+      when String
+        module_or_name.basename
+      else
+        raise ArgumentError
+    end
+  end
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+module OuterModule; end
+module OuterModule::MiddleModule; end
+module OuterModule::MiddleModule::InnerModule; end
+
+class BasenameTest < Test::Unit::TestCase
+  def test_simple
+    assert_equal 'OuterModule', Module.basename(OuterModule)
+    assert_equal 'OuterModule', Module.basename(:OuterModule)
+    assert_equal 'OuterModule', Module.basename('OuterModule')
+  end
+  def test_nesting
+    assert_equal 'InnerModule',
+                 Module.basename(OuterModule::MiddleModule::InnerModule)
+    assert_equal 'InnerModule',
+                 Module.basename(:'OuterModule::MiddleModule::InnerModule')
+    assert_equal 'InnerModule',
+                 Module.basename('OuterModule::MiddleModule::InnerModule')
+  end
+end
+=end
+
+