use 1.2.1 → 1.2.2

data/CHANGES

@@ -1,3 +1,13 @@
+== 1.2.2 - 16-Sep-2008
+* Fixed a bug where methods already defined prior to the inclusion
+  of a module could be accidentally undefined.
+* Added some inline documentation for the sake of RDoc.
+* Renamed test/test_data.rb to test/sample_data.rb, since it's not an
+  actual test file.
+* Renamed test/tc_use.rb to test/test_use.rb to be more in line with what
+  both Rake and Test::Unit (and the Ruby community in general) expect.
+* Minor Rakefile update.
+
 == 1.2.1 - 22-May-2007
 * Added a Rakefile, with tasks for testing and installation.
 * Removed the install.rb file. Installation is now handled by the 'rake

data/MANIFEST

@@ -5,5 +5,5 @@
 * use.gemspec
 * examples/example_use.rb
 * lib/use.rb
-* test/tc_use.rb
-* test/test_data.rb
+* test/test_use.rb
+* test/sample_data.rb

data/Rakefile

@@ -1,24 +1,23 @@
-require 'rake'
-require 'rake/testtask'
-require 'rbconfig'
-include Config
-
-desc 'Install the use package (non-gem)'
-task :install do
-   sitelibdir = CONFIG["sitelibdir"]
-   file = "lib/use.rb"
-   FileUtils.cp(file, sitelibdir, :verbose => true)
-end
-
-task :install_gem do
-   ruby 'use.gemspec'
-   file = Dir["*.gem"].first
-   sh "gem install #{file}"
-end
-
-Rake::TestTask.new do |t|
-   t.libs << 'test'
-   t.verbose = true
-   t.warning = true
-   t.test_files = FileList['test/tc_use.rb']
-end
+require 'rake'
+require 'rake/testtask'
+require 'rbconfig'
+include Config
+
+desc 'Install the use package (non-gem)'
+task :install do
+   sitelibdir = CONFIG["sitelibdir"]
+   file = "lib/use.rb"
+   FileUtils.cp(file, sitelibdir, :verbose => true)
+end
+
+task :install_gem do
+   ruby 'use.gemspec'
+   file = Dir["*.gem"].first
+   sh "gem install #{file}"
+end
+
+Rake::TestTask.new do |t|
+   t.libs << 'test'
+   t.verbose = true
+   t.warning = true
+end

data/lib/use.rb

@@ -1,91 +1,159 @@
-class Class
-   USE_VERSION = '1.2.1'
-   def use(*args)
-      valid_keys = %w/include exclude alias/
-      excluded = []
-      included = []
-      aliased  = []
-
-      mod = args.shift.clone
-
-      # If no arguments follow the module name, treat it as a standard include
-      if args.empty?
-         included.concat(mod.instance_methods)
-      end
-
-      m = Module.new
-
-      args.each{ |arg|
-         if arg.kind_of?(Hash)
-            arg.each{ |key, val|
-               case key.to_s
-                  when "include"
-                     if val.respond_to?(:each)
-                        val.each{ |arg| included.push(arg.to_s) }
-                     else
-                        included.push(val.to_s)
-                     end
-                  when "exclude"
-                     if val.respond_to?(:each)
-                        val.each{ |arg| excluded.push(arg.to_s) }
-                     else
-                        excluded.push(val.to_s)
-                     end
-                  when "alias"
-                     aliased.push(val)
-                  else
-                     raise "invalid key '#{key}'"
-               end
-            }
-         else
-            included.push(arg.to_s)
-         end
-      }
-
-      unless included.empty? || excluded.empty?
-         err = "you cannot include and exclude in the same statement"
-         raise ArgumentError, err
-      end
-
-      imethods = mod.instance_methods
-
-      # Remove excluded methods
-      unless excluded.empty?
-         (imethods & excluded).each{ |meth|
-            mod.module_eval{ remove_method(meth) }
-         }
-      end
-
-      # Alias methods
-      aliased.each{ |pair|
-         pair.each{ |old, new|
-            included.push(old) # Aliased methods automatically included
-            mod.module_eval{
-               alias_method(new, old)
-               remove_method(old)
-            }
-         }
-      }
-
-      # Remove all methods not specifically included.  The rescue was needed
-      # for those cases where a module included another module.
-      unless included.empty?
-         (imethods - included).each{ |meth|
-            mod.module_eval{ undef_method(meth) rescue nil }
-         }
-      end
-
-      m.module_eval{ include mod }
-
-      # Raise a warning if methods are shadowed (in $VERBOSE mode)
-      if $VERBOSE
-         imethods = instance_methods(true)
-         m.instance_methods.each{ |meth|
-            next unless imethods.include?(meth)
-            warn "method '#{meth}' aliased, shadows old '#{meth}'"
-         }
-      end
-
-      include m
-   end
-end
+class Class
+   # The version of the 'use' library
+   USE_VERSION = '1.2.2'
+
+   # Allows you to include mixins in a fine grained manner. Instead of
+   # including all methods from a given module, you can can instead mixin
+   # only those methods you want through a combination of the :include,
+   # :exclude, and :alias options.
+   #
+   # Examples:
+   #
+   #  # Defines a 'bar' and 'baz' method
+   #  module Foo
+   #     def bar
+   #        "hello"
+   #     end
+   #     def baz
+   #       "world"
+   #     end
+   #  end
+   #
+   #  # Defines a 'bar', 'blah', and 'zap' methods
+   #  module Test
+   #     def bar
+   #        "goodbye"
+   #     end
+   #     def blah
+   #        "new york"
+   #     end
+   #     def zap
+   #        "zap"
+   #     end
+   #  end
+   #
+   #  # From the Foo module, only mixin the 'bar' method. From the Test
+   #  # module exclude the 'bar' and 'zap' methods.
+   #  class Zap
+   #     use Foo, :bar
+   #     use Test, :exclude => [:bar, :zap]
+   #  end
+   #
+   #  z = Zap.new
+   #
+   #  z.bar  # => "hello"
+   #  z.baz  # => NoMethodError - wasn't mixed in
+   #  z.zap  # => NoMethodError - wasn't mixed in
+   #  z.blah # =>"new york"
+   #   
+   #  # Alias a method on the fly
+   #  class MyKlass
+   #     use Foo :alias => {:bar, :test}
+   #  end
+   #   
+   #  m = MyKlass.new
+   #  m.test # => "hello"
+   #  m.bar  # => NoMethodError - was aliased to 'test'
+   #
+   #  If no options follow the module name this method is identical
+   #  to a standard include.
+   #
+   def use(*args)
+      valid_keys = %w/include exclude alias/
+      excluded = []
+      included = []
+      aliased  = []
+
+      mod = args.shift.clone
+
+      # If no arguments follow the module name, treat it as a standard include
+      if args.empty?
+         included.concat(mod.instance_methods)
+      end
+
+      m = Module.new
+
+      args.each{ |arg|
+         if arg.kind_of?(Hash)
+            arg.each{ |key, val|
+               case key.to_s
+                  when "include"
+                     if val.respond_to?(:each)
+                        val.each{ |arg| included.push(arg.to_s) }
+                     else
+                        included.push(val.to_s)
+                     end
+                  when "exclude"
+                     if val.respond_to?(:each)
+                        val.each{ |arg| excluded.push(arg.to_s) }
+                     else
+                        excluded.push(val.to_s)
+                     end
+                  when "alias"
+                     aliased.push(val)
+                  else
+                     raise "invalid key '#{key}'"
+               end
+            }
+         else
+            included.push(arg.to_s)
+         end
+      }
+
+      unless included.empty? || excluded.empty?
+         err = "you cannot include and exclude in the same statement"
+         raise ArgumentError, err
+      end
+
+      imethods = mod.instance_methods
+
+      # Remove excluded methods
+      unless excluded.empty?
+         (imethods & excluded).each{ |meth|
+            mod.module_eval{ remove_method(meth) }
+         }
+      end
+
+      # Alias methods
+      aliased.each{ |pair|
+         pair.each{ |old, new|
+            included.push(old) # Aliased methods automatically included
+            mod.module_eval{
+               alias_method(new, old)
+               remove_method(old)
+            }
+         }
+      }
+
+      # Remove all methods not specifically included.  The rescue was needed
+      # for those cases where a module included another module. Also, don't
+      # remove methods from classes that already exist unless specifically
+      # included.
+      unless included.empty?
+         (imethods - included).each{ |meth|
+            if superclass.instance_methods.include?(meth)
+               if included.include?(meth)
+                  mod.module_eval{ undef_method(meth) rescue nil }
+               else
+                  mod.module_eval{ remove_method(meth) rescue nil }
+               end
+            else
+               mod.module_eval{ undef_method(meth) rescue nil }
+            end
+         }
+      end
+
+      m.module_eval{ include mod }
+
+      # Raise a warning if methods are shadowed (in $VERBOSE mode)
+      if $VERBOSE
+         imethods = instance_methods(true)
+         m.instance_methods.each{ |meth|
+            next unless imethods.include?(meth)
+            warn "method '#{meth}' aliased, shadows old '#{meth}'"
+         }
+      end
+
+      include m
+   end
+end

data/test/{test_data.rb → sample_data.rb}

@@ -1,64 +1,64 @@
-##################################################
-# test_data.rb
-#
-# Test modules and classes for the 'use' package.
-##################################################
-module ModA
-   def meth_a
-      "ModA#meth_a"
-   end
-
-   def meth_b
-      "ModA#meth_b"
-   end
-
-   def meth_c
-      "ModA#meth_c"
-   end
-end
-
-module ModB
-   include ModA
-   def meth_a
-      "ModB#meth_a"
-   end
-
-   def meth_b
-      "ModB#meth_b"
-   end
-end
-
-module ModC
-   def meth_x
-      "ModC#meth_x"
-   end
-
-   def meth_y
-      "ModC#meth_y"
-   end
-
-   def meth_z
-      "ModC#meth_z"
-   end
-end
-
-class ClassA
-   use ModA, :meth_a
-end
-
-class ClassB
-   use ModB, :include => :meth_c, :alias => {:meth_b, :meth_z}
-end
-
-class ClassC
-   use ModA, :exclude => [:meth_b, :meth_c]
-   use ModC
-
-   def meth_c
-      "ClassC#meth_c"
-   end
-end
-
-class ClassD
-   use ModA, :alias => {:meth_a, :meth_x, :meth_c, :meth_z}, :exclude => :meth_b
-end
+##################################################
+# test_data.rb
+#
+# Test modules and classes for the 'use' package.
+##################################################
+module ModA
+   def meth_a
+      "ModA#meth_a"
+   end
+
+   def meth_b
+      "ModA#meth_b"
+   end
+
+   def meth_c
+      "ModA#meth_c"
+   end
+end
+
+module ModB
+   include ModA
+   def meth_a
+      "ModB#meth_a"
+   end
+
+   def meth_b
+      "ModB#meth_b"
+   end
+end
+
+module ModC
+   def meth_x
+      "ModC#meth_x"
+   end
+
+   def meth_y
+      "ModC#meth_y"
+   end
+
+   def meth_z
+      "ModC#meth_z"
+   end
+end
+
+class ClassA
+   use ModA, :meth_a
+end
+
+class ClassB
+   use ModB, :include => :meth_c, :alias => {:meth_b, :meth_z}
+end
+
+class ClassC
+   use ModA, :exclude => [:meth_b, :meth_c]
+   use ModC
+
+   def meth_c
+      "ClassC#meth_c"
+   end
+end
+
+class ClassD
+   use ModA, :alias => {:meth_a, :meth_x, :meth_c, :meth_z}, :exclude => :meth_b
+end

data/test/{tc_use.rb → test_use.rb}

@@ -1,96 +1,96 @@
-#######################################################################
-# tc_use.rb
-#
-# Test cases for the 'use' package.  The relevant modules and classes
-# are stored in the 'test_data.rb' file. This test should be run via
-# the 'rake test' task.
-#######################################################################
-require 'use'
-require 'test_data'
-require 'test/unit'
-
-class TC_Use < Test::Unit::TestCase
-   def setup
-      @a = ClassA.new
-      @b = ClassB.new
-      @c = ClassC.new
-      @d = ClassD.new
-   end
-
-   def test_version
-      assert_equal('1.2.1', Class::USE_VERSION)
-   end
-
-   def test_mod_a_methods
-      assert_equal(['meth_a', 'meth_b', 'meth_c'], ModA.instance_methods.sort)
-   end
-
-   def test_mod_b_methods
-      assert_equal(['meth_a', 'meth_b', 'meth_c'], ModB.instance_methods.sort)
-   end
-
-   def test_mod_c_methods
-      assert_equal(['meth_x', 'meth_y', 'meth_z'], ModC.instance_methods.sort)
-   end
-
-   def test_class_a_methods
-      assert_respond_to(@a, :meth_a)
-      assert_equal('ModA#meth_a', @a.meth_a)
-   end
-
-   def test_class_a_expected_errors
-      assert_raises(NoMethodError){ @a.meth_b }
-      assert_raises(NoMethodError){ @a.meth_c }
-   end
-
-   def test_class_b_methods
-      assert_respond_to(@b, :meth_c)
-      assert_respond_to(@b, :meth_z)
-      assert_equal('ModA#meth_c', @b.meth_c)
-      assert_equal('ModB#meth_b', @b.meth_z)
-   end
-
-   def test_class_b_expected_errors
-      assert_raises(NoMethodError){ @b.meth_a }
-      assert_raises(NoMethodError){ @b.meth_b }
-   end
-
-   def test_class_c_methods
-      assert_respond_to(@c, :meth_a)
-      assert_respond_to(@c, :meth_c)
-      assert_respond_to(@c, :meth_x)
-      assert_respond_to(@c, :meth_y)
-      assert_respond_to(@c, :meth_z)
-
-      assert_equal('ModA#meth_a', @c.meth_a)
-      assert_equal('ClassC#meth_c', @c.meth_c)
-      assert_equal('ModC#meth_x', @c.meth_x)
-      assert_equal('ModC#meth_y', @c.meth_y)
-      assert_equal('ModC#meth_z', @c.meth_z)
-   end
-
-   def test_class_c_expected_errors
-      assert_raises(NoMethodError){ @c.meth_b }
-   end
-
-   def test_class_d_methods
-      assert_respond_to(@d, :meth_x)
-      assert_respond_to(@d, :meth_z)
-
-      assert_equal('ModA#meth_a', @d.meth_x)
-      assert_equal('ModA#meth_c', @d.meth_z)
-   end
-
-   def test_class_d_expected_errors
-      assert_raises(NoMethodError){ @d.meth_a }
-      assert_raises(NoMethodError){ @d.meth_b }
-      assert_raises(NoMethodError){ @d.meth_c }
-   end
-
-   def teardown
-      @a = nil
-      @b = nil
-      @c = nil
-      @d = nil
-   end
-end
+#######################################################################
+# test_use.rb
+#
+# Test cases for the 'use' package.  The relevant modules and classes
+# are stored in the 'test_data.rb' file. This test should be run via
+# the 'rake test' task.
+#######################################################################
+require 'use'
+require 'sample_data'
+require 'test/unit'
+
+class TC_Use < Test::Unit::TestCase
+   def setup
+      @a = ClassA.new
+      @b = ClassB.new
+      @c = ClassC.new
+      @d = ClassD.new
+   end
+
+   def test_version
+      assert_equal('1.2.2', Class::USE_VERSION)
+   end
+
+   def test_mod_a_methods
+      assert_equal(['meth_a', 'meth_b', 'meth_c'], ModA.instance_methods.sort)
+   end
+
+   def test_mod_b_methods
+      assert_equal(['meth_a', 'meth_b', 'meth_c'], ModB.instance_methods.sort)
+   end
+
+   def test_mod_c_methods
+      assert_equal(['meth_x', 'meth_y', 'meth_z'], ModC.instance_methods.sort)
+   end
+
+   def test_class_a_methods
+      assert_respond_to(@a, :meth_a)
+      assert_equal('ModA#meth_a', @a.meth_a)
+   end
+
+   def test_class_a_expected_errors
+      assert_raises(NoMethodError){ @a.meth_b }
+      assert_raises(NoMethodError){ @a.meth_c }
+   end
+
+   def test_class_b_methods
+      assert_respond_to(@b, :meth_c)
+      assert_respond_to(@b, :meth_z)
+      assert_equal('ModA#meth_c', @b.meth_c)
+      assert_equal('ModB#meth_b', @b.meth_z)
+   end
+
+   def test_class_b_expected_errors
+      assert_raises(NoMethodError){ @b.meth_a }
+      assert_raises(NoMethodError){ @b.meth_b }
+   end
+
+   def test_class_c_methods
+      assert_respond_to(@c, :meth_a)
+      assert_respond_to(@c, :meth_c)
+      assert_respond_to(@c, :meth_x)
+      assert_respond_to(@c, :meth_y)
+      assert_respond_to(@c, :meth_z)
+
+      assert_equal('ModA#meth_a', @c.meth_a)
+      assert_equal('ClassC#meth_c', @c.meth_c)
+      assert_equal('ModC#meth_x', @c.meth_x)
+      assert_equal('ModC#meth_y', @c.meth_y)
+      assert_equal('ModC#meth_z', @c.meth_z)
+   end
+
+   def test_class_c_expected_errors
+      assert_raises(NoMethodError){ @c.meth_b }
+   end
+
+   def test_class_d_methods
+      assert_respond_to(@d, :meth_x)
+      assert_respond_to(@d, :meth_z)
+
+      assert_equal('ModA#meth_a', @d.meth_x)
+      assert_equal('ModA#meth_c', @d.meth_z)
+   end
+
+   def test_class_d_expected_errors
+      assert_raises(NoMethodError){ @d.meth_a }
+      assert_raises(NoMethodError){ @d.meth_b }
+      assert_raises(NoMethodError){ @d.meth_c }
+   end
+
+   def teardown
+      @a = nil
+      @b = nil
+      @c = nil
+      @d = nil
+   end
+end

data/use.gemspec

@@ -0,0 +1,24 @@
+require "rubygems"
+
+spec = Gem::Specification.new do |gem|
+   gem.name        = "use"
+   gem.version     = "1.2.2"
+   gem.author      = "Daniel J. Berger"
+   gem.email       = "djberg96@gmail.com"
+   gem.homepage    = "http://www.rubyforge.org/projects/shards"
+   gem.platform    = Gem::Platform::RUBY
+   gem.summary     = "Selectively mixin methods from a given module"
+   gem.description = "Selectively mixin methods from a given module"
+   gem.rubyforge_project = "shards"
+   gem.test_file   = "test/test_use.rb"
+   gem.has_rdoc    = true
+   gem.files = Dir['lib/*.rb'] + Dir['[A-Z]*']  + Dir['test/*']
+   gem.files.reject! { |fn| fn.include? "CVS" }
+   gem.require_path = "lib"
+   gem.extra_rdoc_files = ["MANIFEST", "README", "CHANGES"]
+end
+
+if $0 == __FILE__
+   Gem.manage_gems
+   Gem::Builder.new(spec).build
+end

metadata

@@ -1,54 +1,65 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
 name: use
 version: !ruby/object:Gem::Version 
-  version: 1.2.1
-date: 2007-05-22 00:00:00 -06:00
-summary: Selectively mixin methods from a given module
-require_paths: 
-- lib
-email: djberg96@gmail.com
-homepage: http://www.rubyforge.org/projects/shards
-rubyforge_project: 
-description: Selectively mixin methods from a given module
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.2.2
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Daniel J. Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-16 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: Selectively mixin methods from a given module
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MANIFEST
+- README
+- CHANGES
 files: 
 - lib/use.rb
 - CHANGES
+- examples
+- lib
 - MANIFEST
-- README
 - Rakefile
-- test/tc_use.rb
-- test/test_data.rb
-test_files: 
-- test/tc_use.rb
-rdoc_options: []
-
-extra_rdoc_files: 
-- MANIFEST
 - README
-- CHANGES
-executables: []
-
-extensions: []
+- test
+- use.gemspec
+- test/sample_data.rb
+- test/test_use.rb
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/shards
+post_install_message: 
+rdoc_options: []
 
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: shards
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Selectively mixin methods from a given module
+test_files: 
+- test/test_use.rb