tco_method 0.1.0 → 0.2.0

data/test/unit/mixin_test.rb

@@ -1,66 +1,86 @@
 require "test_helper"
 
-class MixinTest < TCOMethod::TestCase
-  TestClass = Class.new { extend TCOMethod::Mixin }
-  TestModule = Module.new { extend TCOMethod::Mixin }
+module TCOMethod
+  class MixinTest < TCOMethod::TestCase
+    TestClass = Class.new { extend TCOMethod::Mixin }
+    TestModule = Module.new { extend TCOMethod::Mixin }
 
 
-  context "Module extensions" do
-    subject { TestModule }
+    context "Module extensions" do
+      subject { TestModule }
 
-    context "#tco_module_method" do
-      should "call TCOMethod.reevaluate_method_with_tco with expected arguments" do
-        method_name = :some_method
-        args = [subject, method_name, :module]
-        TCOMethod.expects(:reevaluate_method_with_tco).with(*args)
-        subject.tco_module_method(method_name)
+      context "#tco_module_method" do
+        should "call MethodReevaluator#new with expected arguments" do
+          method_name = :some_method
+          args = [subject, method_name, :module]
+          MethodReevaluator.expects(:new).with(*args)
+          subject.tco_module_method(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)
+      context "#tco_method" do
+        should "call MethodReevaluator#new with expected arguments" do
+          method_name = :some_method
+          args = [subject, method_name, :instance]
+          MethodReevaluator.expects(:new).with(*args)
+          subject.tco_method(method_name)
+        end
       end
-    end
 
-    context "#tco_method" do
-      should "call TCOMethod.reevaluate_method_with_tco with expected arguments" do
-        method_name = :some_method
-        args = [subject, method_name, :instance]
-        TCOMethod.expects(:reevaluate_method_with_tco).with(*args)
-        subject.tco_method(method_name)
+      context "#tco_eval" do
+        should "call TCOMethod.tco_eval with expected arguments" do
+          code = "some_code"
+          TCOMethod.expects(:tco_eval).with(code)
+          subject.tco_eval(code)
+        end
       end
-    end
-  end
 
-  context "Class extensions" do
-    subject { TestClass }
+      context "#with_tco" do
+        should "call TCOMethod.with_tco with the given block" do
+          # Mocha doesn't offer a good way for sensing passed blocks, so run
+          # through the process twice, once with a stub, once without.
+
+          # Stubbed
+          TCOMethod.expects(:with_tco).returns(true)
+          assert_equal true, subject.with_tco { }
 
-    context "#tco_class_method" do
-      should "call TCOMethod.reevaluate_method_with_tco with expected arguments" do
-        method_name = :some_method
-        args = [subject, method_name, :module]
-        TCOMethod.expects(:reevaluate_method_with_tco).with(*args)
-        subject.tco_class_method(method_name)
+          # Now unstubbed to make sure the expected block is invoked.
+          TCOMethod.unstub(:with_tco)
+
+          # Must use some sort of global for sensing side effects because the
+          # block given to with_tco is called with a different binding than the
+          # one used here.
+          module ::WithTCOSensor
+            def self.call; @called = true; end
+            def self.called?; !!@called; end
+          end
+
+          result = subject.with_tco { ::WithTCOSensor.call; ::WithTCOSensor }
+          assert_equal true, ::WithTCOSensor.called?
+          assert_equal ::WithTCOSensor, result
+        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)
+    context "Class extensions" do
+      subject { TestClass }
+
+      context "#tco_class_method" do
+        should "call MethodReevaluator#new with expected arguments" do
+          method_name = :some_method
+          args = [subject, method_name, :module]
+          MethodReevaluator.expects(:new).with(*args)
+          subject.tco_class_method(method_name)
+        end
       end
-    end
 
-    context "#tco_method" do
-      should "call TCOMethod.reevaluate_method_with_tco with expected arguments" do
-        method_name = :some_method
-        args = [subject, method_name, :instance]
-        TCOMethod.expects(:reevaluate_method_with_tco).with(*args)
-        subject.tco_method(method_name)
+      context "#tco_method" do
+        should "call MethodReevaluator#new with expected arguments" do
+          method_name = :some_method
+          args = [subject, method_name, :instance]
+          MethodReevaluator.expects(:new).with(*args)
+          subject.tco_method(method_name)
+        end
       end
     end
   end

data/test/unit/tco_method_test.rb

@@ -1,182 +1,68 @@
 require "test_helper"
 
-class TCOMethodTest < TCOMethod::TestCase
-  include TCOMethod::TestHelpers::Assertions
+module TCOMethod
+  class TCOMethodTest < TCOMethod::TestCase
+    include TCOMethod::TestHelpers::Assertions
 
-  Subject = TCOMethod
+    Subject = TCOMethod
 
-  test_subject_builder = proc do
-    extend TCOMethod::Mixin
+    # Grab source before it's recompiled for use later
+    InstanceFibYielderSource = TestClass.instance_method(:instance_fib_yielder).source
 
-    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)
-
-  # Grab source before it's recompiled for use later
-  InstanceFibYielderSource = TestClass.instance_method(:instance_fib_yielder).source
-
-  subject { Subject }
-
-  context Subject.name do
-    should "be defined" do
-      assert defined?(subject), "Expected #{subject.name} to be defined!"
-    end
-  end
+    subject { Subject }
 
-  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
+    context Subject.name do
+      should "be defined" do
+        assert defined?(subject), "Expected #{subject.name} to be defined!"
       end
     end
 
-    should "compile the given code with tail call optimization" do
-      EvalDummy = dummy_class = Class.new
-      subject.tco_eval(<<-CODE)
-        class #{dummy_class.name}
-          #{InstanceFibYielderSource}
-        end
-      CODE
-
-      fib_yielder = dummy_class.new.method(:instance_fib_yielder)
-      assert tail_call_optimized?(fib_yielder, 5)
-    end
-  end
-
-  context "::reevaluate_method_with_tco" do
-    subject { Subject.method(:reevaluate_method_with_tco) }
-
-    [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
+    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.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)
+            subject.tco_eval(non_code)
           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
+      should "compile the given code with tail call optimization" do
+        EvalDummy = dummy_class = Class.new
+        subject.tco_eval(<<-CODE)
+          class #{dummy_class.name}
+            #{InstanceFibYielderSource}
           end
+        CODE
 
-          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)
+        fib_yielder = dummy_class.new.method(:instance_fib_yielder)
+        assert tail_call_optimized?(fib_yielder, 5)
+      end
+    end
 
-            assert_equal fib_yielder.source_location, tco_fib_yielder.source_location
-          end
-        end
+    context "::with_tco" do
+      should "raise ArgumentError if a block is not given" do
+        exception = assert_raises(ArgumentError) { subject.with_tco }
+        assert_match(/block required/i, exception.message)
+      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)
+      should "compile the given code with tail call optimization" do
+        subject.with_tco do
+          class WithTCODummy
+            def countdown(count, &block)
+              yield count
+              count.zero? ? 0 : countdown(count - 1, &block)
             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
+        meth = WithTCODummy.new.method(:countdown)
+        assert tail_call_optimized?(meth, 5)
       end
     end
   end
-
-  def instance_class_for_receiver(receiver)
-    return receiver if receiver.is_a?(Class)
-    Class.new { include receiver }
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tco_method
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Danny Guinther
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-12 00:00:00.000000000 Z
+date: 2015-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source
@@ -67,13 +67,21 @@ files:
 - README.md
 - Rakefile
 - lib/tco_method.rb
+- lib/tco_method/ambiguous_source_error.rb
+- lib/tco_method/block_extractor.rb
+- lib/tco_method/block_with_tco.rb
 - lib/tco_method/method_info.rb
+- lib/tco_method/method_reevaluator.rb
 - lib/tco_method/mixin.rb
 - lib/tco_method/version.rb
 - tco_method.gemspec
 - test/test_helper.rb
 - test/test_helpers/assertions.rb
+- test/test_helpers/fibbers.rb
+- test/unit/block_extractor_test.rb
+- test/unit/block_with_tco_test.rb
 - test/unit/method_info_test.rb
+- test/unit/method_reevaluator_test.rb
 - test/unit/mixin_test.rb
 - test/unit/tco_method_test.rb
 homepage: https://github.com/tdg5/tco_method
@@ -96,14 +104,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Simplifies compiling code with tail call optimization in MRI Ruby.
 test_files:
 - test/test_helper.rb
 - test/test_helpers/assertions.rb
+- test/test_helpers/fibbers.rb
+- test/unit/block_extractor_test.rb
+- test/unit/block_with_tco_test.rb
 - test/unit/method_info_test.rb
+- test/unit/method_reevaluator_test.rb
 - test/unit/mixin_test.rb
 - test/unit/tco_method_test.rb
 has_rdoc: