computable 0.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9d62c2956d0f777bd65d7fc308e035505a1a1912
-  data.tar.gz: d18de2360da33738fe19adee655774055472825e
+SHA256:
+  metadata.gz: ec5682e86b9081039947fc2718c8cdc42d2407af8cb0da30244a41b994d917f5
+  data.tar.gz: f8471eed0b3144951e4bb834e63013339e1af67842278e1bac7368c82070e76d
 SHA512:
-  metadata.gz: d18be4067d65ea266bcc2d461a595e50392af48686f48145c4578107cc1a84bf6a2255b1cfc0b3aaf999d9f6cd4947d88f7359f49791b9b990f0479cae331225
-  data.tar.gz: 0aabd0dac09732d5a000c68c051173cd4f1eb8485603e03d469d6568221eda485512e2974c95e536879a3926a430b805f52d96b45ea4742dbfc619e9727b758b
+  metadata.gz: 9be1797f3865b5ed1f0cbf6b98c3a8ceca6342b689212a801e55e2ad1e3499618a1439746744260d719bda4e9895c0ff080b2a2e43a971414f06f18a60f9cb33
+  data.tar.gz: b3852ade5823458ff7a5da0e6e89416c3c9edd326fa3466781ad52cdf876aaa8ee032949b98a52b6646f37b8b8d7256a57ff41d1a5c01c041be4b53b88738232

data/.github/workflows/ci.yml

@@ -0,0 +1,44 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  job_test:
+    name: CI
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows
+            ruby: "head"
+          - os: ubuntu
+            ruby: "head"
+          - os: ubuntu
+            ruby: "3.1"
+          - os: ubuntu
+            ruby: "2.5"
+          - os: ubuntu
+            ruby: "truffleruby"
+            NO_TIMING_TESTS: true
+          - os: ubuntu
+            ruby: "jruby"
+          - os: macos
+            ruby: "head"
+            NO_TIMING_TESTS: true
+
+    runs-on: ${{ matrix.os }}-latest
+    env:
+      NO_TIMING_TESTS: ${{ matrix.NO_TIMING_TESTS }}
+
+    steps:
+
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+
+      - run: bundle install
+
+      - name: Run tests
+        run: bundle exec rake test

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "2.4"
+  - "3.1"
+script: bundle exec rake test

data/README.md

@@ -1,3 +1,6 @@
+[![Build Status Github Actions](https://github.com/larskanis/computable/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/larskanis/computable/actions/workflows/ci.yml)
+[![Build Status Travis CI](https://app.travis-ci.com/larskanis/computable.svg?branch=master)](https://app.travis-ci.com/larskanis/computable)
+
 # Computable
 
 TODO: Write a gem description

data/Rakefile

@@ -3,5 +3,5 @@ require "bundler/gem_tasks"
 task :gem => :build
 
 task :test do
-  sh "ruby -w -W2 -I. -Ilib -e \"#{Dir["test/test_*.rb"].map{|f| "require '#{f}';"}.join}\" -- -v"
+  sh "ruby -w -W2 -I. -Ilib -e \"#{Dir["test/test_*.rb"].map{|f| "require '#{f}';"}.join}\" -- -v #{ENV["TESTOPT"]}"
 end

data/computable.gemspec

@@ -12,12 +12,14 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Define computation tasks with automatic caching and dependency tracking.}
   spec.homepage      = "https://github.com/larskanis/computable"
   spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.4"
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.4"
+  spec.add_development_dependency "bundler", ">= 1.4", "< 3.0"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest", "~> 5.6"
 end

data/lib/computable/version.rb

@@ -1,3 +1,3 @@
 class Computable
-  VERSION = "0.1.0"
+  VERSION = "1.1.1"
 end

data/lib/computable.rb

@@ -16,29 +16,41 @@ class Computable
   end
 
   class Variable
-    attr_accessor :name, :calc_method, :used_for, :expired_from, :value, :value_calced, :count
-    def initialize(name, calc_method)
+    attr_accessor :name, :calc_method, :used_for, :expired_from, :value, :value_calced, :count, :in_process, :recalc_error
+
+    def initialize(name, calc_method, comp, mutex)
       @name = name
       @calc_method = calc_method
+      @comp = comp
+      @mutex = mutex
       @used_for = {}
       @expired_from = {}
       @count = 0
       @value = Unknown
+      @in_process = false
+      @recalc_error = nil
     end
 
     def inspect
-      "<Variable #{name} used_for:#{used_for.keys} expired_from:#{expired_from.keys} has value:#{value==Unknown} value_calced:#{value_calced.inspect}>"
+      has = @recalc_error ? "error!" : "value:#{Unknown!=value}"
+      "<Variable #{name} used_for:#{used_for.keys} expired_from:#{expired_from.keys} has #{has} value_calced:#{value_calced.inspect}>"
     end
 
     def calc!
       self.count += 1
-      calc_method.call(self)
+      self.value_calced = true
+      @mutex.unlock
+      begin
+        calc_method.call(self)
+      ensure
+        @mutex.lock
+      end
     end
 
     def expire_value
       return if used_for.empty?
 
-      puts "expire #{inspect}" if Computable.computable_debug
+      puts "expire #{inspect}" if @comp.computable_debug
       used_for.each do |name2, v2|
         if v2.value_calced && !v2.expired_from[name]
           v2.expire_value
@@ -50,7 +62,7 @@ class Computable
     def revoke_expire
       return if used_for.empty?
 
-      puts "revoke expire #{inspect}" if Computable.computable_debug
+      puts "revoke expire #{inspect}" if @comp.computable_debug
       used_for.each do |name2, v2|
         if v2.value_calced && v2.expired_from.delete(name) && v2.expired_from.empty?
           v2.revoke_expire
@@ -58,49 +70,177 @@ class Computable
       end
     end
 
+    def process_recalced_value(recalced_value, err)
+      if err
+        self.recalc_error = err
+        self.value = Unknown
+        used_for.clear
+      elsif self.value == recalced_value
+        revoke_expire
+      else
+        self.recalc_error = nil
+        self.value = recalced_value
+        used_for.clear
+      end
+      expired_from.clear
+    end
+
     def recalc_value
       return if !value_calced || expired_from.empty?
 
-      puts "recalc #{inspect}" if Computable.computable_debug
+      puts "recalc #{inspect}" if @comp.computable_debug
       expired_from.each do |name2, v2|
         v2.recalc_value
       end
 
       unless expired_from.empty?
-        recalced_value = self.calc!
-        if self.value == recalced_value
-          revoke_expire
+        begin
+          recalced_value = self.calc!
+        rescue Exception => err
+        end
+        process_recalced_value(recalced_value, err)
+      end
+    end
+
+    def new_worker(from_workers, to_workers)
+      Thread.new do
+        while v = to_workers.pop
+          puts "recalc parallel #{v.inspect}" if @comp.computable_debug
+          err = nil
+          begin
+            recalced_value = v.calc_method.call(v)
+          rescue Exception => err
+          end
+          from_workers.push([v, recalced_value, err])
+        end
+      end
+    end
+
+    def recalc_parallel(max_threads)
+      workers = []
+      from_workers = Queue.new
+      to_workers = Queue.new
+
+      master_loop(max_threads, workers, from_workers, to_workers)
+
+      to_workers.close
+      workers.each { |t| t.join }
+    end
+
+    def master_loop(max_threads, workers, from_workers, to_workers)
+      num_working = 0
+      loop do
+        if num_working == max_threads || !(node = find_recalcable)
+          #
+          # maxed out or no nodes available -- wait for results
+          #
+          return if num_working == 0
+
+          puts "recalc join" if @comp.computable_debug
+          @mutex.unlock
+          begin
+            node, recalced_value, err = from_workers.pop
+          ensure
+            @mutex.lock
+          end
+          node.in_process = false
+          num_working -= 1
+
+          if err
+            # Add the backtrace of the caller to the small in-thread backtrace for better debugging
+            err.set_backtrace(err.backtrace + caller)
+          end
+
+          node.process_recalced_value(recalced_value, err)
         else
-          self.value = recalced_value
-          used_for.clear
+          #
+          # not maxed out and found a node -- compute it
+          #
+          if (max_threads && workers.size < max_threads) ||
+             (!max_threads && num_working == workers.size)
+            workers << new_worker(from_workers, to_workers)
+          end
+          node.in_process = true
+          node.count += 1
+          node.value_calced = true
+          num_working += 1
+          to_workers.push(node)
+        end
+      end
+    end
+
+    def find_recalcable
+      if !value_calced || expired_from.empty? || in_process
+        nil
+      elsif expired_from.all?{ |_, v2| !v2.value_calced || v2.expired_from.empty? }
+        self
+      else
+        expired_from.each do |_, v2|
+          node = v2.find_recalcable and return node
         end
+        nil
+      end
+    end
+
+    def assign_value(value)
+      unless self.value == value
+        expire_value
         expired_from.clear
+        used_for.clear
+        self.value = value
+      end
+      self.value_calced = false
+    end
+
+    def query_value(kaller)
+      if kaller
+        v2 = used_for[kaller.name]
+        if v2
+          if Unknown==value && Unknown==v2.value && value_calced && v2.value_calced
+            raise RecursionDetected, "#{v2.name} depends on #{name}, but #{name} could not be computed without #{v2.name}"
+          end
+        else
+          used_for[kaller.name] = kaller
+        end
+      end
+
+      max_threads = @comp.computable_max_threads
+      if !max_threads || max_threads > 0
+        recalc_parallel(max_threads)
+      else
+        recalc_value
       end
+
+      raise recalc_error if recalc_error
+      self.value = calc! if Unknown==value
+      self.value
     end
   end
 
-  @@debug = false
-  def self.computable_debug=(v)
-    @@debug = v
+  def computable_debug=(v)
+    @computable_debug = v
+  end
+  def computable_debug
+    @computable_debug
+  end
+
+  def computable_max_threads=(v)
+    @computable_max_threads = v
   end
-  def self.computable_debug
-    @@debug
+  def computable_max_threads
+    @computable_max_threads
   end
 
-  def computable_display_dot(params={})
+  def computable_display_dot(**kwargs)
     IO.popen("dot -Tpng | display -", "w") do |fd|
-      fd.puts computable_to_dot(params)
+      fd.puts computable_to_dot(**kwargs)
     end
   end
 
-  def computable_to_dot(params={})
-    rankdir = params.delete(:rankdir){ "TB" }
-    multiline = params.delete(:multiline){ true }
-    raise ArgumentError, "invalid params #{params.inspect}" unless params.empty?
-
+  def computable_to_dot(rankdir: "TB", multiline: true)
     dot = "digraph #{self.class.name.inspect} {\n"
     dot << "graph [ dpi = 45, rankdir=#{rankdir} ];\n"
-    @variables.each do |name, v|
+    @computable_variables.each do |name, v|
       col = case
         when !v.value_calced then "color = red,"
         when !v.used_for.empty? then "color = green,"
@@ -120,82 +260,78 @@ class Computable
   end
 
   def initialize
-    @variables = {}
-    @caller = nil
+    @computable_debug = false
+    @computable_max_threads = 0
+    @computable_variables = {}
+    @computable_caller = nil
+    @computable_mutex = Mutex.new
   end
 
 
   def self.verify_format(name, value, format)
-    if format && value!=Unknown && !(format === value)
+    if format && !(Unknown==value) && !(format === value)
       raise InvalidFormat, "variable '#{name}': value #{value.inspect} is not in format #{format.inspect}"
     end
   end
 
-  def self.calc_value name, format=nil, params={}, &block
-    freeze = params.delete(:freeze){ true }
-    raise ArgumentError, "invalid params #{params.inspect}" unless params.empty?
+  private def improve_backtrace(err, block, text)
+    fpath, lineno = block.source_location
+    bt = err.backtrace
+    myloc = err.backtrace_locations.select.with_index{|loc, i| loc.path == fpath && loc.lineno >= lineno && !bt[i].include?("#") }.min{|a,b| a.lineno <=> b.lineno }
+    idx = err.backtrace_locations.index(myloc)
+    bt[idx] += " ##{text}"
+    raise err
+  end
 
+  def self.calc_value name, format=nil, freeze: true, &block
     calc_method_id = "calc_#{name}".intern
     define_method(calc_method_id, &block)
 
     calc_method2_id = "calc_#{name}_with_tracking".intern
     define_method(calc_method2_id) do |v|
+      old_caller = Thread.current.thread_variable_get("Computable #{object_id}")
+      Thread.current.thread_variable_set("Computable #{self.object_id}", v)
       begin
-        v.value_calced = true
-        @caller, old_caller = v, @caller
+        puts "do calc #{v.inspect}" if @computable_debug
         begin
-          puts "do calc #{v.inspect}" if @@debug
           res = send(calc_method_id)
-          Computable.verify_format(name, res, format)
-          res.freeze if freeze
-          res
-        ensure
-          @caller = old_caller
+        rescue Exception => err
+          improve_backtrace(err, block, name)
         end
+        Computable.verify_format(name, res, format)
+        res.freeze if freeze
+        res
+      ensure
+        Thread.current.thread_variable_set("Computable #{self.object_id}", old_caller)
       end
     end
 
     define_method("#{name}=") do |value|
       Computable.verify_format(name, value, format)
-      v = @variables[name]
-      puts "set #{name}: #{value.inspect} #{v.inspect}" if @@debug
-      v = @variables[name] = Variable.new(name, method(calc_method2_id)) unless v
-
-      unless v.value == value
-        v.expire_value
-        v.expired_from.clear
-        v.used_for.clear
+      @computable_mutex.synchronize do
+        v = @computable_variables[name]
+        puts "set #{name}: #{value.inspect} #{v.inspect}" if @computable_debug
+        v = @computable_variables[name] = Variable.new(name, method(calc_method2_id), self, @computable_mutex) unless v
+
         value.freeze if freeze
-        v.value = value
+        v.assign_value(value)
       end
-      v.value_calced = false
     end
 
     define_method(name) do
-      v = @variables[name]
-      puts "called #{name} #{v.inspect}" if @@debug
-      v = @variables[name] = Variable.new(name, method(calc_method2_id)) unless v
+      @computable_mutex.synchronize do
+        v = @computable_variables[name]
+        puts "called #{name} #{v.inspect}" if @computable_debug
+        v = @computable_variables[name] = Variable.new(name, method(calc_method2_id), self, @computable_mutex) unless v
 
-      if @caller
-        v2 = v.used_for[@caller.name]
-        if v2
-          if v.value==Unknown && v2.value==Unknown && v.value_calced && v2.value_calced
-            raise RecursionDetected, "#{v2.name} depends on #{name}, but #{name} could not be computed without #{v2.name}"
-          end
-        else
-          v.used_for[@caller.name] = @caller
-        end
+        kaller = Thread.current.thread_variable_get("Computable #{object_id}")
+        v.query_value(kaller)
       end
-
-      v.recalc_value
-
-      v.value = v.calc! if v.value==Unknown
-      v.value
     end
   end
 
-  def self.input_value name, format=nil, params={}
-    calc_value name, format, params do
+  def self.input_value name, format=nil, **kwargs
+    calc_value name, format, **kwargs do
       raise UndefinedValue, "input variable '#{name}' is not assigned"
     end
   end

data/test/helper.rb

@@ -0,0 +1,16 @@
+require 'minitest/autorun'
+require 'computable'
+
+module Helper
+  module EnableParallel
+    def setup
+      super
+      @b.computable_max_threads = 100
+    end
+
+    def teardown
+      @b.computable_max_threads = 0
+      super
+    end
+  end
+end

data/test/test_backtrace.rb

@@ -0,0 +1,33 @@
+require_relative 'helper'
+
+class TestBacktrace < Minitest::Test
+  class MyBuilder < Computable
+    calc_value :a do
+      b
+    end
+
+    calc_value :b do
+      raise "my error"
+    end
+  end
+
+  def setup
+    @b = MyBuilder.new
+  end
+
+  def teardown
+#     @b.computable_display_dot
+  end
+
+  def test_backtrace_decoration
+    err = assert_raises(StandardError){ @b.a }
+    bt = err.backtrace.join("\n")
+    assert_match(/my error/, err.to_s)
+    assert_match(/test_backtrace.rb:10:.* #b$/, bt)
+    assert_match(/test_backtrace.rb:6:.* #a$/, bt)
+  end
+end
+
+class TestBacktraceParallel < TestBacktrace
+  include Helper::EnableParallel
+end

data/test/test_candy.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'computable'
+require_relative 'helper'
 
-class TestCandy < MiniTest::Unit::TestCase
+class TestCandy < Minitest::Test
   class MyBuilder < Computable
     attr_reader :counters
 
@@ -10,9 +9,9 @@ class TestCandy < MiniTest::Unit::TestCase
       @counters = {}
     end
 
-    def self.counted_value name, format=nil, params={}, &block
+    def self.counted_value name, format=nil, **kwargs, &block
       define_method "#{name}_counted", &block
-      calc_value name, format do
+      calc_value name, format, **kwargs do
         @counters[name] ||= 0
         @counters[name] += 1
         send "#{name}_counted"
@@ -102,3 +101,7 @@ class TestCandy < MiniTest::Unit::TestCase
     assert_equal [2,2,2,1,2,2,1,1], @b.counters.values_at(:top, :l0, :r0, :l1, :r1, :bot, :fl, :fr)
   end
 end
+
+class TestCandyParallel < TestCandy
+  include Helper::EnableParallel
+end

data/test/test_debug.rb

@@ -0,0 +1,40 @@
+require_relative 'helper'
+
+class TestDebug < Minitest::Test
+  class MyBuilder < Computable
+    input_value :inp
+    calc_value :cal do
+      inp * 2
+    end
+  end
+
+  def setup
+    @b = MyBuilder.new
+  end
+
+  def teardown
+#     @b.computable_display_dot
+  end
+
+  def test_enable_debug
+    refute @b.computable_debug
+    @b.computable_debug = true
+    assert @b.computable_debug
+    @b.computable_debug = false
+    refute @b.computable_debug
+  end
+
+  def test_prints_debug
+    @b.computable_debug = true
+
+    assert_output(/set inp/){ @b.inp = 3 }
+    cal = nil
+    assert_output(/do calc/){ cal = @b.cal }
+
+    assert_equal 6, cal
+  end
+end
+
+class TestDebugParallel < TestDebug
+  include Helper::EnableParallel
+end

data/test/test_expired_recalc.rb

@@ -0,0 +1,40 @@
+require_relative 'helper'
+
+class TestExpiredRecalc < Minitest::Test
+  class MyBuilder < Computable
+    input_value :enable
+
+    calc_value :a do
+      b if enable
+    end
+
+    calc_value :b do
+      raise StandardError, "not enabled" unless enable
+      :x
+    end
+  end
+
+  def setup
+    @b = MyBuilder.new
+  end
+
+  def teardown
+#     @b.computable_display_dot
+  end
+
+  def test_on_off
+    @b.enable = true
+    assert_equal :x, @b.a
+
+    @b.enable = false
+    assert_nil @b.a  # this shouldn't raise an error although b is internally recalced
+    assert_raises(StandardError){ @b.b }
+
+    @b.enable = true
+    assert_equal :x, @b.a
+  end
+end
+
+class TestExpiredRecalcParallel < TestExpiredRecalc
+  include Helper::EnableParallel
+end

data/test/test_format.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'computable'
+require_relative 'helper'
 
-class TestFormat < MiniTest::Unit::TestCase
+class TestFormat < Minitest::Test
   class MyBuilder < Computable
     def self.verify_uniq_array(a)
       a.uniq.length == a.length
@@ -66,3 +65,7 @@ class TestFormat < MiniTest::Unit::TestCase
     assert_raises(Computable::InvalidFormat){ @b.sqrt }
   end
 end
+
+class TestFormatParallel < TestFormat
+  include Helper::EnableParallel
+end

data/test/test_freeze.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'computable'
+require_relative 'helper'
 
-class TestFreeze < MiniTest::Unit::TestCase
+class TestFreeze < Minitest::Test
   class MyBuilder < Computable
     input_value :no_freeze1, String, freeze: false
     calc_value :no_freeze2, String, freeze: false do
@@ -34,3 +33,7 @@ class TestFreeze < MiniTest::Unit::TestCase
     assert @b.freeze2.frozen?, "should be frozen"
   end
 end
+
+class TestFreezeParallel < TestFreeze
+  include Helper::EnableParallel
+end

data/test/test_inheritance.rb

@@ -0,0 +1,31 @@
+require_relative 'helper'
+
+class TestInheritance < Minitest::Test
+  class MyBuilder < Computable
+    calc_value :a do |*d|
+      "x#{d.inspect}"
+    end
+  end
+
+  class MyChild < MyBuilder
+    calc_value :a do |*d|
+      super() + "y#{d.inspect}"
+    end
+  end
+
+  def setup
+    @b = MyChild.new
+  end
+
+  def teardown
+#     @b.computable_display_dot
+  end
+
+  def test_super
+    assert_equal "x[]y[]", @b.a
+  end
+end
+
+class TestInheritanceParallel < TestInheritance
+  include Helper::EnableParallel
+end

data/test/test_input_value.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'computable'
+require_relative 'helper'
 
-class TestInputValue < MiniTest::Unit::TestCase
+class TestInputValue < Minitest::Test
   class MyBuilder < Computable
     input_value :i
 
@@ -46,3 +45,7 @@ class TestInputValue < MiniTest::Unit::TestCase
     assert_equal 6, @b.o
   end
 end
+
+class TestInputValueParallel < TestInputValue
+  include Helper::EnableParallel
+end

data/test/test_parallel.rb

@@ -0,0 +1,126 @@
+require_relative 'helper'
+
+class TestParallel < Minitest::Test
+  class MyBuilder < Computable
+    input_value :i1, Integer
+    input_value :i2, Integer
+
+    def self.p(idx)
+      calc_value "p#{idx}" do
+        sleep 0.1
+        i1
+      end
+    end
+
+    def self.q(idx)
+      calc_value "q#{idx}" do
+        sleep 0.1
+        send("p#{idx}") + i2
+      end
+    end
+
+    0.upto(4) do |idx|
+      p idx
+      q idx
+    end
+
+    calc_value :o do
+      0.upto(3).map do |idx|
+        send("q#{idx}")
+      end.inject(:+)
+    end
+
+    input_value :offs
+
+    100.times do |idx|
+      calc_value "m0-#{idx}" do
+        #sleep 0.001
+        idx + offs
+      end
+      calc_value "m1-#{idx}" do
+        #sleep 0.001
+        idx + offs
+      end
+      calc_value "m-#{idx}" do
+        send("m#{offs}-#{idx}")
+      end
+    end
+
+    calc_value "n" do
+      100.times.sum do |idx|
+        send("m-#{idx}")
+      end
+    end
+
+
+    class MyError < RuntimeError
+    end
+
+    input_value :enable_error
+    calc_value :raise_error do
+      raise MyError if enable_error
+    end
+  end
+
+  def setup
+    @b = MyBuilder.new
+  end
+
+  def teardown
+#     @b.computable_display_dot
+  end
+
+  def test_many_recalcs
+    @b.computable_max_threads = 10
+    @b.offs = 0
+    assert_equal 4950, @b.n
+
+    #@b.computable_debug = true
+    @b.offs = 1
+    assert_equal 5050, @b.n
+  end
+
+  def test_error
+    @b.enable_error = false
+    assert_nil @b.raise_error
+    @b.enable_error = true
+    assert_raises(MyBuilder::MyError){ @b.raise_error }
+    assert_raises(MyBuilder::MyError){ @b.raise_error }
+    @b.enable_error = false
+    assert_nil @b.raise_error
+  end
+
+  unless ENV["NO_TIMING_TESTS"]=="true"
+    def diff_time
+      st = Time.now
+      res = yield
+      [Time.now - st, res]
+    end
+
+    def test_full_parallel
+      @b.computable_max_threads = nil
+      @b.i1, @b.i2 = 2, 3
+      dt, res = diff_time{ @b.o }
+      assert_in_delta 0.8, dt, 0.1
+      assert_equal 20, res
+
+      @b.i1, @b.i2 = 4, 5
+      dt, res = diff_time{ @b.o }
+      assert_in_delta 0.2, dt, 0.1
+      assert_equal 36, res
+    end
+
+    def test_2_threads
+      @b.computable_max_threads = 2
+      @b.i1, @b.i2 = 2, 3
+      dt, res = diff_time{ @b.o }
+      assert_in_delta 0.8, dt, 0.1
+      assert_equal 20, res
+
+      @b.i1, @b.i2 = 4, 5
+      dt, res = diff_time{ @b.o }
+      assert_in_delta 0.4, dt, 0.1
+      assert_equal 36, res
+    end
+  end
+end

data/test/test_recursion_detection.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'computable'
+require_relative 'helper'
 
-class TestRecursionDetection < MiniTest::Unit::TestCase
+class TestRecursionDetection < Minitest::Test
   class MyBuilder < Computable
     calc_value :recursion1 do
       recursion1
@@ -34,3 +33,7 @@ class TestRecursionDetection < MiniTest::Unit::TestCase
     assert_raises(Computable::RecursionDetected){ @b.recursion2 }
   end
 end
+
+class TestRecursionDetectionParallel < TestRecursionDetection
+  include Helper::EnableParallel
+end

data/test/test_unknown.rb

@@ -0,0 +1,47 @@
+require_relative 'helper'
+
+class TestUnknown < Minitest::Test
+  class MyTruth
+    def ==(obj)
+      true
+    end
+  end
+
+  class MyFault
+    def ==(obj)
+      false
+    end
+  end
+
+  class MyBuilder < Computable
+    input_value :v1
+
+    calc_value :v2 do
+      v1
+    end
+  end
+
+  def setup
+    @b = MyBuilder.new
+  end
+
+  def teardown
+#     @b.computable_display_dot
+  end
+
+  def test_eq_true
+    @b.v1 = v = MyTruth.new
+    assert_same @b.v1, v
+    assert_same @b.v2, v
+  end
+
+  def test_eq_false
+    @b.v1 = v = MyFault.new
+    assert_same @b.v1, v
+    assert_same @b.v2, v
+  end
+end
+
+class TestUnknownParallel < TestUnknown
+  include Helper::EnableParallel
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: computable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Lars Kanis
@@ -10,9 +10,9 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIDaDCCAlCgAwIBAgIBATANBgkqhkiG9w0BAQUFADA9MQ4wDAYDVQQDDAVrYW5p
+  MIIDLjCCAhagAwIBAgIBCjANBgkqhkiG9w0BAQsFADA9MQ4wDAYDVQQDDAVrYW5p
   czEXMBUGCgmSJomT8ixkARkWB2NvbWNhcmQxEjAQBgoJkiaJk/IsZAEZFgJkZTAe
-  Fw0xMzAyMjYwODQ1NTlaFw0xNDAyMjYwODQ1NTlaMD0xDjAMBgNVBAMMBWthbmlz
+  Fw0yMjA0MTExMTMwNTNaFw0yMzA0MTExMTMwNTNaMD0xDjAMBgNVBAMMBWthbmlz
   MRcwFQYKCZImiZPyLGQBGRYHY29tY2FyZDESMBAGCgmSJomT8ixkARkWAmRlMIIB
   IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApop+rNmg35bzRugZ21VMGqI6
   HGzPLO4VHYncWn/xmgPU/ZMcZdfj6MzIaZJ/czXyt4eHpBk1r8QOV3gBXnRXEjVW
@@ -20,32 +20,37 @@ cert_chain:
   lJi4+ENAVT4MpqHEAGB8yFoPC0GqiOHQsdHxQV3P3c2OZqG+yJey74QtwA2tLcLn
   Q53c63+VLGsOjODl1yPn/2ejyq8qWu6ahfTxiIlSar2UbwtaQGBDFdb2CXgEufXT
   L7oaPxlmj+Q2oLOfOnInd2Oxop59HoJCQPsg8f921J43NCQGA8VHK6paxIRDLQID
-  AQABo3MwcTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUvgTdT7fe
-  x17ugO3IOsjEJwW7KP4wGwYDVR0RBBQwEoEQa2FuaXNAY29tY2FyZC5kZTAbBgNV
-  HRIEFDASgRBrYW5pc0Bjb21jYXJkLmRlMA0GCSqGSIb3DQEBBQUAA4IBAQCa3ThZ
-  9qjyuFXe0kN4IwgHTTSqob3zPOyXAxAq1k65w1/hI/6e4HxCSH7Ds+dKj/xhScEu
-  K5gaya1D69Fo+JTnzLvuSt2X8+mEHclduC9j++oSGc+szd7LKdeEQ7J4RefJjhD+
-  vWI6lqglL4PijN0nOWtm0ygzXEELDcGYpb2WJ++KKNVLIU6pkiWpZUmGcFB7NclV
-  I64m9iNdgWnDwedgUlqSMfVCUUB9S1Y5jI+doxYloPvIB6+6VsI4cmN2LcK0rQO6
-  N3pmmsS0N5772vAmRMyNl8PV1OzCLIMhgPgdeLpfU7LUSYWj67q5VuyjAaH5h68g
-  MlGgwc//cCsBG8sa
+  AQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUvgTdT7fe
+  x17ugO3IOsjEJwW7KP4wDQYJKoZIhvcNAQELBQADggEBAILiaB/unSVBfX5n7uL8
+  veGGCOHuGYhCGqspb6mYiCx0dmV3RPRiEfGDLfzcXbHNx/3AjygcxH4Slr+pmaxr
+  04Xli3WurocnjoANSWqCwpHH3OhSVxFgBNrCa3OMWcIr0xKH+I7PXA80SXe0pzfg
+  ePjpzTY71j+rcyRJqWiU5/zwdUaCCelBJscxh/0IaNcz67ocCEMRj0n4m5HFEmZL
+  9zKkMZFoOjxRQjcL84QU7ZXnnFR5HG8nLw+NqWjo49W6MBQ9HGFda2tk3OpBhyWS
+  sc3NyOkGUGdfiee5VRG31Sh3LLON3YGED+zZAS+ZF6598y4vhv8MBLa1Oy357byC
+  tTg=
   -----END CERTIFICATE-----
-date: 2014-02-12 00:00:00.000000000 Z
+date: 2022-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -60,6 +65,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.6'
 description: Define computation tasks with automatic caching and dependency tracking.
 email:
 - lars@greiz-reinsdorf.de
@@ -67,7 +86,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -75,11 +96,18 @@ files:
 - computable.gemspec
 - lib/computable.rb
 - lib/computable/version.rb
+- test/helper.rb
+- test/test_backtrace.rb
 - test/test_candy.rb
+- test/test_debug.rb
+- test/test_expired_recalc.rb
 - test/test_format.rb
 - test/test_freeze.rb
+- test/test_inheritance.rb
 - test/test_input_value.rb
+- test/test_parallel.rb
 - test/test_recursion_detection.rb
+- test/test_unknown.rb
 homepage: https://github.com/larskanis/computable
 licenses:
 - MIT
@@ -92,21 +120,27 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Define computation tasks with automatic caching and dependency tracking.
 test_files:
+- test/helper.rb
+- test/test_backtrace.rb
 - test/test_candy.rb
+- test/test_debug.rb
+- test/test_expired_recalc.rb
 - test/test_format.rb
 - test/test_freeze.rb
+- test/test_inheritance.rb
 - test/test_input_value.rb
+- test/test_parallel.rb
 - test/test_recursion_detection.rb
+- test/test_unknown.rb