monkey 0.0.0 → 0.6.0

data/README.rdoc

@@ -1,17 +1,63 @@
-= monkey
+= Monkey
 
-Description goes here.
+Monkey is a smart, scoped monkeypatching library. You can define monkeypatches
+via an intuitive DSL, and apply them only to scoped blocks, assured that your
+changes won't leak out to objects outside your scope.
 
-== Note on Patches/Pull Requests
+== Usage
+  
+=== Monkeypatching objects
+
+  # define the "metaclass" monkeypatch on Object
+  Monkey.see(Object) do
+    def metaclass
+      class << self; self; end
+    end
+  end
+  
+  # patch Object to include the "metaclass" monkeypatch for the duration of
+  # the block
+  Monkey.patch(Object, :metaclass) do
+    "foo".metaclass # => #<Class:#<String:0x1016d7570>>
+  end
+  
+  # the monkeypatch doesn't make it out of the scope
+  "foo".metaclass # => NoMethodError
+  
+  # patch Object to include the "metaclass" monkeypatch
+  Monkey.patch(Object, :metaclass)
+  
+  # the monkeypatch persists
+  "foo".metaclass # => #<Class:#<String:0x1016d7570>>  
+
+=== Monkeypatching classes
  
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+  # define the "foo" and "bar" monkeypatches on the class-level of Object
+  Monkey.see(Object.metaclass) do
+    def foo
+      Kernel.rand
+    end
+    
+    def bar
+      "hello!"
+    end
+  end
+  
+  Monkey.patch(Object.metaclass, :foo, :bar) do
+    Object.foo # => 0.571499912853919
+    Object.bar # => "hello!"
+  end
 
-== Copyright
+=== Monkeypatching instances
 
-Copyright (c) 2010 Stephen Touset. See LICENSE for details.
+  # define the "metaclass" monkeypatch on Object
+  Monkey.see(Object) do
+    def metaclass
+      class << self; self; end
+    end
+  end
+  
+  a = "foo"
+  
+  Monkey.patch(a, :metaclass) { a.metaclass }
+    

data/Rakefile

@@ -1,52 +1,46 @@
 require 'rubygems'
-require 'rake'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "monkey"
-    gem.summary = %Q{Scopeable monkeypatching support for Ruby}
-    gem.description = %Q{This is just a dummy package to reserve the name until the project is ready to be released}
-    gem.email = "stephen@touset.org"
-    gem.homepage = "http://github.com/stouset/monkey"
-    gem.authors = ["Stephen Touset"]
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/version_task'
+require 'spec/rake/spectask'
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
+spec = Gem::Specification.new do |s|
+  s.name    = 'monkey'
+  s.version = Version.current
+  s.summary = 'A smart, scoped monkeypatching library'
+  
+  s.author  = 'Stephen Touset'
+  s.email   = 'stephen@touset.org'
+  
+  s.files   = Dir['[A-Z]*', 'lib/**/*.rb', 'spec/**/*']
+  
+  s.extra_rdoc_files = Dir['*.rdoc']
+  s.rdoc_options     = %w{ --main README.rdoc }
+  
+  s.add_development_dependency 'version'
+  s.add_development_dependency 'rspec'
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
+Rake::GemPackageTask.new(spec) do |gem|
+  gem.need_tar = true
 end
 
-task :test => :check_dependencies
-
-task :default => :test
+Rake::RDocTask.new do |doc|
+  doc.title    = "monkey #{Version.current}"
+  doc.rdoc_dir = 'doc'
+  doc.main     = 'README.rdoc'
+  doc.rdoc_files.include('*.rdoc')
+  doc.rdoc_files.include('lib/**/*.rb')
+end
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+Spec::Rake::SpecTask.new(:spec) do |task|
+  task.spec_files = FileList['spec/**/*_spec.rb']
+end
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "monkey #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+Rake::VersionTask.new do |v|
+  v.with_git_tag = true
+  v.with_gemspec = spec
 end
+
+task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.6.0

data/lib/monkey/ext/modexcl/mrimodexcl.rb

@@ -0,0 +1,82 @@
+require 'rubygems'
+require 'inline'
+
+class Object
+  inline(:C) do |builder|
+    builder.prefix %{
+      static VALUE
+      rb_obj_dummy()
+      {
+        return Qnil;
+      }
+    }
+    builder.add_to_init %{
+      rb_define_private_method(rb_cModule, "unextended", rb_obj_dummy, 1);
+    }
+    builder.c %{
+      VALUE unextend(VALUE mod) 
+      {
+        VALUE p, prev;
+        Check_Type(mod, T_MODULE);
+        if (mod == rb_mKernel) 
+          rb_raise(rb_eArgError, "unextending Kernel is prohibited");
+
+
+          p = rb_singleton_class(self);
+
+          while (p) {
+            if (p == mod || RCLASS(p)->m_tbl == RCLASS(mod)->m_tbl) {
+              RCLASS(prev)->super = RCLASS(p)->super;
+              rb_clear_cache();
+              rb_funcall(mod, rb_intern("unextended"), 1, self);
+              return self;
+            }
+            prev = p;
+            p = RCLASS(p)->super;
+          }
+          return self;
+        }
+      }
+    end
+
+end
+
+class Class
+
+    inline(:C) do |builder|
+      builder.prefix %{
+        static VALUE
+        rb_obj_dummy()
+        {
+          return Qnil;
+        }
+      }
+      builder.add_to_init %{
+        rb_define_private_method(rb_cModule, "unincluded", rb_obj_dummy, 1);
+      }
+      builder.c %{  
+        VALUE uninclude(VALUE mod) 
+        {
+          VALUE p, prev;
+          Check_Type(mod, T_MODULE);
+          if (mod == rb_mKernel) 
+            rb_raise(rb_eArgError, "unincluding Kernel is prohibited");
+
+            p = self;
+
+            while (p) {
+              if (p == mod || RCLASS(p)->m_tbl == RCLASS(mod)->m_tbl) {
+                RCLASS(prev)->super = RCLASS(p)->super;
+                rb_clear_cache();
+                rb_funcall(mod, rb_intern("unincluded"), 1, self);
+                return self;
+              }
+              prev = p;
+              p = RCLASS(p)->super;
+            }
+            return self;
+          }
+        }
+      end
+
+end

data/lib/monkey/ext/modexcl/rbmodexcl.rb

@@ -0,0 +1,5 @@
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+  require File.join(File.dirname(__FILE__),'rbxmodexcl')
+else
+  require File.join(File.dirname(__FILE__),'mrimodexcl')
+end

data/lib/monkey/ext/modexcl/rbxmodexcl.rb

@@ -0,0 +1,48 @@
+
+class Object
+
+  def unextend(mod)
+    raise ArgumentError, "Module is expected" unless mod.is_a?(Module)
+    raise ArgumentError, "unextending Kernel is prohibited" if mod == Kernel
+    prev = p = metaclass
+    while p 
+      if (p == mod || (p.respond_to?(:module) && p.module == mod)) 
+        prev.set_superclass(p.direct_superclass)
+        # remove cache
+        self.methods.each do |name|
+          name = self.metaclass.send(:normalize_name,name)
+          Rubinius::VM.reset_method_cache(name)
+        end
+        #
+        mod.send(:unextended, self) if mod.respond_to?(:unextended)
+        return self
+      end
+      prev = p
+      p = p.direct_superclass
+    end
+
+  end
+
+  def uninclude(mod)
+    raise ArgumentError, "Module is expected" unless mod.is_a?(Module)
+    raise ArgumentError, "unincluding Kernel is prohibited" if mod == Kernel
+    prev = p = self
+    while p 
+      if (p == mod || (p.respond_to?(:module) && p.module == mod)) 
+        prev.superclass=(p.direct_superclass)
+        # remove cache
+        self.methods.each do |name|
+          name = self.metaclass.send(:normalize_name,name)
+          Rubinius::VM.reset_method_cache(name)
+        end
+        #
+        mod.send(:unincluded, self) if mod.respond_to?(:unincluded)
+        return self
+      end
+      prev = p
+      p = p.direct_superclass
+    end
+
+  end
+
+end

data/lib/monkey.rb

@@ -0,0 +1,135 @@
+require 'pathname'
+require 'monkey/ext/modexcl/rbmodexcl'
+
+module Monkey
+  class MonkeyError        < StandardError; end
+  class MethodPatchedError < MonkeyError;   end
+  class MethodMissingError < MonkeyError;   end
+  
+  #
+  # Allows you to specify a set of monkey patches that can be applied to a
+  # class or module. Pass a block to the method and define methods inside the
+  # block as normal, and the methods will be available only inside a
+  # Monkey#patch block.
+  #
+  # Raises a Monkey::MethodPatchedError if the +method+ already has a
+  # monkeypatch registered on +klass+.
+  #
+  #   Monkey.see(Object) do
+  #     def metaclass
+  #       (class << self; self; end)
+  #     end
+  #   end
+  #
+  def self.see(klass, &block)
+    mod     = Module.new(&block)
+    methods = mod.instance_methods(false)
+    
+    methods.each do |method|
+      register_patch(klass, method.to_sym, mod)
+    end
+  end
+  
+  #
+  # Patches +object+ to contain the monkeypatched +methods+. If a block is
+  # passed, the monkeypatches are only active for the duration of the block, 
+  # and the return value is the return value of the block.
+  #
+  # Raises a Monkey::MethodMissingError if a named monkeypatch is not defined.
+  #
+  #   Monkey.patch(Object, :metaclass) do
+  #     "foo".metaclass # => #<Class:#<String:0x10153caf8>>
+  #   end
+  #
+  #   "foo".metaclass # => NoMethodError
+  #
+  def self.patch(object, *methods, &scope)
+    # if the object is a class or metaclass, monkeypatch the class, otherwise
+    # monkeypatch the metaclass of the object
+    if object.kind_of?(Class)
+      _patch(object, object, *methods, &scope)
+    else
+      metaclass = (class << object; self; end)
+      klass     = object.class
+      
+      _patch(metaclass, klass, *methods, &scope)
+    end
+  end
+  
+  private
+  
+  #
+  # Actually applies monkeypatches to +object+. Looks up the +methods+ to be
+  # patched in the scope of of +klass+.
+  #
+  def self._patch(object, klass, *methods, &scope)
+    patches = methods.map do |method|
+      patch = klass.ancestors.map {|a| patch_for(a, method) }.compact.first
+      error_missing(klass, method) if patch.nil?
+      patch
+    end
+    
+    scope ? scope_patches(object, *patches, &scope) \
+          : apply_patches(object, *patches)
+  end
+  
+  #
+  # Applies +patches+ to +object+, yields, then removes the patches when the
+  # block returns.
+  #
+  def self.scope_patches(object, *patches)
+    apply_patches(object, *patches)
+    yield
+  ensure
+    remove_patches(object, *patches)
+  end
+  
+  #
+  # Applies the Modules +patches+ to +object+.
+  #
+  def self.apply_patches(object, *patches)
+    patches.each {|patch| object.send(:include, patch) }
+  end
+  
+  #
+  # Removes the Modules +patches+ from +object+.
+  #
+  def self.remove_patches(object, *patches)
+    patches.each {|patch| object.send(:uninclude, patch) }
+  end
+  
+  #
+  # Registers a monkeypatch +patch+, which should be a module that defines the
+  # named +method+. The patch is scoped to +klass+ and is named +method+.
+  #
+  def self.register_patch(klass, method, patch)
+    error_patched(klass, method) if patch_for(klass, method)
+    
+    self.patches[klass][method] = patch
+  end
+  
+  #
+  # Looks up the monkeypatch for +method+ in +klass+.
+  #
+  def self.patch_for(klass, method)
+    self.patches[klass][method]
+  end
+  
+  #
+  # A nested hash of existing monkeypatch definitions, first by class, then
+  # method name.
+  #
+  def self.patches
+    @patches ||= Hash.new {|h,k| h[k] = Hash.new }
+  end
+  
+  def self.error_patched(klass, method)
+    raise MethodPatchedError,
+      "#{klass}##{method} already has a monkeypatch"
+  end
+  
+  def self.error_missing(klass, method)
+    raise MethodMissingError,
+      "No monkeypatch #{klass}##{method} has been defined"
+  end
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: monkey
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  hash: 7
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Stephen Touset
@@ -9,57 +15,87 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-26 00:00:00 -05:00
+date: 2010-07-12 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
-description: This is just a dummy package to reserve the name until the project is ready to be released
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: version
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
 email: stephen@touset.org
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE
 - README.rdoc
 files: 
-- .document
-- .gitignore
-- LICENSE
-- README.rdoc
 - Rakefile
+- README.rdoc
 - VERSION
+- lib/monkey/ext/modexcl/mrimodexcl.rb
+- lib/monkey/ext/modexcl/rbmodexcl.rb
+- lib/monkey/ext/modexcl/rbxmodexcl.rb
 - lib/monkey.rb
-- test/helper.rb
-- test/test_monkey.rb
 has_rdoc: true
-homepage: http://github.com/stouset/monkey
+homepage: 
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --charset=UTF-8
+- --main
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Scopeable monkeypatching support for Ruby
-test_files: 
-- test/helper.rb
-- test/test_monkey.rb
+summary: A smart, scoped monkeypatching library
+test_files: []
+

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC

data/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2009 Stephen Touset
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/test/helper.rb

@@ -1,10 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'monkey'
-
-class Test::Unit::TestCase
-end

data/test/test_monkey.rb

@@ -1,7 +0,0 @@
-require 'helper'
-
-class TestMonkey < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
-  end
-end