rosarium 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0caf50a0435f2f9bd47f702eb22de12e5ad672d2
-  data.tar.gz: dd71f5aa5e34a2b6302dcf6d65d5aecd41825f2f
+SHA256:
+  metadata.gz: 7953c9f3adbdebbd4299ddef80c064fe76f32fe74e8bd8abafd160d0f9b6d816
+  data.tar.gz: 80b937b9e1e8750f1bbac9a9913a0e129b5dc80048d97b3ea360774b02eb1e2e
 SHA512:
-  metadata.gz: 3075ef2b1dcd8cdf1911e00fafb55c211d940420a18bafe356b703236e2ce888fe299898dfbc37d99f99374a56eb2fc91f60bdddc5a92d6df6e56fe0129ce25b
-  data.tar.gz: d6575b8a7f78e44848d26e98b536e9bc08aec5db580af6523b04e10e541842256fe98b9ace1cf152adb17c64feddfd15e3e361aea1c92b33570a71242fd4a9ff
+  metadata.gz: 22821d81eaccb0357841982eb2095c57e58f786d535834600b5903719c180d91af364b9e8778ac1256236d19db95835262fd77b8c313bedafdf60ae0e04a7579
+  data.tar.gz: 34ac659ece6ea48a111db7dab0ea89f8c0adcf90cfcf0802aaecba89eec49b1e8831fb9d55147691c4b686e51c1e68e38164fcd6dd27b4464fd5363ca802bcc9

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:
@@ -117,7 +114,3 @@ Promise code (every time a ruby block appears in the above examples) is run
 via a fixed-size thread pool, currently set to 10 threads.  Execution order is
 not defined.
 
-In comparison to the Promises/A+ spec <https://promisesaplus.com/>, these
-promises have an extra possible state, `:resolving`.  You are encouraged to
-use `#fulfilled?` and `#rejected?` instead anyway.
-

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
+    DEFAULT_ON_FULFILL = proc { |value| value }
+    DEFAULT_ON_REJECT = proc { |reason| raise reason }
 
-    DEFAULT_ON_FULFILL = Proc.new {|value| value}
-    DEFAULT_ON_REJECT = Proc.new {|reason| raise reason}
+    private_class_method :new
 
-    def self.resolve(value)
-      if value.kind_of? Promise
-        return value
+    def self.defer
+      promise = new
+
+      resolver = ->(value) { promise.send(:try_settle, value, nil) }
+
+      rejecter = lambda do |reason|
+        raise "reason must be an Exception" unless reason.is_a?(Exception)
+
+        promise.send(:try_settle, nil, reason)
       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.then(check, &check)
       end
 
       deferred.promise
@@ -65,16 +72,16 @@ module Rosarium
       waiting_for = promises.count
       mutex = Mutex.new
 
-      do_reject = Proc.new {|reason| deferred.reject reason}
-      do_fulfill = Proc.new do
+      do_reject = ->(reason) { deferred.reject(reason) }
+      do_fulfill = proc 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)
+          deferred.resolve(promises.map(&:value))
         end
       end
 
       promises.each do |promise|
-        promise.then(do_reject) { do_fulfill.call }
+        promise.then(do_reject, &do_fulfill)
       end
 
       deferred.promise
@@ -86,17 +93,21 @@ module Rosarium
       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.call value
+              else
+                # User-supplied code
+                on_rejected.call reason
+              end
+            )
+          rescue Exception => e
+            deferred.reject e
+          end
         end
       end
 
@@ -107,9 +118,142 @@ module Rosarium
       self.then(block)
     end
 
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
+    alias catch rescue
+    alias on_error rescue
 
-  end
+    public
+
+    def initialize
+      @state = :pending
+      @resolving = false
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @when_settled = []
+    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
+        raise @reason if @state == :rejected
+        @value
+      end
+    end
 
+    private
+
+    def wait
+      when_settled do
+        synchronize { @condition.broadcast }
+      end
+
+      synchronize do
+        loop do
+          return if @state == :fulfilled || @state == :rejected
+          @condition.wait @mutex
+        end
+      end
+    end
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+
+    def try_settle(value, reason)
+      callbacks = []
+      add_when_settled = false
+
+      synchronize do
+        if @state == :pending && !@resolving
+          if value.is_a? Promise
+            @resolving = true
+            add_when_settled = true
+          elsif reason.nil?
+            @value = value
+            @state = :fulfilled
+            callbacks.concat @when_settled
+            @when_settled.clear
+          else
+            @reason = reason
+            @state = :rejected
+            callbacks.concat @when_settled
+            @when_settled.clear
+          end
+        end
+      end
+
+      # rubocop:disable Style/IfUnlessModifier
+      if add_when_settled
+        value.when_settled { copy_settlement_from value }
+      end
+      # rubocop:enable Style/IfUnlessModifier
+
+      callbacks.each { |c| EXECUTOR.submit(&c) }
+    end
+
+    def copy_settlement_from(other)
+      callbacks = []
+
+      synchronize do
+        @value = other.value
+        @reason = other.reason
+        @state = other.state
+        @resolving = false
+        callbacks.concat @when_settled
+        @when_settled.clear
+      end
+
+      callbacks.each { |c| EXECUTOR.submit(&c) }
+    end
+
+    protected
+
+    def when_settled(&block)
+      immediate = synchronize do
+        if @state == :fulfilled || @state == :rejected
+          true
+        else
+          @when_settled << block
+          false
+        end
+      end
+
+      block.call if immediate
+
+      nil
+    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.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Rachel Evans
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-07-04 00:00:00.000000000 Z
+date: 2021-02-13 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
@@ -51,7 +64,7 @@ homepage: http://rve.org.uk/gems/rosarium
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -59,16 +72,15 @@ 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
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Promises, or something like them
 test_files: []

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