use 1.2.2 → 1.3.0

data/CHANGES

@@ -1,3 +1,11 @@
+== 1.3.0 - 30-Jul-2009
+* Compatibility fixes for Ruby 1.9.x
+* Added structured_warnings as a dependency, and now emits a
+  MethodRedefinedWarning in $VERBOSE mode if a method is redefined.
+* Changed license to Artistic 2.0.
+* Fixed a bug with regards to aliased methods (which you probably
+  never noticed).
+
 == 1.2.2 - 16-Sep-2008
 * Fixed a bug where methods already defined prior to the inclusion
   of a module could be accidentally undefined.

data/README

@@ -1,15 +1,16 @@
 == Description
-   The 'use' package allows you to selectively mix in methods from a given
-   module.
+   The 'use' library allows you to selectively mixin methods from a given
+   module and alias them on the fly if desired.
 
 == Prerequisites
    Ruby 1.8.0 or later
-	
+   structured_warnings 0.1.1 or later
+   
 == Installation
 === Standard
    rake test (optional)
    rake install
-	
+   
 === Gem install
    rake test (optional)
    rake install_gem
@@ -46,7 +47,7 @@
    
    # Using the new keywords
    class MyKlass
-      use Foo :alias => {:bar, :test}
+      use Foo :alias => {:bar => :test}
    end
    
    m = MyKlass.new
@@ -55,7 +56,12 @@
    
 == Constants
 USE_VERSION
-	The version of this package, returned as a String.
+   The version of this library. This is a string.
+   
+== Notes
+   In $VERBOSE mode this library will issue a MethodRedefinedWarning if you
+   shadow an existing method. See the documentation for structured_warnings
+   for more details.
 
 == Acknowledgements
    Thanks go to Ara Howard for providing the original solution and to
@@ -63,8 +69,11 @@ USE_VERSION
    in order to implement fine-grained mixins.
 
 == 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.
+   Some versions of Ruby 1.9.x may emit a warning in verbose mode. This is a
+   bug in Ruby 1.9.x and can be ignored.
+   
+   If you find any bugs 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
@@ -72,13 +81,12 @@ USE_VERSION
    link.
 
 == License
-   Ruby's
+   Artistic 2.0
 
 == Copyright
-   (C) 2005-2007, Daniel J. Berger
+   (C) 2005-2009, Daniel J. Berger
    All Rights Reserved
 
 == Author
    Daniel J. Berger
-   djberg96 at gmail dot com
-   IRC nickname: imperator/mok (freenode)
+   djberg96 at nospam at gmail dot com

data/examples/example_use.rb

@@ -0,0 +1,56 @@
+Dir.chdir("..") if File.basename(Dir.pwd) == "examples"
+$LOAD_PATH.unshift(Dir.pwd + "/lib")
+
+require "use"
+
+module Mod_A
+   def meth_a
+      "hello"
+   end
+   def meth_b
+      "world"
+   end
+end
+
+module Mod_B
+   def meth_a
+      "goodbye"
+   end
+   def meth_b
+      "new york"
+   end
+   def meth_c
+      "adios"
+   end
+end
+
+# Various ways to mixin methods using 'use'.  Note that I am intentionally
+# putting multiple 'use' statements within the classes for the sake of brevity
+# and demonstration.  In practice, you would not use more than one per module.
+#
+class Foo
+   use Mod_A                     # include all methods from Mod_A
+   use Mod_A, :meth_a            # or, include only meth_a from Mod_A
+   use Mod_A, include => :meth_a # same as above
+end
+
+class Bar
+   use Mod_B, :include => [:meth_b, :meth_c] # include only meth_a and meth_b
+   use Mod_B, :exclude => :meth_c            # same net result as above
+end
+
+class Baz
+   use Mod_A, :meth_a                        # mixin meth_a from Mod_A
+   use Mod_B, :alias => {:meth_a, :meth_z}   # mixin meth_a from Mod_B, but as meth_z
+end
+
+# Alias every method from Mod_B, as well as mixin Mod_A's meth_b.
+class Zap
+   use Mod_B, :alias => {
+      :meth_a => :meth_x,
+      :meth_b => :meth_y,
+      :meth_c => :meth_z
+   }
+
+   use Mod_A, :meth_b
+end

data/lib/use.rb

@@ -1,159 +1,177 @@
-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
+require 'structured_warnings'
+
+unless defined? MethodRedefinedWarning
+   # Warning raised in $VERBOSE mode if a method is shadowed.
+   class MethodRedefinedWarning < Warning
+   end
+end
+
+class Class
+   # The version of the 'use' library
+   USE_VERSION = '1.3.0'
+
+   # 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.
+   #--
+   #  Designer's note: Most of the explicit .to_s calls on method lists are
+   #  here to deal with the fact that Ruby 1.8 returns strings for method
+   #  lists while Ruby 1.9 returns symbols. To ensure compatibility, and
+   #  preserve my sanity, all method names are converted to strings.
+   #
+   def use(*args)
+      valid_keys = %w/include exclude alias/
+      excluded_methods = []
+      included_methods = []
+      aliased_methods  = []
+
+      mod = args.shift.clone
+
+      # If no arguments follow the module name, treat it as a standard include
+      if args.empty?
+         included_methods.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{ |element| included_methods << element.to_s }
+                     else
+                        included_methods << val.to_s
+                     end
+                  when 'exclude'
+                     if val.respond_to?(:each)
+                        val.each{ |element| excluded_methods << element.to_s }
+                     else
+                        excluded_methods << val.to_s
+                     end
+                  when 'alias'
+                     aliased_methods.push(val)
+                  else
+                     raise "invalid key '#{key}'"
+               end
+            }
+         else
+            included_methods.push(arg.to_s)
+         end
+      }
+
+      unless included_methods.empty? || excluded_methods.empty?
+         err = 'you cannot include and exclude in the same statement'
+         raise ArgumentError, err
+      end
+
+      local_instance_methods = mod.instance_methods.map{ |e| e.to_s }
+
+      excluded_methods.map!{ |e| e.to_s }
+
+      # Remove excluded_methods methods
+      unless excluded_methods.empty?
+         (local_instance_methods & excluded_methods).each{ |meth|
+            mod.module_eval{ remove_method(meth) }
+         }
+      end
+
+      # Alias methods. All aliased methods are automatically included.
+      aliased_methods.each{ |pair|
+         pair.each{ |old_method, new_method|
+            included_methods << new_method
+            mod.module_eval{
+               alias_method(new_method, old_method)
+               remove_method(old_method) rescue nil
+            }
+         }
+      }
+
+      included_methods.map!{ |e| e.to_s }
+
+      # 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_methods.empty?
+         (local_instance_methods - included_methods).each{ |meth|
+            if superclass.instance_methods.include?(meth)
+               if included_methods.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
+         local_instance_methods = instance_methods(true)
+         m.instance_methods.each{ |meth|
+            next unless local_instance_methods.include?(meth)
+            msg = "method '#{meth}' aliased, shadows old '#{meth}'"
+            warn MethodRedefinedWarning, msg
+         }
+      end
+
+      include m
+   end
+end

data/test/sample_data.rb

@@ -1,64 +1,66 @@
-##################################################
-# 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/test_use.rb

@@ -1,96 +1,102 @@
-#######################################################################
-# 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
+#######################################################################
+# 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
+
+   # Convert symbols to strings for 1.9.x
+   def assert_methods(array, methods)
+      methods = methods.map{ |m| m.to_s } 
+      assert_equal(array, methods)
+   end
+
+   def test_version
+      assert_equal('1.3.0', Class::USE_VERSION)
+   end
+
+   def test_mod_a_methods
+      assert_methods(['meth_a', 'meth_b', 'meth_c'], ModA.instance_methods.sort)
+   end
+
+   def test_mod_b_methods
+      assert_methods(['meth_a', 'meth_b', 'meth_c'], ModB.instance_methods.sort)
+   end
+
+   def test_mod_c_methods
+      assert_methods(['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_raise(NoMethodError){ @a.meth_b }
+      assert_raise(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_raise(NoMethodError){ @b.meth_a }
+      assert_raise(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_raise(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_raise(NoMethodError){ @d.meth_a }
+      assert_raise(NoMethodError){ @d.meth_b }
+      assert_raise(NoMethodError){ @d.meth_c }
+   end
+
+   def teardown
+      @a = nil
+      @b = nil
+      @c = nil
+      @d = nil
+   end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: use
 version: !ruby/object:Gem::Version 
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors: 
 - Daniel J. Berger
@@ -9,11 +9,20 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-16 00:00:00 -06:00
+date: 2009-07-30 00:00:00 -06:00
 default_executable: 
-dependencies: []
-
-description: Selectively mixin methods from a given module
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: structured_warnings
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.1
+    version: 
+description: "      The use library solves the multi-mixin problem by allowing you to\n      selectively mixin specific methods from a module rather than mixing\n      in all of them. In addition, you can alias methods on the fly as they\n      are mixed in, effectively allowing you to change the name of the mixin\n      method.\n"
 email: djberg96@gmail.com
 executables: []
 
@@ -24,19 +33,17 @@ extra_rdoc_files:
 - README
 - CHANGES
 files: 
+- examples/example_use.rb
 - lib/use.rb
-- CHANGES
-- examples
-- lib
-- MANIFEST
-- Rakefile
-- README
-- test
-- use.gemspec
 - test/sample_data.rb
 - test/test_use.rb
+- MANIFEST
+- README
+- CHANGES
 has_rdoc: true
 homepage: http://www.rubyforge.org/projects/shards
+licenses: 
+- Artistic 2.0
 post_install_message: 
 rdoc_options: []
 
@@ -57,9 +64,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: shards
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Selectively mixin methods from a given module
 test_files: 
 - test/test_use.rb

data/Rakefile

@@ -1,23 +0,0 @@
-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/use.gemspec

@@ -1,24 +0,0 @@
-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