quality_extensions 0.1.1

data/lib/qualitysmith_extensions/module/includable_once.rb

@@ -0,0 +1,10 @@
+
+#    mattr_accessor :already_included
+#    def self.already_included
+#      @@already_included ||= false
+#    end
+#
+#    def self.included(base_module)
+#      return if @@already_included
+#      @@already_included = true
+#

data/lib/qualitysmith_extensions/module/join.rb

@@ -0,0 +1,66 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+
+require 'rubygems'
+require 'facets/core/symbol/to_proc'
+require 'qualitysmith_extensions/symbol/constantize'
+require 'qualitysmith_extensions/module/namespace'  # dirname
+require 'qualitysmith_extensions/module/basename'
+
+class Module
+  # Joins pieces of a "module path" together in the same sense that <tt>File.join</tt> joins pieces of a _filesystem_ path.
+  #
+  # See also <tt>Module.dirname</tt>/<tt>Module.namespace_name_of</tt> and <tt>Module.basename</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.join(*path_parts)
+    path_parts.map(&:to_s).join('::')
+  end
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+module OuterModule; end
+module OuterModule::MiddleModule; end
+module OuterModule::MiddleModule::InnerModule; end
+
+class JoinTest < Test::Unit::TestCase
+  def test_join
+    assert_equal 'OuterModule::MiddleModule::InnerModule',
+                 Module.join('OuterModule', 'MiddleModule', 'InnerModule')
+  end
+end
+
+class TeamworkTest < Test::Unit::TestCase
+  def test_join
+    assert_equal ['OuterModule::MiddleModule', 'InnerModule'],
+                 [Module.dirname(OuterModule::MiddleModule::InnerModule), Module.basename(OuterModule::MiddleModule::InnerModule)]
+    assert_equal 'OuterModule::MiddleModule::InnerModule',
+                 Module.join(Module.dirname(OuterModule::MiddleModule::InnerModule), Module.basename(OuterModule::MiddleModule::InnerModule))
+    assert_equal OuterModule::MiddleModule::InnerModule,
+                 Module.join(Module.dirname(OuterModule::MiddleModule::InnerModule), Module.basename(OuterModule::MiddleModule::InnerModule)).constantize
+  end
+end
+=end
+
+
+

data/lib/qualitysmith_extensions/module/malias_method_chain.rb

@@ -0,0 +1,92 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+require 'rubygems'
+gem 'facets'
+require 'facets/core/kernel/singleton_class'
+require 'qualitysmith_extensions/module/alias_method_chain'
+
+class Module
+
+  # Same as <tt>Module#alias_method_chain</tt>, only it works for modules/classes
+  #
+  #   class X
+  #     def self.foo
+  #       'foo'
+  #     end
+  #     malias_method_chain :foo, :feature
+  #   end
+  #
+  # Note: You could always do the same thing with <tt>Module#alias_method_chain</tt> by simply doing this:
+  #
+  #   class << self
+  #     alias_method_chain :foo, :feature
+  #   end
+  #
+  def malias_method_chain(target, feature, *args)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+
+    singleton_class.instance_eval do
+      alias_method_chain target, feature, *args
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TestHowYouWouldDoItWithPlain_alias_method_chain < Test::Unit::TestCase
+
+  class X
+    def self.foo
+      'foo'
+    end
+    def self.foo_with_feature
+      foo_without_feature + '_with_feature'
+    end
+    class << self
+      alias_method_chain :foo, :feature
+    end
+  end
+
+  def test_001
+    assert_equal 'foo_with_feature', X.foo
+  end
+
+end
+
+class Test_malias_method_chain < Test::Unit::TestCase
+
+  class Y
+    def self.foo
+      'foo'
+    end
+    def self.foo_with_feature
+      foo_without_feature + '_with_feature'
+    end
+    malias_method_chain :foo, :feature
+  end
+
+  def test_001
+    assert_equal 'foo_with_feature', Y.foo
+  end
+
+end
+
+=end
+

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,112 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+# * 0.0.52: Renamed namespace to namespace_module to avoid conflicting with Facets' Module#namespace and Rake's namespace
+#++
+
+
+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_module
+    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_module.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_module
+  end
+  def test_nesting
+    assert_equal OuterModule::MiddleModule, 
+                 OuterModule::MiddleModule::InnerModule.namespace_module
+  end
+  def test_nesting_2
+    assert_equal NamespaceTest, InnerModule.namespace_module
+  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
+
+
+