method_disabling 0.1.0

data/.document

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

data/.rspec

@@ -0,0 +1,2 @@
+--format=documentation
+--color

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - ree

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec",   "~> 2.8.0"
+  gem "yard",    "~> 0.7"
+  gem "rdoc",    "~> 3.12"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+end

data/Gemfile.lock

@@ -0,0 +1,33 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.6.5)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    yard (0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.8.3)
+  rdoc (~> 3.12)
+  rspec (~> 2.8.0)
+  yard (~> 0.7)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 David Cuddeback
+
+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/README.rdoc

@@ -0,0 +1,58 @@
+= method_disabling
+
+Allows disabling methods at runtime. It can be used to raise an error whenever a certain method is
+called from within your test suite to ensure the developers on your team don't accidentally write
+fragile tests. For example, you might want to disable access to a shared resource.
+
+== Getting Started
+
+Add +method_disabling+ to your Gemfile (probably under the +test+ group):
+
+  group :test do
+    gem "method_disabling"
+  end
+
+Use <tt>Module#disable_method</tt> and <tt>Module#disable_class_method</tt> to disable methods that
+you don't want called during your test suite. For example, to disable access to <tt>Net::HTTP</tt>:
+
+  # spec/spec_helper.rb
+  config.before do
+    Net::HTTP.disable_method :initialize
+  end
+
+When developers inadvertantly write unit tests that access the disabled method, they will see an error message:
+
+  NoMethodError: Net::HTTP#initialize is disabled
+
+You can set a custom error message by adding a second parameter to +disable_method+:
+
+  # spec/spec_helper.rb
+  config.before do
+    Net::HTTP.disable_method :initialize, "You were about to access an external resource. Please mock or stub instead."
+  end
+
+A disabled method can be restored to its original behavior with +restore_method+:
+
+  Net::HTTP.restore_method :initialize
+
+The same can be done for class methods with +disable_class_method+ and +restore_class_method+.
+
+== Status {<img src="https://secure.travis-ci.org/dcuddeback/method_disabling.png" />}[http://travis-ci.org/dcuddeback/method_disabling]
+
++method_disabling+ is tested on Ruby 1.8.7, 1.9.2, 1.9.3, REE, Rubnius (1.8 and 1.9 mode), and JRuby (1.8 and 1.9 mode).
+
+== Contributing to method_disabling
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 David Cuddeback. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "method_disabling"
+  gem.homepage = "http://github.com/dcuddeback/method_disabling"
+  gem.license = "MIT"
+  gem.summary = %Q{Allows disabling methods at run-time}
+  gem.description = %Q{Allows you to disable methods at run-time, such as when you want to ensure that certain methods are never called during a test suite.}
+  gem.email = "david.cuddeback@gmail.com"
+  gem.authors = ["David Cuddeback"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/method_disabling.rb

@@ -0,0 +1,206 @@
+# MethodDisabling allows a programmer to programatically disable existing methods, causing them to
+# raise a NoMethodError, and restore the methods to their original behavior.
+#
+# The most obvious use case for disabling messages is when you want to ensure that your unit tests
+# don't do anything unexpected, such as connecting to external resources.
+module MethodDisabling
+
+  # Provides class-level macros for managing disabled methods.
+  #
+  # @example Disabling an instance method
+  #   class Foo
+  #     def bar
+  #       42
+  #     end
+  #   end
+  #
+  #   Foo.new.bar               # => 42
+  #   Foo.disable_method :bar
+  #   Foo.new.bar               # => NoMethodError: Foo#bar is disabled
+  #   Foo.restore_method :bar
+  #   Foo.new.bar               # => 42
+  #
+  # @example Disabling a class method
+  #   class Foo
+  #     def self.bar
+  #       42
+  #     end
+  #   end
+  #
+  #   Foo.bar                         # => 42
+  #   Foo.disable_class_method :bar
+  #   Foo.bar                         # => NoMethodError: #<Class:Foo>#bar is disabled
+  #   Foo.restore_class_method :bar
+  #   Foo.bar                         # => 42
+  #
+  module ClassMethods
+
+    # Disables an instance method.
+    #
+    # @param [Symbol,String]  method_name   The name of the method to disable.
+    # @param [String]         message       An error message. Defaults to "Class#method is disabled".
+    def disable_method(method_name, message = nil)
+      disabled_methods[method_name] ||= DisabledMethod.new(self, method_name, message)
+      disabled_methods[method_name].disable!
+    end
+
+    # Restores a previously disabled instance method.
+    #
+    # @param [Symbol,String]  method_name   The name of the method to restore.
+    def restore_method(method_name)
+      disabled_methods[method_name].restore!
+    end
+
+    # A collection of the methods that have been disabled.
+    #
+    # @return [Hash]
+    def disabled_methods
+      @disabled_methods ||= {}
+    end
+    private :disabled_methods
+
+    # Disables a class method.
+    #
+    # @param [Symbol,String]  method_name   The name of the method to disable.
+    # @param [String]         message       An error message. Defaults to "Class#method is disabled".
+    def disable_class_method(method_name, message = nil)
+      (class << self; self; end).disable_method(method_name, message)
+    end
+
+    # Restores a previously disabled class method.
+    #
+    # @param [Symbol,String]  method_name   The name of the method to restore.
+    def restore_class_method(method_name)
+      (class << self; self; end).restore_method(method_name)
+    end
+
+  end
+
+
+  # A DisabledMethod is an existing class or instance method that has been disabled. The method can
+  # be disabled and restored as necessary. When the method is disabled, calling the method will
+  # raise a NoMethodError, optionally with a custom message. When the method is restored, the method
+  # will behave as normal.
+  #
+  # Although this class *could* be used directly, the intention is that you would use the methods in
+  # {MethodDisabling::ClassMethods} to disable and restore methods.
+  class DisabledMethod
+
+    attr_reader :klass, :method_name, :message
+
+    # Disables a instance method. To disable a class method, pass the class's singleton class as the
+    # first argument.
+    #
+    # @param [Module]         klass         The module or class whose method should be disabled.
+    # @param [Symbol,String]  method_name   The name of the method to disable.
+    # @param [String]         message       The exception message to be shown when the method is
+    #                                       called.
+    def initialize(klass, method_name, message = nil)
+      @klass       = klass
+      @method_name = method_name
+      @message     = message || "#{klass.inspect}##{method_name} is disabled"
+
+      alias_method!
+      disable!
+    end
+
+    # Disables the method.
+    def disable!
+      @disabled = true
+    end
+
+    # Restores the method.
+    def restore!
+      @disabled = false
+    end
+
+    # Returns a Proc that acts as a replacement for the disabled method.
+    def to_proc
+      disabled_method = self
+
+      # This proc will be evaluated with "self" set to the original object.
+      Proc.new do |*args, &block|
+        disabled_method.execute(self, *args, &block)
+      end
+    end
+
+    # The replacement for the original method. It will raise a NoMethodError if the method is
+    # disabled. Otherwise, it will execute the original method.
+    #
+    # @param [Object] object  The "self" object of the method being called.
+    # @param [Array]  args    The arguments that were passed to the method.
+    # @param [Proc]   block   The block that was passed to the method.
+    #
+    # @return Whatever the original method returns.
+    def execute(object, *args, &block)
+      if disabled?
+        raise NoMethodError, message
+      else
+        object.send(aliased_name, *args, &block)
+      end
+    end
+
+    private
+
+    # Indicates whether or not the method is disabled.
+    #
+    # @return [Boolean]
+    def disabled?
+      @disabled
+    end
+
+    # Replaces the original implementation of the method with an implementation that allows
+    # disabling.
+    def alias_method!
+      klass.send(:define_method, replacement_name, &self)
+      klass.send(:alias_method, aliased_name, method_name)
+      klass.send(:alias_method, method_name, replacement_name)
+    end
+
+    # The name of the replacement method.
+    #
+    # @return [String]
+    def replacement_name
+      "#{base_method_name}_with_disable#{method_suffix}"
+    end
+
+    # The aliased name of the original method.
+    #
+    # @return [String]
+    def aliased_name
+      "#{base_method_name}_without_disable#{method_suffix}"
+    end
+
+    # The original method name with any suffix ("!" or "?") removed.
+    #
+    # @return [String]
+    def base_method_name
+      method_name_parts[:base_name]
+    end
+
+    # The original method name's suffix ("!" or "?"), if any.
+    #
+    # @return [String]
+    def method_suffix
+      method_name_parts[:suffix]
+    end
+
+    # The original method name broken into parts. The returned value can is a hash with the keys
+    # `:base_name` and `:suffix`, which return the original method name's base name and suffix,
+    # respectively.
+    #
+    # @return [Hash]
+    def method_name_parts
+      @parts ||= begin
+        base_name, suffix = method_name.to_s.sub(/([?!=]?)$/, ""), $1
+        { :base_name => base_name, :suffix => suffix }
+      end
+    end
+
+  end
+
+end
+
+# Yeah, it's including ClassMethods, which isn't usual, but that's because it's being included on
+# the Module class, which effectively makes them class methods in other classes and modules.
+Module.send(:include, MethodDisabling::ClassMethods)

data/spec/method_disabling_spec.rb

@@ -0,0 +1,178 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+
+shared_examples "enabled method" do
+
+  it "should call the original implementation" do
+    object.should_receive(:original_implementation)
+    object.the_method rescue nil
+  end
+
+  it "should pass through the method parameters" do
+    args = [:foo, 42]
+    object.should_receive(:original_implementation).with(*args)
+    object.the_method(*args) rescue nil
+  end
+
+  it "should pass through any block parameters" do
+    yielded   = nil
+    the_block = Proc.new { |*args| yielded = args }
+
+    object.should_receive(:original_implementation).and_yield(42)
+    object.the_method(&the_block)
+
+    yielded.should == [42]
+  end
+
+  it "should return the original implementation's return value" do
+    return_value = rand
+    object.should_receive(:original_implementation).and_return(return_value)
+    object.the_method.should == return_value
+  end
+
+  it "should not raise an error" do
+    expect {
+      object.the_method
+    }.to_not raise_error
+  end
+
+end
+
+
+shared_examples "disabled method" do
+
+  it "should not call the original implementation" do
+    object.should_not_receive(:original_implementation)
+    object.the_method rescue nil
+  end
+
+  it "should raise NoMethodError with default message" do
+    expect {
+      object.the_method
+    }.to raise_error(NoMethodError, "#{klass_inspect}#the_method is disabled")
+  end
+
+end
+
+
+shared_examples "method disabling" do
+
+  context "untouched" do
+    it_should_behave_like "enabled method"
+  end
+
+  context "disabled" do
+    context "with default message" do
+      before do
+        klass.send(disabler, :the_method)
+      end
+
+      it_should_behave_like "disabled method"
+    end
+
+    context "with custom message" do
+      let(:message) { "Custom Message" }
+
+      before do
+        klass.send(disabler, :the_method, message)
+      end
+
+      it "should raise NoMethodError with custom message" do
+        expect {
+          object.the_method
+        }.to raise_error(NoMethodError, message)
+      end
+    end
+  end
+
+  context "restored" do
+    before do
+      klass.send(disabler, :the_method)
+      klass.send(restorer, :the_method)
+    end
+
+    it_should_behave_like "enabled method"
+  end
+
+  context "re-disabled" do
+    context "with default message" do
+      before do
+        klass.send(disabler, :the_method)
+        klass.send(restorer, :the_method)
+        klass.send(disabler, :the_method)
+      end
+
+      it_should_behave_like "disabled method"
+    end
+
+    context "with custom message" do
+      let(:message) { "Custom Message" }
+
+      before do
+        klass.send(disabler, :the_method, message)
+        klass.send(restorer, :the_method)
+        klass.send(disabler, :the_method)
+      end
+
+      it "should raise NoMethodError with custom message" do
+        expect {
+          object.the_method
+        }.to raise_error(NoMethodError, message)
+      end
+    end
+  end
+
+end
+
+
+describe "MethodDisabling" do
+
+  describe "instance methods" do
+    let(:klass) do
+      suppress_warnings do
+        ::TheClass = Class.new do
+          def the_method(*args, &block)
+            original_implementation(*args, &block)
+          end
+
+          private
+
+          def original_implementation(*args, &block)
+            42
+          end
+        end
+      end
+    end
+
+    let(:object)        { klass.new }
+    let(:disabler)      { :disable_method }
+    let(:restorer)      { :restore_method }
+    let(:klass_inspect) { klass.inspect }
+
+    include_examples "method disabling"
+  end
+
+  describe "class methods" do
+    let(:klass) do
+      suppress_warnings do
+        ::TheClass = Class.new do
+          def self.the_method(*args, &block)
+            original_implementation(*args, &block)
+          end
+
+          def self.original_implementation(*args, &block)
+          end
+          private_class_method :original_implementation
+        end
+      end
+    end
+
+    let(:object)        { klass }
+    let(:disabler)      { :disable_class_method }
+    let(:restorer)      { :restore_class_method }
+    let(:klass_inspect) { class << klass; inspect; end }
+
+    include_examples "method disabling"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'method_disabling'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end
+
+def suppress_warnings
+  original_verbosity = $VERBOSE
+  $VERBOSE = nil
+  yield
+ensure
+  $VERBOSE = original_verbosity
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: method_disabling
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- David Cuddeback
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &12456960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *12456960
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &12455480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: *12455480
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &12469180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *12469180
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &12465440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *12465440
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &12464460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *12464460
+description: Allows you to disable methods at run-time, such as when you want to ensure
+  that certain methods are never called during a test suite.
+email: david.cuddeback@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/method_disabling.rb
+- spec/method_disabling_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/dcuddeback/method_disabling
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2416705567977990342
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Allows disabling methods at run-time
+test_files: []