tco_method 0.1.0 → 0.2.0

data/lib/tco_method/block_with_tco.rb

@@ -0,0 +1,22 @@
+require "tco_method/block_extractor"
+
+module TCOMethod
+  class BlockWithTCO
+    attr_reader :result
+
+    def initialize(&block)
+      raise ArgumentError, "Block required" unless block
+      @result = eval(block)
+    end
+
+    private
+
+    def extract_source(block)
+      BlockExtractor.new(block).source
+    end
+
+    def eval(block)
+      TCOMethod.tco_eval(extract_source(block)).call
+    end
+  end
+end

data/lib/tco_method/method_reevaluator.rb

@@ -0,0 +1,45 @@
+require "tco_method/method_info"
+
+module TCOMethod
+  class MethodReevaluator
+    # Reevaluates a method with tail call optimization enabled.
+    #
+    # @note This class 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.
+    # @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 initialize(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
+      receiver_class = receiver.is_a?(Class) ? :class : :module
+      code = <<-CODE
+        #{receiver_class} #{receiver.name}
+          #{existing_method.source}
+        end
+      CODE
+
+      file, line = existing_method.source_location
+      TCOMethod.tco_eval(code, file, File.dirname(file), line - 1)
+    end
+  end
+end

data/lib/tco_method/mixin.rb

@@ -1,3 +1,5 @@
+require "tco_method/method_reevaluator"
+
 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
@@ -11,9 +13,9 @@ module TCOMethod
     # @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
+    # @see TCOMethod::MethodReevaluator
     def tco_module_method(method_name)
-      TCOMethod.reevaluate_method_with_tco(self, method_name, :module)
+      MethodReevaluator.new(self, method_name, :module)
     end
     alias_method :tco_class_method, :tco_module_method
 
@@ -36,9 +38,23 @@ module TCOMethod
     # @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
+    # @see TCOMethod::MethodReevaluator
     def tco_method(method_name)
-      TCOMethod.reevaluate_method_with_tco(self, method_name, :instance)
+      MethodReevaluator.new(self, method_name, :instance)
+    end
+
+    # Allows for executing a block of code with tail call optimization enabled.
+    #
+    # All code that is evaluated in the block will be evaluated with tail call
+    # optimization enabled, however here be dragons, so make sure to read the
+    # docs for {TCOMethod.with_tco} before getting too crazy.
+    #
+    # @param [Proc] block The proc to evaluate with tail call optimization
+    #   enabled.
+    # @return [Object] Returns whatever the result of evaluating the given block.
+    # @see TCOMethod.with_tco
+    def with_tco(&block)
+      TCOMethod.with_tco(&block)
     end
   end
 end

data/lib/tco_method/version.rb

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

data/test/test_helper.rb

@@ -11,8 +11,8 @@ end
 require "minitest/autorun"
 require "mocha/setup"
 require "tco_method"
-
-require_relative "test_helpers/assertions"
+require "test_helpers/assertions"
+require "test_helpers/fibbers"
 
 # Use alternate shoulda-style DSL for tests
 class TCOMethod::TestCase < Minitest::Spec

data/test/test_helpers/fibbers.rb

@@ -0,0 +1,37 @@
+# A couple of test classes used for testing tail call optimization in various
+# contexts.
+module TCOMethod
+  test_subject_builder = proc do
+    extend TCOMethod::Mixin
+
+    class << self
+      define_method(:singleton_block_method) { }
+    end
+
+    # Equivalent to the below, but provides a target for verifying that
+    # tco_module_method works on Classes and tco_class_method works on Modules.
+    def self.module_fib_yielder(index, back_one = 1, back_two = 0, &block)
+      yield back_two if index > 0
+      index < 1 ? back_two : module_fib_yielder(index - 1, back_one + back_two, back_one, &block)
+    end
+
+    # Equivalent to the above, but provides a target for verifying that
+    # tco_module_method works on Classes and tco_class_method works on Modules.
+    def self.class_fib_yielder(index, back_one = 1, back_two = 0, &block)
+      yield back_two if index > 0
+      index < 1 ? back_two : class_fib_yielder(index - 1, back_one + back_two, back_one, &block)
+    end
+
+    define_method(:instance_block_method)  { }
+
+    # Equivalent to the above, but provides a target for verifying that
+    # instance methods work for both Classes and Modules
+    def instance_fib_yielder(index, back_one = 1, back_two = 0, &block)
+      yield back_two if index > 0
+      index < 1 ? back_two : instance_fib_yielder(index - 1, back_one + back_two, back_one, &block)
+    end
+  end
+
+  TestModule = Module.new(&test_subject_builder)
+  TestClass = Class.new(&test_subject_builder)
+end

data/test/unit/block_extractor_test.rb

@@ -0,0 +1,150 @@
+require "pry"
+require "test_helper"
+
+module TCOMethod
+  class BlockExtractorTest < TestCase
+    Subject = BlockExtractor
+    subject { Subject }
+
+    blocks = [
+      :lambda_brace_inline,
+      :lambda_brace_multi,
+      :lambda_do_inline,
+      :lambda_do_multi,
+      :method_brace_inline,
+      :method_brace_multi,
+      :method_do_inline,
+      :method_do_multi,
+      :proc_brace_inline,
+      :proc_brace_multi,
+      :proc_do_inline,
+      :proc_do_multi,
+    ]
+
+    unsourceable_blocks = [
+      :ambiguous_procs,
+      :a_hash_with_an_ambiguous_proc,
+      :an_ambiguous_proc_with_hash,
+      :an_unsourceable_proc,
+    ]
+
+    context "block extraction" do
+      blocks.each do |meth|
+        should "extract block in #{meth} form" do
+          block = send(meth)
+          block_source = subject.new(block).source
+          reblock = eval(block_source)
+          reblock_result = reblock.call
+
+          # Ensure both blocks return the same result
+          assert_equal block.call, reblock_result
+
+          # Ensure a lambda is used where appropriate
+          assert_equal reblock_result == :lambda, reblock.lambda?
+        end
+      end
+
+      unsourceable_blocks.each do |meth|
+        should "raise when given a #{meth}" do
+          block = send(meth)
+          assert_raises(AmbiguousSourceError) { subject.new(block).source }
+        end
+      end
+
+      should "correctly strip trailing code at the end of the block" do
+        # The ').source' below should be plenty to test this concern.
+        block_source = subject.new(lambda do
+          "Hold on to your butts"
+        end).source
+        begin
+          eval(block_source)
+        rescue SyntaxError
+          assert false, "Syntax error in block source"
+        end
+      end
+    end
+
+    # This ambiguity could be handled, but encourages poorly formatted code and
+    # doesn't seem worth the effort presently.
+    def a_hash_with_an_ambiguous_proc
+      {}; proc { :proc }
+    end
+
+    def ambiguous_procs
+      proc { :please }; proc { :dont_do_this }
+    end
+
+    def an_unsourceable_proc
+      {
+        :block => proc { :method_source_error }
+      }[:block]
+    end
+
+    # This ambiguity could be handled, but encourages poorly formatted code and
+    # doesn't seem worth the effort presently.
+    def an_ambiguous_proc_with_hash
+      block = proc { :proc }; {}
+      block
+    end
+
+    def lambda_brace_inline
+      lambda { :lambda }
+    end
+
+    def lambda_brace_multi
+      lambda {
+        :lambda
+      }
+    end
+
+    def lambda_do_inline
+      lambda do; :lambda; end
+    end
+
+    def lambda_do_multi
+      lambda do
+        :lambda
+      end
+    end
+
+    def method_brace_inline
+      Proc.new { :proc }
+    end
+
+    def method_brace_multi
+      Proc.new {
+        :proc
+      }
+    end
+
+    def method_do_inline
+      Proc.new do; :proc; end
+    end
+
+    def method_do_multi
+      Proc.new do
+        :proc
+      end
+    end
+
+    def proc_do_inline
+      proc do; :proc; end
+    end
+
+    def proc_do_multi
+      proc do
+        :proc
+      end
+    end
+
+    def proc_brace_inline
+      proc { :proc }
+    end
+
+    def proc_brace_multi
+      proc {
+        :proc
+      }
+    end
+  end
+end

data/test/unit/block_with_tco_test.rb

@@ -0,0 +1,53 @@
+require "test_helper"
+
+module TCOMethod
+  class BlockWithTCOTest < TestCase
+    include TCOMethod::TestHelpers::Assertions
+
+    Subject = BlockWithTCO
+
+    context "::with_tco" do
+      subject { Subject }
+
+      should "raise ArgumentError if a block is not given" do
+        exception = assert_raises(ArgumentError) { subject.new }
+        assert_match(/block required/i, exception.message)
+      end
+
+      # It would be nice if it could evaluate the block with the same binding, but
+      # I haven't been able to find a way to make that work.
+      should "evaluate the provided block with a different binding" do
+        some_variable = "Hello, world!"
+        assert_raises(NameError) do
+          subject.new { some_variable }
+        end
+      end
+
+      should "work with a proc in block form" do
+        tco_block = subject.new do
+          "Hello, world!"
+        end
+        assert_equal "Hello, world!", tco_block.result
+      end
+
+      should "work with a proc in curly-brace form" do
+        tco_block = subject.new { "Hello, world!" }
+        assert_equal "Hello, world!", tco_block.result
+      end
+
+      should "be tail call optimized" do
+        subject.new do
+          class ::TCOTester
+            def fib_yielder(index, back_one = 1, back_two = 0, &block)
+              index > 0 ? yield(back_two) : (return back_two)
+              fib_yielder(index - 1, back_one + back_two, back_one, &block)
+            end
+          end
+        end
+
+        meth = ::TCOTester.new.method(:fib_yielder)
+        assert_equal true, tail_call_optimized?(meth, 5)
+      end
+    end
+  end
+end

data/test/unit/method_reevaluator_test.rb

@@ -0,0 +1,112 @@
+require "test_helper"
+
+module TCOMethod
+  class MethodReevaluatorTest < TestCase
+    include TCOMethod::TestHelpers::Assertions
+
+    Subject = MethodReevaluator
+
+    context "#initialize" do
+      subject { Subject.method(:new) }
+
+      [TestClass, TestModule].each do |method_owner|
+        method_owner_class = method_owner.class.name.downcase.to_sym
+
+        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(method_owner, nil, :instance)
+            end
+          end
+
+          should "raise ArgumentError unless method owner given" do
+            assert_raises(ArgumentError) do
+              subject.call(method_owner, :class_factorial, nil)
+            end
+          end
+
+          should "raise TypeError for block methods" do
+            assert_raises(TypeError) do
+              subject.call(method_owner, :singleton_block_method, :class)
+            end
+            assert_raises(TypeError) do
+              subject.call(method_owner, :instance_block_method, :instance)
+            end
+          end
+        end
+
+        context "#{method_owner_class} receiver" do
+          context "with module method" do
+            should "raise NameError if no #{method_owner_class} method with given name defined" do
+              assert_raises(NameError) do
+                subject.call(method_owner, :marmalade, method_owner_class)
+              end
+            end
+
+            should "re-compile the given method with tail call optimization" do
+              fib_yielder = method_owner.method(:module_fib_yielder)
+              refute tail_call_optimized?(fib_yielder, 5)
+
+              subject.call(method_owner, :module_fib_yielder, :module)
+              tco_fib_yielder = method_owner.method(:module_fib_yielder)
+              assert tail_call_optimized?(tco_fib_yielder, 5)
+
+              assert_equal fib_yielder.source_location, tco_fib_yielder.source_location
+            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(method_owner, :marmalade, :class)
+              end
+            end
+
+            should "re-compile the given method with tail call optimization" do
+              fib_yielder = method_owner.method(:class_fib_yielder)
+              refute tail_call_optimized?(fib_yielder, 5)
+
+              subject.call(method_owner, :class_fib_yielder, :module)
+              tco_fib_yielder = method_owner.method(:class_fib_yielder)
+              assert tail_call_optimized?(tco_fib_yielder, 5)
+
+              assert_equal fib_yielder.source_location, tco_fib_yielder.source_location
+            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(method_owner, :marmalade, :instance)
+              end
+            end
+
+            should "re-compile the given method with tail call optimization" do
+              instance_class = instance_class_for_receiver(method_owner)
+
+              fib_yielder = instance_class.new.method(:instance_fib_yielder)
+              refute tail_call_optimized?(fib_yielder, 5)
+
+              subject.call(method_owner, :instance_fib_yielder, :instance)
+              tco_fib_yielder = instance_class.new.method(:instance_fib_yielder)
+              assert tail_call_optimized?(tco_fib_yielder, 5)
+
+              assert_equal fib_yielder.source_location, tco_fib_yielder.source_location
+            end
+          end
+        end
+      end
+    end
+
+    def instance_class_for_receiver(receiver)
+      return receiver if receiver.is_a?(Class)
+      Class.new { include receiver }
+    end
+  end
+end