tco_method 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11960ee06eb5b374d740739ce2c713ac378614a7
-  data.tar.gz: 1f745c27ee5c95ab29a04e9880167f3d57ba3083
+  metadata.gz: 5b38db19eea395f824f107cdf26128b24f4a0de7
+  data.tar.gz: 061f302f00571f8d3290b2c33deb15c8e3e12c85
 SHA512:
-  metadata.gz: ada2e8cd1fc60a513afe1d8b41648af9ad8d7c180671f952569f1b39d6913fde93be9a91dec4456d7de48706c08503b87aded56e0056f3f5d3d1f58356b60de6
-  data.tar.gz: 26ff23af6d83115e64012b09e2d7c00dc2632a9aed6d280a7dec52c4ab5f225d415a73562e360ce7f78fc7ad8b8ffa585d7ef86ec120d9bddb26227b8bd6d0d9
+  metadata.gz: 5582d4e9e64fc235526dc5c5504ad041e1736252f9017c45934990f0bbd8c005327dc12ecad192373a1cce42a00e76209b5abff4038248170105860b79222987
+  data.tar.gz: 8e38fa82f97b0cb9f60678ef5342f59f7c7042ed5cd4104f90b49a66cb82de4e9c6571cd36aaa9ea8695d2f3c4d885c718794372c19a8f15bd5f7a0e21d7503f

data/lib/tco_method/version.rb

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

data/lib/tco_method.rb

@@ -53,7 +53,9 @@ module TCOMethod
         #{existing_method.source}
       end
     CODE
-    tco_eval(code)
+
+    file, line = existing_method.source_location
+    tco_eval(code, file, File.dirname(file), line - 1)
     method_name.to_sym
   end
 
@@ -65,8 +67,8 @@ module TCOMethod
   # @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)
+  def self.tco_eval(code, file = nil, path = nil, line = nil)
     raise ArgumentError, "Invalid code string!" unless code.is_a?(String)
-    RubyVM::InstructionSequence.new(code, nil, nil, nil, ISEQ_OPTIONS).eval
+    RubyVM::InstructionSequence.new(code, file, path, line, ISEQ_OPTIONS).eval
   end
 end

data/test/test_helper.rb

@@ -12,9 +12,7 @@ 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"
+require_relative "test_helpers/assertions"
 
 # Use alternate shoulda-style DSL for tests
 class TCOMethod::TestCase < Minitest::Spec

data/test/test_helpers/assertions.rb

@@ -0,0 +1,28 @@
+module TCOMethod
+  module TestHelpers
+    module Assertions
+      def assert_tail_call_optimized(method, *args)
+        is_tco = tail_call_optimized(method, *args)
+        msg = "Expected method #{method.name} to be tail call optimized"
+        assert is_tco, msg
+      end
+
+      def refute_tail_call_optimized(method, *args)
+        is_tco = tail_call_optimized(method, *args)
+        msg = "Expected method #{method.name} not to be tail call optimized"
+        refute is_tco, msg
+      end
+
+      def tail_call_optimized?(method, *args)
+        initial_length = nil
+        method.call(*args) do
+          if initial_length.nil?
+            initial_length = caller.length
+          else
+            break initial_length == caller.length
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/mixin_test.rb

@@ -1,8 +1,6 @@
 require "test_helper"
 
 class MixinTest < TCOMethod::TestCase
-  include TCOMethod::TestHelpers::FactorialStackBusterHelper
-
   TestClass = Class.new { extend TCOMethod::Mixin }
   TestModule = Module.new { extend TCOMethod::Mixin }
 

data/test/unit/tco_method_test.rb

@@ -1,7 +1,7 @@
 require "test_helper"
 
 class TCOMethodTest < TCOMethod::TestCase
-  include TCOMethod::TestHelpers::FactorialStackBusterHelper
+  include TCOMethod::TestHelpers::Assertions
 
   Subject = TCOMethod
 
@@ -14,26 +14,34 @@ class TCOMethodTest < TCOMethod::TestCase
 
     # 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_factorial(n, acc = 1)
-      n <= 1 ? acc : module_factorial(n - 1, n * acc)
+    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_factorial(n, acc = 1)
-      n <= 1 ? acc : class_factorial(n - 1, n * acc)
+    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)  { }
 
-    def instance_factorial(n, acc = 1)
-      n <= 1 ? acc : instance_factorial(n - 1, n * acc)
+    # 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
@@ -57,21 +65,15 @@ class TCOMethodTest < TCOMethod::TestCase
     end
 
     should "compile the given code with tail call optimization" do
-      FactorialEvalDummy = dummy_class = Class.new
+      EvalDummy = 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
+          #{InstanceFibYielderSource}
         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)
+      fib_yielder = dummy_class.new.method(:instance_fib_yielder)
+      assert tail_call_optimized?(fib_yielder, 5)
     end
   end
 
@@ -119,15 +121,14 @@ class TCOMethodTest < TCOMethod::TestCase
           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
-              method_owner.module_factorial(factorial_seed)
-            end
+            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)
 
-            subject.call(method_owner, :module_factorial, :module)
-            expected_result = iterative_factorial(factorial_seed)
-            assert_equal expected_result, method_owner.module_factorial(factorial_seed)
+            assert_equal fib_yielder.source_location, tco_fib_yielder.source_location
           end
         end
 
@@ -139,15 +140,14 @@ class TCOMethodTest < TCOMethod::TestCase
           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
-              method_owner.class_factorial(factorial_seed)
-            end
+            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)
 
-            subject.call(method_owner, :class_factorial, method_owner_class)
-            expected_result = iterative_factorial(factorial_seed)
-            assert_equal expected_result, method_owner.class_factorial(factorial_seed)
+            assert_equal fib_yielder.source_location, tco_fib_yielder.source_location
           end
         end
 
@@ -159,16 +159,16 @@ class TCOMethodTest < TCOMethod::TestCase
           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
             instance_class = instance_class_for_receiver(method_owner)
-            assert_raises(SystemStackError) do
-              instance_class.new.instance_factorial(factorial_seed)
-            end
 
-            subject.call(method_owner, :instance_factorial, :instance)
-            expected_result = iterative_factorial(factorial_seed)
-            assert_equal expected_result, instance_class.new.instance_factorial(factorial_seed)
+            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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tco_method
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Danny Guinther
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-14 00:00:00.000000000 Z
+date: 2015-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source
@@ -72,11 +72,7 @@ files:
 - 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/test_helpers/assertions.rb
 - test/unit/method_info_test.rb
 - test/unit/mixin_test.rb
 - test/unit/tco_method_test.rb
@@ -106,11 +102,7 @@ specification_version: 4
 summary: Simplifies compiling code with tail call optimization in MRI 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/test_helpers/assertions.rb
 - test/unit/method_info_test.rb
 - test/unit/mixin_test.rb
 - test/unit/tco_method_test.rb

data/test/test_helpers/factorial_stack_buster_helper.rb

@@ -1,31 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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