tco_method 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 74462b42288aee51eb1533d2a233c9a39c4bea07
+  data.tar.gz: 8a4ebe308889ee0edf86489e4491ea3d9d656f52
+SHA512:
+  metadata.gz: b3cdc64cac48fd98ca99c52fdc076b9e58e2f209bd8bbb7d5b10bf4feb81af392c4077a891652fadad165d5c3086e200254ef51753eabd45e1e01ec0049210c1
+  data.tar.gz: 807f4ae4f07dbaf15412c9b4dbfe66e1e856e06e647dcd2028b498bac587f4b8dddba890de212ef4250f188ea51a162e796164d3010c09ce22a6a6e50564f32c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+
+rvm:
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,16 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :doc do
+  gem "yard"
+end
+
+group :test do
+  gem "coveralls", :require => false
+  gem "guard"
+  gem "guard-minitest"
+  gem "minitest", ">= 3.0"
+  gem "mocha"
+  gem "simplecov", :require => false
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard(:minitest, :all_after_pass => false, :all_on_start => false) do
+  watch(%r{^lib/tco_method/(.+)\.rb$})                               { |m| "test/unit/#{m[1]}_test.rb" }
+  watch(%r{^test/.+_test\.rb$})
+  watch(%r{^(?:test/test_helper(.*)|lib/tco_method)\.rb$}) { "test" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Danny
+
+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.md

@@ -0,0 +1,92 @@
+# TCOMethod
+[![Gem Version](https://badge.fury.io/rb/tco_method.svg)](http://badge.fury.io/rb/tco_method)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/gems/tco_method)
+[![Build Status](https://travis-ci.org/tdg5/tco_method.svg)](https://travis-ci.org/tdg5/tco_method)
+[![Coverage Status](https://coveralls.io/repos/tdg5/tco_method/badge.svg)](https://coveralls.io/r/tdg5/tco_method)
+[![Code Climate](https://codeclimate.com/github/tdg5/tco_method/badges/gpa.svg)](https://codeclimate.com/github/tdg5/tco_method)
+[![Dependency Status](https://gemnasium.com/tdg5/tco_method.svg)](https://gemnasium.com/tdg5/tco_method)
+
+Provides `TCOMethod::Mixin` for extending Classes and Modules with helper methods
+to facilitate evaluating code and some types of methods with tail call
+optimization enabled. Also provides `TCOMethod.tco_eval` providing an easy means
+to evaluate code strings with tail call optimization enabled.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```bash
+gem 'tco_method'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install tco_method
+```
+
+## Usage
+
+Require the `TCOMethod` library:
+
+```ruby
+require "tco_method"
+```
+
+Extend a class with the `TCOMethod::Mixin` and enjoy!
+
+```ruby
+class MyClass
+  extend TCOMethod::Mixin
+
+  def factorial(n, acc = 1)
+    n <= 1 ? acc : factorial(n - 1, n * acc)
+  end
+  tco_method :factorial
+end
+
+MyClass.new.factorial(10_000).to_s.length
+# => 35660
+```
+
+Or, use `TCOMethod.tco_eval` directly. Cumbersome, but much more flexible and
+powerful:
+
+```ruby
+TCOMethod.tco_eval(<<-CODE)
+  class MyClass
+    def factorial(n, acc = 1)
+      n <= 1 ? acc : factorial(n - 1, n * acc)
+    end
+  end
+CODE
+
+MyClass.new.factorial(10_000).to_s.length
+# => 35660
+```
+
+## Gotchas
+
+The list so far:
+
+- Currently only works with methods defined using the `def` keyword.
+- Class annotations use the [`method_source` gem](https://github.com/banister/method_source)
+  to retrieve the method source to reevaluate. As a result, class annotations
+  can act strangely when used in more dynamic contexts like `irb` or `pry`.
+
+
+I'm sure there are more and I will document them here as I come across them.
+
+## Contributing
+
+1. Fork it ( https://github.com/tdg5/tco_method/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+end
+
+task :default => :test

data/lib/tco_method.rb

@@ -0,0 +1,71 @@
+require "method_source"
+require "tco_method/version"
+require "tco_method/method_info"
+require "tco_method/mixin"
+
+# The namespace for the TCOMethod gem. Home to private API methods employed by
+# the {TCOMethod::Mixin} module to provide tail call optimized behavior to
+# extending Classes and Modules.
+module TCOMethod
+  # Options that must be provided to RubyVM::InstructionSequence in order to
+  # compile code with tail call optimization enabled. Beyond simply enabling the
+  # `tailcall optimization` option, the `trace_instruction` option must also be
+  # disabled because the RubyVM doesn't currently support `set_trace_func` for
+  # code that is compiled with tail call optimization.
+  ISEQ_OPTIONS = {
+    tailcall_optimization: true,
+    trace_instruction: false,
+  }.freeze
+
+  # Reevaluates a method with tail call optimization enabled.
+  #
+  # @note This method is not part of the public API and should not be used
+  #   directly. See {TCOMethod::Mixin} for a module that provides publicly
+  #   supported access to the behaviors provided by this method.
+  # @param [Class, Module] receiver The Class or Module for which the specified
+  #   module, class, or instance method should be reevaluated with tail call
+  #   optimization enabled.
+  # @param [String, Symbol] method_name The name of the method that should be
+  #   reevaluated with tail call optimization enabled.
+  # @param [Symbol] method_owner A symbol representing whether the specified
+  #   method is expected to be owned by a class, module, or instance.
+  # @return [Symbol] The symbolized method name.
+  # @raise [ArgumentError] Raised if receiver, method_name, or method_owner
+  #   argument is omitted.
+  # @raise [TypeError] Raised if the specified method is not a method that can
+  #   be reevaluated with tail call optimization enabled.
+  def self.reevaluate_method_with_tco(receiver, method_name, method_owner)
+    raise ArgumentError, "Receiver required!" unless receiver
+    raise ArgumentError, "Method name required!" unless method_name
+    raise ArgumentError, "Method owner required!" unless method_owner
+    if method_owner == :instance
+      existing_method = receiver.instance_method(method_name)
+    elsif method_owner == :class || method_owner== :module
+      existing_method = receiver.method(method_name)
+    end
+    method_info = MethodInfo.new(existing_method)
+    if method_info.type != :method
+      raise TypeError, "Invalid method type: #{method_info.type}"
+    end
+    code = <<-CODE
+      class #{receiver.name}
+        #{existing_method.source}
+      end
+    CODE
+    tco_eval(code)
+    method_name.to_sym
+  end
+
+  # Provides a mechanism for evaluating Strings of code with tail call
+  # optimization enabled.
+  #
+  # @param [String] code The code to evaluate with tail call optimization
+  #   enabled.
+  # @return [Object] Returns the value of the final expression of the provided
+  #   code String.
+  # @raise [ArgumentError] if the provided code argument is not a String.
+  def self.tco_eval(code)
+    raise ArgumentError, "Invalid code string!" unless code.is_a?(String)
+    RubyVM::InstructionSequence.new(code, nil, nil, nil, ISEQ_OPTIONS).eval
+  end
+end

data/lib/tco_method/method_info.rb

@@ -0,0 +1,39 @@
+module TCOMethod
+  # Class encapsulating the behaviors required to extract information about a
+  # method from the 14-element Array of data representing the instruction
+  # sequence of that method.
+  class MethodInfo
+    # A collection of those classes that will be recognized as methods and can
+    # be used effectively with this class.
+    VALID_METHOD_CLASSES = [
+      Method,
+      UnboundMethod,
+    ].freeze
+
+    # Creates a new MethodInfo instance.
+    #
+    # @param [Method] method_obj The Method or UnboundMethod object representing
+    #   the method for which more information should be retrieved.
+    # @raise [TypeError] Raised if the provided method object is not a Method or
+    #   Unbound method.
+    # @see VALID_METHOD_CLASSES
+    def initialize(method_obj)
+      unless VALID_METHOD_CLASSES.any? { |klass| method_obj.is_a?(klass) }
+        msg = "Invalid argument! Method or UnboundMethod expected, received #{method_obj.class.name}"
+        raise TypeError, msg
+      end
+      @info = RubyVM::InstructionSequence.of(method_obj).to_a
+    end
+
+    # Returns the type of the method object as reported by the Array of data
+    # describing the instruction sequence representing the method.
+    #
+    # @return [Symbol] A Symbol identifying the type of the instruction
+    #   sequence. Typical values will be :method or :block, but all of the
+    #   following are valid return values: :top, :method, :block, :class,
+    #   :rescue, :ensure, :eval, :main, and :defined_guard.
+    def type
+      @info[9]
+    end
+  end
+end

data/lib/tco_method/mixin.rb

@@ -0,0 +1,45 @@
+module TCOMethod
+  # Mixin providing tail call optimization eval and class annotations. When
+  # extended by a Class or Module adds methods for evaluating code with tail
+  # call optimization enabled and re-evaluating existing methods with tail call
+  # optimization enabled.
+  module Mixin
+    # Class annotation causing the class or module method identified by the
+    # given method name to be reevaluated with tail call optimization enabled.
+    # Only works for methods defined using the `def` keyword.
+    #
+    # @param [String, Symbol] method_name The name of the class or module method
+    #   that should be reeevaluated with tail call optimization enabled.
+    # @return [Symbol] The symbolized method name.
+    # @see TCOMethod.reevaluate_method_with_tco
+    def tco_class_method(method_name)
+      TCOMethod.reevaluate_method_with_tco(self, method_name, :class)
+    end
+    alias_method :tco_module_method, :tco_class_method
+
+    # Evaluate the given code String with tail call optimization enabled.
+    #
+    # @param [String] code The code to evaluate with tail call optimization
+    #   enabled.
+    # @return [Object] Returns the value of the final expression of the provided
+    #   code String.
+    # @raise [ArgumentError] if the provided code argument is not a String.
+    # @see TCOMethod.tco_eval
+    def tco_eval(code)
+      TCOMethod.tco_eval(code)
+    end
+
+    # Class annotation causing the instance method identified by the given
+    # method name to be reevaluated with tail call optimization enabled. Only
+    # works for methods defined using the `def` keyword.
+    #
+    # @param [String, Symbol] method_name The name of the instance method that
+    #   should be reeevaluated with tail call optimization enabled.
+    # @return [Symbol] The symbolized method name.
+    # @see TCOMethod.reevaluate_method_with_tco
+    def tco_method(method_name)
+      TCOMethod.reevaluate_method_with_tco(self, method_name, :instance)
+      method_name.to_sym
+    end
+  end
+end

data/lib/tco_method/version.rb

@@ -0,0 +1,4 @@
+module TCOMethod
+  # The version of the TCOMethod gem.
+  VERSION = "0.0.1"
+end

data/tco_method.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "tco_method/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "tco_method"
+  spec.version       = TCOMethod::VERSION
+  spec.authors       = ["Danny Guinther"]
+  spec.email         = ["dannyguinther@gmail.com"]
+  spec.summary       = %q{Simplifies creating tail call optimized procs/lambdas/methods in Ruby.}
+  spec.description   = %q{Simplifies creating tail call optimized procs/lambdas/methods in Ruby.}
+  spec.homepage      = "https://github.com/tdg5/tco_method"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = "~> 2"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "method_source", "~> 0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 0"
+end

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+if ENV["CI"]
+  require "simplecov"
+  require "coveralls"
+  Coveralls.wear!
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  SimpleCov.root(File.expand_path("../..", __FILE__))
+end
+
+require "minitest/autorun"
+require "mocha/setup"
+require "tco_method"
+
+require "test_helpers/vm_stack_helper"
+require "test_helpers/factorial_stack_buster_helper"
+require "test_helpers/vanilla_stack_buster_helper"
+
+# Use alternate shoulda-style DSL for tests
+class TCOMethod::TestCase < Minitest::Spec
+  class << self
+    alias :setup :before
+    alias :teardown :after
+    alias :context :describe
+    alias :should :it
+  end
+end

data/test/test_helpers/factorial_stack_buster_helper.rb

@@ -0,0 +1,31 @@
+require "test_helpers/stack_busters/factorial_stack_buster"
+
+module TCOMethod
+  module TestHelpers
+    module FactorialStackBusterHelper
+      extend Forwardable
+
+      def_delegators "#{self.name}.stack_buster", :unoptimized_factorial
+
+      long_alias =  :factorial_stack_buster_stack_depth_remaining
+      def_delegator "#{self.name}.stack_buster", :stack_depth_remaining, long_alias
+
+      def self.stack_buster
+        @@stack_buster ||= StackBusters::FactorialStackBuster.new
+      end
+
+      def assert_unoptimized_factorial_stack_overflow(depth)
+        # Subtract 1 to account for this methiod call since result should be
+        # relative to caller
+        unoptimized_factorial(depth - 1)
+        assert false, "Factorial for depth #{depth} did not overflow!"
+      rescue SystemStackError
+        assert true
+      end
+
+      def iterative_factorial(n)
+        (2..n).inject(1, :*)
+      end
+    end
+  end
+end

data/test/test_helpers/stack_busters/factorial_stack_buster.rb

@@ -0,0 +1,60 @@
+require "pry"
+
+module TCOMethod
+  module TestHelpers
+    module StackBusters
+      class FactorialStackBuster
+        include VMStackHelper
+
+        def frame_size
+          @frame_size ||= vm_stack_size / stack_overflow_threshold
+        end
+
+        def unoptimized_factorial(n, acc = 1)
+          n <= 1 ? acc : unoptimized_factorial(n - 1, n * acc)
+        end
+
+        def stack_depth_remaining
+          stack_depth_remaining_for_frame_size(frame_size)
+        end
+
+        private
+
+        # Stack buster based on binary search for point of stack oveflow of
+        # unoptimized_factorial
+        def stack_overflow_threshold
+          # Use a frame size that's larger than the expected frame size to ensure
+          # that limit is less than the point of overflow
+          limit = last_good_limit = stack_depth_limit_for_frame_size(LARGEST_VM_STACK_SIZE * 2)
+          last_overflow_limit = nil
+          # Determine an upper-bound for binary search
+          loop do
+            begin
+              unoptimized_factorial(limit)
+              last_good_limit = limit
+              limit *= 2
+            rescue SystemStackError
+              last_overflow_limit = limit
+              break
+            end
+          end
+
+          # Reset for binary search for point of stack overflow
+          limit = last_good_limit
+          loop do
+            return last_overflow_limit if last_overflow_limit == last_good_limit + 1
+            begin
+              half_the_distance_to_overflow = (last_overflow_limit - limit) / 2
+              limit += half_the_distance_to_overflow
+              unoptimized_factorial(limit)
+              last_good_limit = limit
+            rescue SystemStackError
+              last_overflow_limit = limit
+              limit = last_good_limit
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_helpers/stack_busters/vanilla_stack_buster.rb

@@ -0,0 +1,25 @@
+module TCOMethod
+  module TestHelpers
+    module StackBusters
+      class VanillaStackBuster
+        include VMStackHelper
+
+        def frame_size
+          @frame_size ||= vm_stack_size / stack_overflow_threshold
+        end
+
+        def stack_depth_remaining
+          stack_depth_remaining_for_frame_size(frame_size)
+        end
+
+        private
+
+        def stack_overflow_threshold(depth = 1)
+          stack_overflow_threshold(depth + 1)
+        rescue SystemStackError
+          depth
+        end
+      end
+    end
+  end
+end

data/test/test_helpers/vanilla_stack_buster_helper.rb

@@ -0,0 +1,16 @@
+require "test_helpers/stack_busters/vanilla_stack_buster"
+
+module TCOMethod
+  module TestHelpers
+    module VanillaStackBusterHelper
+      extend Forwardable
+
+      def_delegator "#{self.name}.stack_buster", :stack_depth_remaining, :vanilla_stack_depth_remaining
+
+      def self.stack_buster
+        @@stack_buster ||= StackBusters::VanillaStackBuster.new
+      end
+      private_class_method :stack_buster
+    end
+  end
+end

data/test/test_helpers/vm_stack_helper.rb

@@ -0,0 +1,28 @@
+module TCOMethod
+  module TestHelpers
+    module VMStackHelper
+      LARGEST_VM_STACK_SIZE = 128
+
+      # Calculate the maximum number of times a stack frame of a given size could
+      # be repeated before running out of room on the stack.
+      def stack_depth_limit_for_frame_size(frame_size)
+        vm_stack_size / frame_size
+      end
+      module_function :stack_depth_limit_for_frame_size
+
+      # Calculate how many more times a frame could be repeated before running out of
+      # room on the stack.
+      def stack_depth_remaining_for_frame_size(frame_size)
+        stack_depth_limit_for_frame_size(frame_size) - caller.length + 1
+      end
+      module_function :stack_depth_remaining_for_frame_size
+
+      # Determine maximum size of VM stack for a single thread based on
+      # environment or default value.
+      def vm_stack_size
+        ENV["RUBY_THREAD_VM_STACK_SIZE"] || RubyVM::DEFAULT_PARAMS[:thread_vm_stack_size]
+      end
+      module_function :vm_stack_size
+    end
+  end
+end

data/test/unit/method_info_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+class MethodInfoTest < TCOMethod::TestCase
+  Subject = TCOMethod::MethodInfo
+
+  TestClass = Class.new do
+    class << self; define_method(:class_block_method) { }; end
+    def self.class_def_method; end
+    define_method(:instance_block_method) { }
+    def instance_def_method; end
+  end
+
+  context "#initialize" do
+    should "raise TypeError unless given a Method object" do
+      non_methods = [
+        proc { },
+        lambda { },
+        Proc.new { },
+      ]
+      non_methods.each do |non_method|
+        assert_raises(TypeError) do
+          Subject.new(non_method)
+        end
+      end
+    end
+
+    should "accept Method objects defined on a class using def" do
+      method_obj = TestClass.method(:class_def_method)
+      assert_kind_of Method, method_obj
+      assert_kind_of Subject, Subject.new(method_obj)
+    end
+
+    should "accept UnboundMethod objects defined on an instance using def" do
+      method_obj = TestClass.instance_method(:instance_def_method)
+      assert_kind_of UnboundMethod, method_obj
+      assert_kind_of Subject, Subject.new(method_obj)
+    end
+
+    should "accept Method objects defined on a class using define_method" do
+      method_obj = TestClass.method(:class_block_method)
+      assert_kind_of Method, method_obj
+      assert_kind_of Subject, Subject.new(method_obj)
+    end
+
+    should "accept UnboundMethod objects defined on an instance using define_method" do
+      method_obj = TestClass.instance_method(:instance_block_method)
+      assert_kind_of UnboundMethod, method_obj
+      assert_kind_of Subject, Subject.new(method_obj)
+    end
+  end
+
+  context "#type" do
+    subject { TestClass.new }
+    should "return :method for methods defined using def" do
+      assert_equal :method, Subject.new(TestClass.method(:class_def_method)).type
+      assert_equal :method, Subject.new(subject.method(:instance_def_method)).type
+    end
+
+    should "return :block for methods defined using define_method" do
+      assert_equal :block, Subject.new(TestClass.method(:class_block_method)).type
+      assert_equal :block, Subject.new(subject.method(:instance_block_method)).type
+    end
+  end
+end

data/test/unit/mixin_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+
+class MixinTest < TCOMethod::TestCase
+  include TCOMethod::TestHelpers::FactorialStackBusterHelper
+
+  TestClass = Class.new do
+    extend TCOMethod::Mixin
+  end
+
+  subject { TestClass }
+
+  [:tco_class_method, :tco_module_method].each do |method_alias|
+    context "##{method_alias}" do
+      should "call TCOMethod.reevaluate_method_with_tco with expected arguments" do
+        method_name = :some_method
+        args = [TestClass, method_name, :class]
+        TCOMethod.expects(:reevaluate_method_with_tco).with(*args)
+        subject.send(method_alias, method_name)
+      end
+    end
+  end
+
+  context "#tco_eval" do
+    should "call TCOMethod.eval with expected arguments" do
+      code = "some_code"
+      TCOMethod.expects(:tco_eval).with(code)
+      subject.tco_eval(code)
+    end
+  end
+
+  context "#tco_method" do
+    should "call TCOMethod.reevaluate_method_with_tco with expected arguments" do
+      method_name = :some_method
+      args = [TestClass, method_name, :instance]
+      TCOMethod.expects(:reevaluate_method_with_tco).with(*args)
+      subject.tco_method(method_name)
+    end
+  end
+end

data/test/unit/tco_method_test.rb

@@ -0,0 +1,139 @@
+require "test_helper"
+
+class TCOMethodTest < TCOMethod::TestCase
+  include TCOMethod::TestHelpers::FactorialStackBusterHelper
+
+  Subject = TCOMethod
+
+  TestClass = Class.new do
+    extend TCOMethod::Mixin
+
+    class << self;
+      define_method(:class_block_method) { }
+    end
+
+    def self.class_factorial(n, acc = 1)
+      n <= 1 ? acc : class_factorial(n - 1, n * acc)
+    end
+
+    define_method(:instance_block_method)  { }
+
+    def instance_factorial(n, acc = 1)
+      n <= 1 ? acc : instance_factorial(n - 1, n * acc)
+    end
+  end
+
+  subject { Subject }
+
+  context Subject.name do
+    should "be defined" do
+      assert defined?(subject), "Expected #{subject.name} to be defined!"
+    end
+  end
+
+  context "::tco_eval" do
+    should "raise ArgumentError unless code is a String" do
+      bad_code = [
+        :bad_code,
+        5,
+        proc { puts "hello" },
+      ]
+      bad_code.each do |non_code|
+        assert_raises(ArgumentError) do
+          subject.tco_eval(non_code)
+        end
+      end
+    end
+
+    should "compile the given code with tail call optimization" do
+      FactorialEvalDummy = dummy_class = Class.new
+      subject.tco_eval(<<-CODE)
+        class #{dummy_class.name}
+          def factorial(n, acc = 1)
+            n <= 1 ? acc : factorial(n - 1, n * acc)
+          end
+        end
+      CODE
+
+      # Exceed maximum available stack depth by 100 for good measure
+      factorial_seed = factorial_stack_buster_stack_depth_remaining + 100
+      assert_unoptimized_factorial_stack_overflow(factorial_seed)
+
+      expected_result = iterative_factorial(factorial_seed)
+      assert_equal expected_result, dummy_class.new.factorial(factorial_seed)
+    end
+  end
+
+  context "::reevaluate_method_with_tco" do
+    subject { Subject.method(:reevaluate_method_with_tco) }
+
+    context "validation" do
+      should "raise ArgumentError unless receiver given" do
+        assert_raises(ArgumentError) do
+          subject.call(nil, :nil?, :instance)
+        end
+      end
+
+      should "raise ArgumentError unless method name given" do
+        assert_raises(ArgumentError) do
+          subject.call(TestClass, nil, :instance)
+        end
+      end
+
+      should "raise ArgumentError unless method owner given" do
+        assert_raises(ArgumentError) do
+          subject.call(TestClass, :class_factorial, nil)
+        end
+      end
+
+      should "raise TypeError for block methods" do
+        assert_raises(TypeError) do
+          subject.call(TestClass, :class_block_method, :class)
+        end
+        assert_raises(TypeError) do
+          subject.call(TestClass, :instance_block_method, :instance)
+        end
+      end
+    end
+
+    context "with class method" do
+      should "raise NameError if no class method with given name defined" do
+        assert_raises(NameError) do
+          subject.call(TestClass, :marmalade, :class)
+        end
+      end
+
+      should "re-compile the given method with tail call optimization" do
+        # Exceed maximum available stack depth by 100 for good measure
+        factorial_seed = factorial_stack_buster_stack_depth_remaining + 100
+        assert_raises(SystemStackError) do
+          TestClass.class_factorial(factorial_seed)
+        end
+
+        subject.call(TestClass, :class_factorial, :class)
+        expected_result = iterative_factorial(factorial_seed)
+        assert_equal expected_result, TestClass.class_factorial(factorial_seed)
+      end
+    end
+
+    context "with instance method" do
+      should "raise NameError if no instance method with given name defined" do
+        assert_raises(NameError) do
+          subject.call(TestClass, :marmalade, :instance)
+        end
+      end
+
+      should "re-compile the given method with tail call optimization" do
+        # Exceed maximum available stack depth by 100 for good measure
+        factorial_seed = factorial_stack_buster_stack_depth_remaining + 100
+        assert_raises(SystemStackError) do
+          TestClass.new.instance_factorial(factorial_seed)
+        end
+
+        subject.call(TestClass, :instance_factorial, :instance)
+        expected_result = iterative_factorial(factorial_seed)
+        assert_equal expected_result, TestClass.new.instance_factorial(factorial_seed)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: tco_method
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Danny Guinther
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: method_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: Simplifies creating tail call optimized procs/lambdas/methods in Ruby.
+email:
+- dannyguinther@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/tco_method.rb
+- lib/tco_method/method_info.rb
+- lib/tco_method/mixin.rb
+- lib/tco_method/version.rb
+- tco_method.gemspec
+- test/test_helper.rb
+- test/test_helpers/factorial_stack_buster_helper.rb
+- test/test_helpers/stack_busters/factorial_stack_buster.rb
+- test/test_helpers/stack_busters/vanilla_stack_buster.rb
+- test/test_helpers/vanilla_stack_buster_helper.rb
+- test/test_helpers/vm_stack_helper.rb
+- test/unit/method_info_test.rb
+- test/unit/mixin_test.rb
+- test/unit/tco_method_test.rb
+homepage: https://github.com/tdg5/tco_method
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simplifies creating tail call optimized procs/lambdas/methods in Ruby.
+test_files:
+- test/test_helper.rb
+- test/test_helpers/factorial_stack_buster_helper.rb
+- test/test_helpers/stack_busters/factorial_stack_buster.rb
+- test/test_helpers/stack_busters/vanilla_stack_buster.rb
+- test/test_helpers/vanilla_stack_buster_helper.rb
+- test/test_helpers/vm_stack_helper.rb
+- test/unit/method_info_test.rb
+- test/unit/mixin_test.rb
+- test/unit/tco_method_test.rb
+has_rdoc: