use 1.1.0 → 1.2.0

data/CHANGES

@@ -1,3 +1,9 @@
+== 1.2.0 - 24-Feb-2006
+* Method is now redefined within Class instead of Module in order to make
+  the ability to use 'include' and 'alias' more flexible and work more nicely
+  together.
+* Updated the test suite.
+
 == 1.1.0 - 20-Jan-2006
 * Using 'use' with no arguments is now the same as if you used 'include',
   i.e. all methods are mixed in.  Previously, this would not mixin any methods.

data/MANIFEST

@@ -8,4 +8,5 @@ examples/example_use.rb
 
 lib/use.rb
 
-test/tc_use.rb
+test/tc_use.rb
+test/test_data.rb

data/README

@@ -53,6 +53,10 @@
    m = MyKlass.new
    m.test # "hello"
    m.bar  # NoMethodError
+   
+== Constants
+USE_VERSION
+	The version of this package, returned as a String.
 
 == Acknowledgements
    Thanks go to Ara Howard for providing the original solution and to
@@ -62,6 +66,11 @@
 == Known Bugs
    None that I'm aware of.  If you find any, please log them on the project
    page at http://www.rubyforge.org/projects/shards.
+   
+== Questions?
+   Please post your comment or question on one of the forums on the project
+   page at http://www.rubyforge.org/projects/shards.  Just click the 'Forums'
+   link.
 
 == License
    Ruby's

data/lib/use.rb

@@ -1,122 +1,91 @@
-class Module
-   # VERSION = "1.1.0"
-
-   # :call-seq:
-   # use module, methods
-   # # or
-   # use module, option => value, ...
-   #
-   # The 'use' directive allows you to selectively mixin +methods+ from the
-   # given +module+.  The +methods+ may be either strings or symbols.  If
-   # no methods are provided then 'use' is effectively the same thing as
-   # 'include', i.e. all methods are mixed in.
-   #
-   # If a Hash is provided, there are three keywords available to you:
-   #
-   # * 'include'
-   #   This option lets you specify one or more methods to explicitly include.
-   #   If you wish to include more than one method, use an array as the value.
-   #
-   # * 'exclude'
-   #   This option lets you specify one or more methods to explicitly exclude.
-   #   If you wish to exclude more than one method, use an array as the value.
-   #
-   # * 'alias'
-   #   This option lets you include a method, but as a different method name.
-   #   Use a hash as the value to +alias+, e.g. :alias => {:old, :new, ... }.
-   #   Using this option doubles as an explicit include, so you do not need
-   #   to both include and alias in the same statement.
-   #
-   #   Note that the original method name is NOT included if aliased this way.
-   #
-   #   Also note that you cannot include and exclude in the same statement,
-   #   or an ArgumentError is raised.  You can, however, exclude and alias.
-   #
-   def use(mod, *methods)
-      valid    = %w/include exclude alias/
-      included = []
+class Class
+   USE_VERSION = '1.2.0'
+   def use(*args)
+      valid_keys = %w/include exclude alias/
       excluded = []
+      included = []
       aliased  = []
 
-      m = Module.new
+      mod = args.shift.clone
 
-      # If the first argument is a Hash, verify the keywords and push values
-      # onto the appropriate array for later processing.
-      #
-      if methods.first.kind_of?(Hash)
-         methods = methods.first
-         methods.each{ |key, val|
-            unless valid.include?(key.to_s.downcase)
-               raise ArgumentError, "invalid key: #{key}"
-            end
+      # If no arguments follow the module name, treat it as a standard include
+      if args.empty?
+         included.concat(mod.instance_methods)
+      end
 
-            if key.to_s == "include"
-               if val.respond_to?(:each)
-                  val.each{ |arg| included.push(arg.to_sym) } 
-               else
-                  included.push(val.to_sym)
-               end
-            end
+      m = Module.new
 
-            if key.to_s == "exclude"
-               if val.respond_to?(:each)
-                  val.each{ |arg| excluded.push(arg.to_sym) } 
-               else
-                  excluded.push(val.to_sym)
+      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
-            end
-
-            if key.to_s == "alias"
-               aliased.push(val)
-            end
-         }          
-      else
-         if methods.empty?
-            module_eval{ include mod } # Mixin all methods if no arguments
+            }
          else
-            m.module_eval do
-               include mod
-               all_methods = mod.instance_methods
-               unn_methods = all_methods - methods.map{ |method| method.to_s }
-               undef_method(*unn_methods)
-            end
-            module_eval{ include m }
+            included.push(arg.to_s)
          end
-         return
-      end
+      }
 
       unless included.empty? || excluded.empty?
          err = "you cannot include and exclude in the same statement"
          raise ArgumentError, err
       end
 
-      m.module_eval{
-         include mod
+      imethods = mod.instance_methods
 
-         aliased.each{ |pair|
-            pair.each{ |old, new|
-               included.push(old)      # Aliased methods automatically included
-               alias_method(new, old)  # Alias the old method
-               undef_method(old)       # Then remove the old method
-            }
+      # Remove excluded methods
+      unless excluded.empty?
+         (imethods & excluded).each{ |meth|
+            mod.module_eval{ remove_method(meth) }
          }
+      end
 
-         # Undef all methods not in the 'included' array
-         unless included.empty?
-            mod.instance_methods.each{ |method|
-               method = method.to_sym
-               unless included.include?(method)
-                  undef_method(method) if method_defined?(method)
-              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)
             }
-         end
-
-         # Undef all methods in the 'excluded' array
-         excluded.each{ |method|
-            undef_method(method) if method_defined?(method)
          }
       }
 
-      module_eval{ include m }
+      # 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

data/test/tc_use.rb

@@ -1,115 +1,103 @@
-###############################################
+#######################################################################
 # tc_use.rb
 #
-# Test suite for the "use" package.
-###############################################
+# Test cases for the 'use' package.  The relevant modules and classes
+# are stored in the 'test_data.rb' file.
+#######################################################################
 base = File.basename(Dir.pwd)
-
-if base == "test" || base =~ /use/
-   Dir.chdir("..") if base == "test"
-   $LOAD_PATH.unshift(Dir.pwd)
-   $LOAD_PATH.unshift(Dir.pwd + "/lib")
-   Dir.chdir("test") rescue nil
-end
-
-require "use"
-require "test/unit"
-
-module Foo
-   def bar; self; end
-   def baz; "hello"; end
-   def zap; "world"; end
+if base == 'test' || base =~ /use/i
+   Dir.chdir '..' if base == 'test'
+   $LOAD_PATH.unshift Dir.pwd + '/lib'
+   Dir.chdir 'test' rescue nil
+   $LOAD_PATH.unshift Dir.pwd
 end
 
-module Bar
-   def bar; "bar!"; end
-   def baz; "baz!"; end
-end
+require 'use'
+require 'test_data'
+require 'test/unit'
 
-class User
-   use Foo, :bar
-end
+class TC_Use < Test::Unit::TestCase
+   def setup
+      @a = ClassA.new
+      @b = ClassB.new
+      @c = ClassC.new
+      @d = ClassD.new
+   end
 
-class Temp
-   use Foo,
-      :include => :zap,
-      :alias => {:baz, :test}
-end
+   def test_version
+      assert_equal('1.2.0', Class::USE_VERSION)
+   end
 
-class Zapr
-   use Foo, :exclude => [:bar, :baz]
-   use Bar
+   def test_mod_a_methods
+      assert_equal(['meth_a', 'meth_b', 'meth_c'], ModA.instance_methods.sort)
+   end
 
-   def zap
-      "zap"
+   def test_mod_b_methods
+      assert_equal(['meth_a', 'meth_b', 'meth_c'], ModB.instance_methods.sort)
    end
-end
 
-class Bogus
-   use Foo,
-      :alias   => {"zap", :test1, :baz, :test2},
-      :exclude => :bar
-end
+   def test_mod_c_methods
+      assert_equal(['meth_x', 'meth_y', 'meth_z'], ModC.instance_methods.sort)
+   end
 
-class TC_Use < Test::Unit::TestCase
-   def setup
-      @user = User.new
-      @temp = Temp.new
-      @zapr = Zapr.new
+   def test_class_a_methods
+      assert_respond_to(@a, :meth_a)
+      assert_equal('ModA#meth_a', @a.meth_a)
    end
 
-   def test_user_mod_methods
-      assert_equal(["bar","baz","zap"], Foo.instance_methods.sort)
+   def test_class_a_expected_errors
+      assert_raises(NoMethodError){ @a.meth_b }
+      assert_raises(NoMethodError){ @a.meth_c }
    end
 
-   def test_zapr_legal_methods
-      assert_respond_to(@zapr, :zap)
-      assert_respond_to(@zapr, :bar)
-      assert_equal("zap", @zapr.zap) # Existing method not overridden
+   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_temp_legal_methods
-      assert_respond_to(@temp, :zap)
-      assert_respond_to(@temp, :test)
-      assert_equal("world", @temp.zap)
-      assert_equal("hello", @temp.test)
+   def test_class_b_expected_errors
+      assert_raises(NoMethodError){ @b.meth_a }
+      assert_raises(NoMethodError){ @b.meth_b }
    end
 
-   def test_temp_expected_errors
-      assert_raises(NoMethodError){ @temp.bar }
-      assert_raises(NoMethodError){ @temp.baz } # Aliased
+   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_user_legal_methods
-      assert_respond_to(@user, :bar)
-      assert_nothing_raised{ @user.bar }
-      assert_kind_of(User, @user.bar)
+
+   def test_class_c_expected_errors
+      assert_raises(NoMethodError){ @c.meth_b }
    end
-   
-   def test_user_expected_errors
-      assert_raises(NoMethodError){ @user.baz }
-      assert_raises(NoMethodError){ @user.zap }
+
+   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
 
-   # Don't allow exclude and include
-   def test_mutual_exclusion
-      assert_raises(ArgumentError){
-         eval{
-            "class Bogus
-               use Foo, :include => :bar, :exclude => :zap
-            end"
-         }
-      }
-      assert_raises(ArgumentError){
-         eval{
-            "class Bogus
-               use Foo, :alias => {:bar,:blah}, :exclude => :zap
-            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
-      @user = nil
+      @a = nil
+      @b = nil
+      @c = nil
+      @d = nil
    end
 end

data/test/test_data.rb

@@ -0,0 +1,72 @@
+##################################################
+# test_data.rb
+#
+# Test modules and classes for the 'use' package.
+##################################################
+#if File.basename(Dir.pwd) == "test"
+#   Dir.chdir(".."){
+#      $LOAD_PATH.unshift(Dir.pwd)
+#      $LOAD_PATH.unshift(Dir.pwd + "/lib")
+#   }
+#end
+#$LOAD_PATH.unshift(Dir.pwd + "/lib")
+
+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

metadata

@@ -3,11 +3,11 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: use
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
-date: 2006-01-20 00:00:00 -07:00
+  version: 1.2.0
+date: 2006-02-24 00:00:00 -07:00
 summary: Selectively mixin methods from a given module
 require_paths: 
-  - lib
+- lib
 email: djberg96@gmail.com
 homepage: http://www.rubyforge.org/projects/shards
 rubyforge_project: 
@@ -18,29 +18,34 @@ bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
 authors: 
-  - Daniel J. Berger
+- Daniel J. Berger
 files: 
-  - lib/use.rb
-  - CHANGES
-  - MANIFEST
-  - README
-  - test/tc_use.rb
+- lib/use.rb
+- CHANGES
+- MANIFEST
+- README
+- test/tc_use.rb
+- test/test_data.rb
 test_files: 
-  - test/tc_use.rb
+- test/tc_use.rb
 rdoc_options: []
+
 extra_rdoc_files: 
-  - README
-  - CHANGES
+- README
+- CHANGES
 executables: []
+
 extensions: []
+
 requirements: []
-dependencies: []
+
+dependencies: []
+