rosarium 0.1.2 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dd135d7400b2b9b0ec7a42e0f55574e303df8425
-  data.tar.gz: bebfd30e1de878fbedf6590c32a4b7909b479288
+SHA256:
+  metadata.gz: 3789051cf47569f1729bb161433ecb033274b49833e774eec788e5884c490897
+  data.tar.gz: f48ef4f93bc8cadb68d9069d3dd3f8434b45ce43e6f3057918912d97d72f5432
 SHA512:
-  metadata.gz: 2f4a5068349c9084a3aa7b9207bb36df467658f3492d388f622f4dad39870187e175dc1671effddf4b9fcb839a1167f9b61431a4fc3247322b522c7b6ee12881
-  data.tar.gz: aa809dc94d73d35b5a2dea871dfeb486b04e1dc5b1733955d5f3cf0dab566d558f5b2ddbded6558d011b54f726379112eb47a7f8edd9f758fc9a3a641727bd4f
+  metadata.gz: 3e108887ddb2cdee8bc0e5abe53915e249028d5f367a7c617874460a4b7b5ec19ca04c364631e3b6235c0da80c2ae2951501e08c6b280dd2609455bdbe9f7858
+  data.tar.gz: 7622eab1b92fcee040b91394422f8b7f1f2c78be004c62988d5e588bf528ab6718da0bc97d3adb8b24022b22498d80843e31c051b5b83ed2f4fed308ff288370

data/Gemfile

@@ -1 +1,4 @@
+# frozen_string_literal: true
+
 gem 'rspec', '~> 3.4'
+gem 'rubocop', '~> 1.2'

data/Gemfile.lock

@@ -1,25 +1,46 @@
 GEM
   specs:
-    diff-lcs (1.2.5)
-    rspec (3.4.0)
-      rspec-core (~> 3.4.0)
-      rspec-expectations (~> 3.4.0)
-      rspec-mocks (~> 3.4.0)
-    rspec-core (3.4.1)
-      rspec-support (~> 3.4.0)
-    rspec-expectations (3.4.0)
+    ast (2.4.1)
+    diff-lcs (1.4.4)
+    parallel (1.20.1)
+    parser (3.0.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    regexp_parser (1.8.2)
+    rexml (3.2.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.4.0)
-    rspec-mocks (3.4.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.4.0)
-    rspec-support (3.4.1)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    rubocop (1.2.0)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.5)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8)
+      rexml
+      rubocop-ast (>= 1.0.1)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (1.4.0)
+      parser (>= 2.7.1.5)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (1.7.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   rspec (~> 3.4)
+  rubocop (~> 1.2)
 
 BUNDLED WITH
-   1.11.2
+   1.17.3

data/README.md

@@ -66,9 +66,15 @@ then later, use the "deferred" to fulfill or reject the promise:
 ## Methods of promises:
 
 ```
-  # One of: :pending, :resolving, :fulfilled, :rejected.
+  # One of: :pending, :fulfilled, :rejected.
   promise.state
 
+  # Equivalent to "state == :fulfilled"
+  promise.fulfilled?
+
+  # Equivalent to "state == :rejected"
+  promise.rejected?
+
   # Wait for the promise to be settled, then return its value (if fulfilled -
   # note the value may be nil), or nil (if rejected).
   promise.value
@@ -77,22 +83,13 @@ then later, use the "deferred" to fulfill or reject the promise:
   # or nil (if fulfilled).
   promise.reason
 
-  # A hash describing the state of the promise.  Always includes :state key;
-  # may include :value or :reason.
-  promise.inspect
-
-  # true iff state == :fulfilled
-  promise.fulfilled?
-
-  # true iff state == :rejected
-  promise.rejected?
-
   # Wait for the promise to be settled, then return its value (if fulfilled),
   # or raise with the rejection reason (if rejected).
   promise.value!
 
-  # Wait for the promise to be settled
-  promise.wait
+  # A hash describing the state of the promise.  Always includes :state key;
+  # may include :value or :reason.
+  promise.inspect
 ```
 
 Chaining promises together:

data/lib/rosarium.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require_relative 'rosarium/fixed_thread_executor'
-require_relative 'rosarium/simple_promise'
 require_relative 'rosarium/deferred'
 require_relative 'rosarium/promise'
 

data/lib/rosarium/deferred.rb

@@ -1,5 +1,6 @@
-module Rosarium
+# frozen_string_literal: true
 
+module Rosarium
   class Deferred
 
     def initialize(promise, resolver, rejecter)
@@ -8,9 +9,7 @@ module Rosarium
       @rejecter = rejecter
     end
 
-    def promise
-      @promise
-    end
+    attr_reader :promise
 
     def resolve(value)
       @resolver.call(value)
@@ -21,5 +20,4 @@ module Rosarium
     end
 
   end
-
 end

data/lib/rosarium/fixed_thread_executor.rb

@@ -1,5 +1,6 @@
-module Rosarium
+# frozen_string_literal: true
 
+module Rosarium
   class FixedThreadExecutor
 
     def initialize(max = 1)
@@ -14,7 +15,7 @@ module Rosarium
       @mutex.synchronize do
         @waiting << block
         if @executing < @max
-          @executing = @executing + 1
+          @executing += 1
           t = Thread.new { execute_and_count_down }
           @threads.push t
         end
@@ -36,26 +37,23 @@ module Rosarium
     private
 
     def execute_and_count_down
-      begin
-        execute
-      ensure
-        @mutex.synchronize do
-          @executing = @executing - 1
-        end
+      execute
+    ensure
+      @mutex.synchronize do
+        @executing -= 1
       end
     end
 
     def execute
-      while true
+      loop do
         block = @mutex.synchronize { @waiting.shift }
         block or break
         begin
           block.call
-        rescue Exception => e
+        rescue Exception
         end
       end
     end
 
   end
-
 end

data/lib/rosarium/promise.rb

@@ -1,15 +1,30 @@
+# frozen_string_literal: true
+
 module Rosarium
+  class Promise
 
-  class Promise < SimplePromise
+    private_class_method :new
 
-    DEFAULT_ON_FULFILL = Proc.new {|value| value}
-    DEFAULT_ON_REJECT = Proc.new {|reason| raise reason}
+    def self.defer
+      promise = new
 
-    def self.resolve(value)
-      if value.kind_of? Promise
-        return value
+      resolver = lambda do |value|
+        promise.send(:try_settle, value, nil)
+        nil # do not leak
+      end
+
+      rejecter = lambda do |reason|
+        raise "reason must be an Exception" unless reason.is_a?(Exception)
+        promise.send(:try_settle, nil, reason)
+        nil # do not leak
       end
 
+      Deferred.new(promise, resolver, rejecter)
+    end
+
+    def self.resolve(value)
+      return value if value.is_a? Promise
+
       deferred = defer
       deferred.resolve(value)
       deferred.promise
@@ -22,15 +37,7 @@ module Rosarium
     end
 
     def self.execute(&block)
-      deferred = defer
-      EXECUTOR.submit do
-        begin
-          deferred.resolve block.call
-        rescue Exception => e
-          deferred.reject e
-        end
-      end
-      deferred.promise
+      @resolved.then(&block)
     end
 
     def self.all_settled(promises)
@@ -42,7 +49,7 @@ module Rosarium
       waiting_for = promises.count
       mutex = Mutex.new
 
-      check = Proc.new do
+      check = proc do
         # Includes both fulfilled and rejected, so always hits zero eventually
         if mutex.synchronize { (waiting_for -= 1) == 0 }
           deferred.resolve promises
@@ -50,7 +57,7 @@ module Rosarium
       end
 
       promises.each do |promise|
-        promise.then(check) { check.call }
+        promise.send(:when_settled, &check)
       end
 
       deferred.promise
@@ -65,38 +72,89 @@ module Rosarium
       waiting_for = promises.count
       mutex = Mutex.new
 
-      do_reject = Proc.new {|reason| deferred.reject reason}
-      do_fulfill = Proc.new do
-        # Only fulfilled (not rejected), so hits zero iff all promises were fulfilled
-        if mutex.synchronize { (waiting_for -= 1) == 0 }
-          deferred.resolve(promises.map &:value)
+      check = lambda do |promise|
+        if promise.fulfilled?
+          # Hits zero iff all promises were fulfilled
+          if mutex.synchronize { (waiting_for -= 1) == 0 }
+            deferred.resolve(promises.map(&:value))
+          end
+        else
+          deferred.reject(promise.reason)
         end
       end
 
       promises.each do |promise|
-        promise.then(do_reject) { do_fulfill.call }
+        promise.send(:when_settled) { check.call(promise) }
       end
 
       deferred.promise
     end
 
+    def initialize
+      @state = :pending
+      @settling = false
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @when_settled = []
+    end
+
+    def state
+      synchronize { @state }
+    end
+
+    def value
+      wait_until_settled
+      synchronize { @value }
+    end
+
+    def reason
+      wait_until_settled
+      synchronize { @reason }
+    end
+
+    def value!
+      wait_until_settled
+      synchronize do
+        raise @reason if @state == :rejected
+        @value
+      end
+    end
+
+    def inspect
+      synchronize do
+        r = { state: @state }
+        r[:value] = @value if @state == :fulfilled
+        r[:reason] = @reason if @state == :rejected
+        r
+      end
+    end
+
+    def fulfilled?
+      state == :fulfilled
+    end
+
+    def rejected?
+      state == :rejected
+    end
+
     def then(on_rejected = nil, &on_fulfilled)
       deferred = self.class.defer
 
-      on_fulfilled ||= DEFAULT_ON_FULFILL
-      on_rejected ||= DEFAULT_ON_REJECT
-
-      on_resolution do
-        begin
-          deferred.resolve(
-            if fulfilled?
-              on_fulfilled.call value
-            else
-              on_rejected.call reason
-            end
-          )
-        rescue Exception => e
-          deferred.reject e
+      when_settled do
+        EXECUTOR.submit do
+          begin
+            deferred.resolve(
+              if fulfilled?
+                # User-supplied code
+                on_fulfilled ? on_fulfilled.call(value) : value
+              else
+                # User-supplied code
+                on_rejected ? on_rejected.call(reason) : raise(reason)
+              end
+            )
+          rescue Exception => e
+            deferred.reject e
+          end
         end
       end
 
@@ -107,9 +165,76 @@ module Rosarium
       self.then(block)
     end
 
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
+    alias catch rescue
+    alias on_error rescue
 
-  end
+    private
+
+    def wait_until_settled
+      synchronize do
+        loop do
+          return if @state != :pending
+          @condition.wait @mutex
+        end
+      end
+    end
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+
+    # Can be called more than once
+    def try_settle(value, reason)
+      settle_with = nil
+
+      synchronize do
+        return if @state != :pending || @settling
+
+        if value.is_a? Promise
+          @settling = true
+        elsif reason.nil?
+          settle_with = [value, nil]
+        else
+          settle_with = [nil, reason]
+        end
+      end
+
+      if settle_with
+        settle(*settle_with)
+      else
+        value.when_settled do
+          if value.fulfilled?
+            settle(value.value, nil)
+          else
+            settle(nil, value.reason)
+          end
+        end
+      end
+    end
+
+    # Only called once
+    def settle(value, reason)
+      synchronize do
+        @state = (reason ? :rejected : :fulfilled)
+        @value = value
+        @reason = reason
+        @condition.broadcast
+        @when_settled.slice!(0, @when_settled.length)
+      end.each(&:call)
+    end
 
+    protected
+
+    def when_settled(&block)
+      immediate = synchronize do
+        @when_settled << block if @state == :pending
+        @state != :pending
+      end
+
+      block.call if immediate
+    end
+
+    @resolved = resolve(nil)
+
+  end
 end

data/spec/deferred_spec.rb

@@ -63,7 +63,7 @@ describe "deferred promises" do
     d1.resolve(d2.promise)
     check_pending d1.promise
     d2.resolve 7
-    d1.promise.wait
+    d1.promise.value
     check_fulfilled d1.promise, 7
   end
 
@@ -74,7 +74,7 @@ describe "deferred promises" do
     check_pending d1.promise
     e = an_error
     d2.reject e
-    d1.promise.wait
+    d1.promise.value
     check_rejected d1.promise, e
   end
 

data/spec/promise_methods_spec.rb

@@ -33,7 +33,7 @@ describe Rosarium::Promise do
     chained = deferred.promise.then { then_called = true }
     check_pending chained
     deferred.reject e
-    chained.wait
+    chained.value
     check_rejected chained, e
     expect(then_called).to be_falsy
   end
@@ -45,7 +45,7 @@ describe Rosarium::Promise do
     got_args = nil
     chained = deferred.promise.then(Proc.new {|*args| got_args = args; raise e2 }) { raise "should never be called" }
     deferred.reject e
-    chained.wait
+    chained.value
     check_rejected chained, e2
     expect(got_args).to eq([e])
   end
@@ -54,7 +54,7 @@ describe Rosarium::Promise do
     deferred = Rosarium::Promise.defer
     chained = deferred.promise.then(Proc.new {7}) { raise "should never be called" }
     deferred.reject an_error
-    chained.wait
+    chained.value
     check_fulfilled chained, 7
   end
 
@@ -63,9 +63,16 @@ describe Rosarium::Promise do
       deferred = Rosarium::Promise.defer
       chained = deferred.promise.send(method) { 7 }
       deferred.reject an_error
-      chained.wait
+      chained.value
       check_fulfilled chained, 7
     end
   end
 
+  it "uses the executor even if immediately callable" do
+    deferred = Rosarium::Promise.resolve(nil).then { sleep 0.1; 7 }
+    check_pending deferred
+    sleep 0.2
+    check_fulfilled deferred, 7
+  end
+
 end

data/spec/promise_static_spec.rb

@@ -14,16 +14,11 @@ describe "instantly-resolved promises" do
   it "creates a fulfilled promise" do
     t = Rosarium::Promise.resolve 7
     check_fulfilled t, 7
-    expect(t).not_to respond_to(:fulfill)
-    expect(t).not_to respond_to(:reject)
   end
 
   it "creates a rejected promise" do
-    e = an_error
     t = Rosarium::Promise.reject an_error
     check_rejected t, an_error
-    expect(t).not_to respond_to(:fulfill)
-    expect(t).not_to respond_to(:reject)
   end
 
   it "creates an immediately-executable promise" do
@@ -61,7 +56,7 @@ describe "instantly-resolved promises" do
 
     e = an_error
     d2.reject e
-    promise.wait
+    promise.value
     check_fulfilled promise, [ d1.promise, d2.promise ]
   end
 
@@ -82,7 +77,7 @@ describe "instantly-resolved promises" do
 
     e = an_error
     d3.reject e
-    promise.wait
+    promise.value
     check_rejected promise, e
   end
 
@@ -96,7 +91,7 @@ describe "instantly-resolved promises" do
     check_pending promise
 
     d2.resolve 8
-    promise.wait
+    promise.value
     check_fulfilled promise, [7,8]
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rosarium
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.7
 platform: ruby
 authors:
 - Rachel Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-04 00:00:00.000000000 Z
+date: 2021-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: |2
       Rosarium implements something that's a bit like Promises,
       inspired by the stability and ease of use of Q
@@ -41,7 +55,6 @@ files:
 - lib/rosarium/deferred.rb
 - lib/rosarium/fixed_thread_executor.rb
 - lib/rosarium/promise.rb
-- lib/rosarium/simple_promise.rb
 - spec/deferred_spec.rb
 - spec/fixed_thread_executor_spec.rb
 - spec/promise_methods_spec.rb
@@ -59,15 +72,14 @@ 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.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Promises, or something like them

data/lib/rosarium/simple_promise.rb

@@ -1,164 +0,0 @@
-module Rosarium
-
-  class SimplePromise
-
-    def self.defer
-      promise = new
-      resolver = promise.method :resolve
-      rejecter = promise.method :reject
-
-      class <<promise
-        undef :resolve
-        undef :reject
-      end
-
-      Deferred.new(promise, resolver, rejecter)
-    end
-
-    def initialize
-      @state = :pending
-      @resolving = false
-      @mutex = Mutex.new
-      @condition = ConditionVariable.new
-      @on_resolution = []
-    end
-
-    def state
-      synchronize { @state }
-    end
-
-    def value
-      wait
-      synchronize { @value }
-    end
-
-    def reason
-      wait
-      synchronize { @reason }
-    end
-
-    def inspect
-      synchronize do
-        r = { state: @state }
-        r[:value] = @value if @state == :fulfilled
-        r[:reason] = @reason if @state == :rejected
-        r
-      end
-    end
-
-    def fulfilled?
-      state == :fulfilled
-    end
-
-    def rejected?
-      state == :rejected
-    end
-
-    def value!
-      wait
-      synchronize do
-        if @state == :rejected
-          raise @reason
-        else
-          @value
-        end
-      end
-    end
-
-    def wait
-      on_resolution do
-        @mutex.synchronize { @condition.broadcast }
-      end
-
-      @mutex.synchronize do
-        loop do
-          return if @state == :fulfilled or @state == :rejected
-          @condition.wait @mutex
-        end
-      end
-    end
-
-    private
-
-    def synchronize
-      @mutex.synchronize { yield }
-    end
-
-    public
-
-    def resolve(value)
-      _resolve(value, nil)
-    end
-
-    def reject(reason)
-      raise "reason must be an Exception" unless reason.kind_of? Exception
-      _resolve(nil, reason)
-    end
-
-    private
-
-    def _resolve(value, reason)
-      callbacks = []
-      add_on_resolution = false
-
-      synchronize do
-        if @state == :pending and not @resolving
-          if value.kind_of? SimplePromise
-            @resolving = true
-            add_on_resolution = true
-          elsif reason.nil?
-            @value = value
-            @state = :fulfilled
-            callbacks.concat @on_resolution
-            @on_resolution.clear
-          else
-            @reason = reason
-            @state = :rejected
-            callbacks.concat @on_resolution
-            @on_resolution.clear
-          end
-        end
-      end
-
-      if add_on_resolution
-        value.on_resolution { copy_resolution_from value }
-      end
-
-      callbacks.each {|c| EXECUTOR.submit { c.call } }
-    end
-
-    def copy_resolution_from(other)
-      callbacks = []
-
-      synchronize do
-        @value = other.value
-        @reason = other.reason
-        @state = other.state
-        @resolving = false
-        callbacks.concat @on_resolution
-        @on_resolution.clear
-      end
-
-      callbacks.each {|c| EXECUTOR.submit { c.call } }
-    end
-
-    protected
-
-    def on_resolution(&block)
-      immediate = synchronize do
-        if @state == :fulfilled or @state == :rejected
-          true
-        else
-          @on_resolution << block
-          false
-        end
-      end
-
-      block.call if immediate
-
-      nil
-    end
-
-  end
-
-end