use 1.3.1 → 1.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5cc4ebf5e672d9172d6f5d8186cc103db14df3b8
+  data.tar.gz: 56617771d511b621577cbf9636a80c39356c79ee
+SHA512:
+  metadata.gz: 90fae6e4aa251b1df17116f960c9f69bbc6d89bcd7882ed3e9c04ed258a3cc87072c7b659038defc9527ec3832742cf1f30377b0dbdfc504195f258c969f28b4
+  data.tar.gz: 57595675316a3979ad8e8940dc9404061250e433f89f732cc03abbb59991f4d964927715871620dbf3cc80a57c38a3dc8f3ea1e33a87f773b149f478982ed49a

data/CHANGES

@@ -1,3 +1,11 @@
+== 1.3.3 - 12-Oct-2014
+* Rakefile, gemspec and README updates.
+* Fixed an unused variable warning.
+
+== 1.3.2 - 8-Oct-2009
+* Updated and fixed gemspec.
+* Added the :gem rake task.
+
 == 1.3.1 - 31-Jul-2009
 * Fixed a bug where identical methods from different modules were being
   inadvertently undefined.

data/README

@@ -91,4 +91,3 @@ USE_VERSION
 
 == Author
    Daniel J. Berger
-   djberg96 at nospam at gmail dot com

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+
+CLEAN.include("**/*.gem", "**/*.rbc", "**/*.rbx")
+
+namespace :gem do
+  desc "Create the use gem"
+  task :create => [:clean] do
+    spec = eval(IO.read('use.gemspec'))
+    if Gem::VERSION < "2.0"
+      Gem::Builder.new(spec).build
+    else
+      require 'rubygems/package'
+      Gem::Package.build(spec)
+    end
+  end
+
+  desc "Install the use gem"
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install -l #{file}"
+  end
+end
+
+Rake::TestTask.new do |t|
+  task :test => :clean
+  t.libs << 'test'
+  t.verbose = true
+  t.warning = true
+end
+
+task :default => :test

data/lib/use.rb

@@ -1,178 +1,177 @@
 require 'structured_warnings'
 
 unless defined? MethodRedefinedWarning
-   # Warning raised in $VERBOSE mode if a method is shadowed.
-   class MethodRedefinedWarning < Warning
-   end
+  # 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.1'
-
-   # 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 Alpha
-   #     def bar
-   #        puts 'hello'
-   #     end
-   #     def baz
-   #       puts 'world'
-   #     end
-   #  end
-   #
-   #  # Defines a 'bar', 'blah', and 'zap' methods
-   #  module Beta
-   #     def bar
-   #        puts 'goodbye'
-   #     end
-   #     def blah
-   #        puts 'new york'
-   #     end
-   #     def zap
-   #        puts 'zap'
-   #     end
-   #  end
-   #
-   #  # From the Alpha module, only mixin the 'bar' method. From the Beta
-   #  # module exclude the 'bar' and 'zap' methods.
-   #  class Zap
-   #     use Alpha, :bar
-   #     use Beta, :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 Alpha, :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
+  # The version of the 'use' library
+  USE_VERSION = '1.3.3'
+
+  # 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 Alpha
+  #     def bar
+  #        puts 'hello'
+  #     end
+  #     def baz
+  #       puts 'world'
+  #     end
+  #  end
+  #
+  #  # Defines a 'bar', 'blah', and 'zap' methods
+  #  module Beta
+  #     def bar
+  #        puts 'goodbye'
+  #     end
+  #     def blah
+  #        puts 'new york'
+  #     end
+  #     def zap
+  #        puts 'zap'
+  #     end
+  #  end
+  #
+  #  # From the Alpha module, only mixin the 'bar' method. From the Beta
+  #  # module exclude the 'bar' and 'zap' methods.
+  #  class Zap
+  #     use Alpha, :bar
+  #     use Beta, :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 Alpha, :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)
+    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
+    }
 
-      local_instance_methods = mod.instance_methods.map{ |e| e.to_s }
+    unless included_methods.empty? || excluded_methods.empty?
+      err = 'you cannot include and exclude in the same statement'
+      raise ArgumentError, err
+    end
 
-      excluded_methods.map!{ |e| e.to_s }
+    local_instance_methods = mod.instance_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
+    excluded_methods.map!{ |e| e.to_s }
 
-      # 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
-            }
-         }
+    # 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?
+      self_instance_methods = self.instance_methods.map{ |e| e.to_s }
+      (local_instance_methods - included_methods).each{ |meth|
+        if self_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
 
-      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?
-         self_instance_methods = self.instance_methods.map{ |e| e.to_s }
-         (local_instance_methods - included_methods).each{ |meth|
-            if self_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 }
+    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
+    # 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
+    include m
+  end
 end

data/test/test_use.rb

@@ -25,7 +25,7 @@ class TC_Use < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal('1.3.1', Class::USE_VERSION)
+      assert_equal('1.3.3', Class::USE_VERSION)
    end
 
    def test_mod_a_methods

data/use.gemspec

@@ -0,0 +1,26 @@
+require 'rubygems'
+
+Gem::Specification.new do |gem|
+  gem.name      = 'use'
+  gem.version   = '1.3.3'
+  gem.author    = 'Daniel J. Berger'
+  gem.license   = 'Artistic 2.0'
+  gem.email     = 'djberg96@gmail.com'
+  gem.homepage  = 'https://github.com/djberg96/use'
+  gem.summary   = 'Selectively mixin methods from a given module'
+  gem.test_file = 'test/test_use.rb'
+  gem.files     = Dir['**/*'].reject{ |f| f.include?('git') }
+
+  gem.extra_rdoc_files  = ['MANIFEST', 'README', 'CHANGES']
+
+  gem.add_dependency('structured_warnings', '>= 0.1.1')
+  gem.add_development_dependency('rake')
+
+  gem.description = <<-EOF
+    The use library solves the multi-mixin problem by allowing you to
+    selectively mixin specific methods from a module rather than mixing
+    in all of them. In addition, you can alias methods on the fly as they
+    are mixed in, effectively allowing you to change the name of the mixin
+    method.
+  EOF
+end

metadata

@@ -1,72 +1,89 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: use
-version: !ruby/object:Gem::Version 
-  version: 1.3.1
+version: !ruby/object:Gem::Version
+  version: 1.3.3
 platform: ruby
-authors: 
+authors:
 - Daniel J. Berger
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-07-31 00:00:00 -06:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: structured_warnings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
+      - !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"
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      The use library solves the multi-mixin problem by allowing you to
+      selectively mixin specific methods from a module rather than mixing
+      in all of them. In addition, you can alias methods on the fly as they
+      are mixed in, effectively allowing you to change the name of the mixin
+      method.
 email: djberg96@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - MANIFEST
 - README
 - CHANGES
-files: 
+files:
+- CHANGES
+- MANIFEST
+- README
+- Rakefile
 - examples/example_use.rb
 - lib/use.rb
 - test/sample_data.rb
 - test/test_use.rb
-- MANIFEST
-- README
-- CHANGES
-has_rdoc: true
-homepage: http://www.rubyforge.org/projects/shards
-licenses: 
+- use.gemspec
+homepage: https://github.com/djberg96/use
+licenses:
 - Artistic 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: shards
-rubygems_version: 1.3.5
+rubyforge_project: 
+rubygems_version: 2.4.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Selectively mixin methods from a given module
-test_files: 
+test_files:
 - test/test_use.rb