thomas_utils 0.1.18 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d8863b06f5f048eab689b989c66dd14e4d29b4f
-  data.tar.gz: c5d8484310812422078cf2e147ef9caa1eb5c845
+  metadata.gz: 1020f2a07e22d03f1be48e6c97fdc68b4c03631b
+  data.tar.gz: 35873e679f97bab51c4cad7b613efeca95733a60
 SHA512:
-  metadata.gz: f7a8d86e988a34be705829a487d9404e8e385a03f6eb7bf8c06dec02f7a95cfb6da37fb80eac00eb4efb6e2074aa88e8718e9086005e701f7b447ae586018218
-  data.tar.gz: 99dc2ba2d5513d7148963fa76edebe30280900673158468ae393fdd6fbe392297f78c84e8ca9a06c378c7269dd80fdcbce6fb622658e6cd433dd09af97302703
+  metadata.gz: 2cd4e5f2b799142ea45e3ad1026fd748cfa2e2520072d3a0ca836b61b98dd39e3db42d61f3a88f72f1ec70168fe34d94e6ceb8f020e6a36f54715d057789d029
+  data.tar.gz: a511baf55abad9d03c3f8f70ce972fad75e3defd6c2b46c1b58235c940450d7e15e74c262062d5f76f02444097202eb9f5b46ba61cc0b468d59495db5ad15c96

data/lib/thomas_utils.rb

@@ -25,4 +25,7 @@ require 'thomas_utils/multi_future_wrapper'
 require 'thomas_utils/key_comparer'
 require 'thomas_utils/key_indexer'
 require 'thomas_utils/key_child'
+require 'thomas_utils/executor_service'
+require 'thomas_utils/constant_var'
+require 'thomas_utils/observation'
 require 'thomas_utils/future'

data/lib/thomas_utils/constant_var.rb

@@ -0,0 +1,47 @@
+module ThomasUtils
+  class ConstantVar < Struct.new(:time, :value, :reason)
+
+    def self.value(value)
+      new(Time.now, value, nil)
+    end
+
+    def self.none
+      new(Time.now, nil, nil)
+    end
+
+    def self.error(error)
+      new(Time.now, nil, error)
+    end
+
+    def value!
+      raise reason if reason
+      value
+    end
+
+    def add_observer(observer = nil, func = :update, &block)
+      if block
+        observer = block
+        func = :call
+      end
+      observer.public_send(func, time, value, reason)
+    end
+
+    def with_observer(observer = nil, func = :update, &block)
+      add_observer(observer, func, &block)
+      self
+    end
+
+    def delete_observer(_)
+      raise NotImplementedError
+    end
+
+    def delete_observers
+      raise NotImplementedError
+    end
+
+    def count_observers
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/thomas_utils/executor_service.rb

@@ -0,0 +1,7 @@
+module Concurrent
+  module ExecutorService
+    def execute(*args, &block)
+      post(*args, &block)
+    end
+  end
+end

data/lib/thomas_utils/future.rb

@@ -1,42 +1,53 @@
 module ThomasUtils
-  class Future
+  class Future < Observation
     DEFAULT_EXECUTOR = ::Concurrent::CachedThreadPool.new
+    IMMEDIATE_EXECUTOR = ::Concurrent::ImmediateExecutor.new
 
-    def initialize(options = {})
-      options[:executor] ||= DEFAULT_EXECUTOR
-
-      @mutex = Mutex.new
-      @future = ::Concurrent::Future.execute(executor: options[:executor]) do
-        begin
-          @result = yield
-          @result = @result.get if @result.is_a?(FutureWrapper)
-          @mutex.synchronize { @success_callback.call(@result) if @success_callback }
-          @result
-        rescue => e
-          @error = e
-          @mutex.synchronize { @failure_callback.call(e) if @failure_callback }
-        end
-      end
+    def self.value(value)
+      Observation.new(IMMEDIATE_EXECUTOR, ConstantVar.value(value))
+    end
+
+    def self.immediate(&block)
+      none.then(&block)
     end
 
-    def get
-      result = @future.value
-      raise @error if @error
-      result
+    def self.none
+      Observation.new(IMMEDIATE_EXECUTOR, ConstantVar.none)
     end
 
-    def join
-      get rescue nil
+    def self.error(error)
+      Observation.new(IMMEDIATE_EXECUTOR, ConstantVar.error(error))
     end
 
-    def on_success(&block)
-      @mutex.synchronize { @success_callback = block }
-      @success_callback.call(@result) if @future.fulfilled? && !@error
+    def self.all(observations)
+      observable = Concurrent::IVar.new
+      left = observations.count
+      buffer = [nil] * left
+      mutex = Mutex.new
+      observations.each_with_index do |observation, index|
+        observation.on_complete do |value, error|
+          if error
+            observable.fail(error)
+          else
+            buffer[index] = value
+            done = false
+            mutex.synchronize do
+              left -= 1
+              done = !!left.zero?
+            end
+            observable.set(buffer) if done
+          end
+        end
+      end
+      Observation.new(DEFAULT_EXECUTOR, observable)
     end
 
-    def on_failure(&block)
-      @mutex.synchronize { @failure_callback = block }
-      @failure_callback.call(@error) if @future.fulfilled? && @error
+    def initialize(options = {}, &block)
+      executor = options.fetch(:executor) { DEFAULT_EXECUTOR }
+      observable = Concurrent::Future.execute(executor: executor, &block)
+      super(executor, observable)
     end
+
   end
-end
+end
+

data/lib/thomas_utils/observation.rb

@@ -0,0 +1,167 @@
+module ThomasUtils
+  class Observation
+    extend Forwardable
+
+    def_delegator :@observable, :value!, :get
+
+    def initialize(executor, observable)
+      @executor = executor
+      @observable = observable
+    end
+
+    def on_success
+      @observable.add_observer do |_, value, error|
+        @executor.post do
+          yield value unless error
+        end
+      end
+      self
+    end
+
+    def on_failure
+      @observable.add_observer do |_, _, error|
+        @executor.post do
+          yield error if error
+        end
+      end
+      self
+    end
+
+    def on_complete
+      @observable.add_observer do |_, value, error|
+        @executor.post do
+          yield value, error
+        end
+      end
+      self
+    end
+
+    def join
+      @observable.value
+      self
+    end
+
+    def then(&block)
+      successive(:on_complete_then, &block)
+    end
+
+    def none_fallback
+      self.then do |result|
+        result || yield
+      end
+    end
+
+    def fallback(&block)
+      successive(:on_complete_fallback, &block)
+    end
+
+    def ensure(&block)
+      successive(:on_complete_ensure, &block)
+    end
+
+    def on_success_ensure(&block)
+      self.then do |result|
+        child_result = block.call(result)
+        if result_is_observation?(child_result)
+          child_result.then { result }
+        else
+          result
+        end
+      end
+    end
+
+    def on_failure_ensure(&block)
+      self.fallback do |error|
+        result = block.call(error)
+        error_observation = Observation.new(@executor, ConstantVar.error(error))
+        if result_is_observation?(result)
+          result.then { error_observation }
+        else
+          error_observation
+        end
+      end
+    end
+
+    private
+
+    def successive(method, &block)
+      observable = Concurrent::IVar.new
+      send(method, observable, &block)
+      Observation.new(@executor, observable)
+    end
+
+    def on_complete_then(observable, &block)
+      on_complete do |value, error|
+        if error
+          observable.fail(error)
+        else
+          on_success_then(observable, value, &block)
+        end
+      end
+    end
+
+    def on_complete_fallback(observable, &block)
+      on_complete do |value, error|
+        if error
+          on_failure_fallback(observable, error, &block)
+        else
+          observable.set(value)
+        end
+      end
+    end
+
+    def on_success_then(observable, value)
+      result = yield value
+      if result_is_observation?(result)
+        result.on_complete do |child_result, child_error|
+          ensure_then(child_error, observable, child_result)
+        end
+      else
+        observable.set(result)
+      end
+    rescue Exception => error
+      observable.fail(error)
+    end
+
+    alias :on_failure_fallback :on_success_then
+
+    def on_complete_ensure(observable)
+      on_complete do |value, error|
+        begin
+          result = yield value, error
+          if result_is_observation?(result)
+            ensure_complete_then(error, observable, result, value)
+          else
+            ensure_then(error, observable, value)
+          end
+        rescue Exception => child_error
+          observable.fail(child_error)
+        end
+      end
+    end
+
+    def ensure_complete_then(error, observable, result, value)
+      result.on_complete do |_, child_error|
+        if child_error
+          observable.fail(child_error)
+        elsif error
+          observable.fail(error)
+        else
+          observable.set(value)
+        end
+      end
+    end
+
+    def ensure_then(error, observable, value)
+      if error
+        observable.fail(error)
+      else
+        observable.set(value)
+      end
+    end
+
+    def result_is_observation?(result)
+      result.respond_to?(:on_complete) && result.respond_to?(:then)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thomas_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.2.3
 platform: ruby
 authors:
 - Thomas RM Rogers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-14 00:00:00.000000000 Z
+date: 2016-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: workers
   requirement: !ruby/object:Gem::Requirement
@@ -50,6 +50,8 @@ files:
 - LICENSE.txt
 - README.md
 - lib/thomas_utils.rb
+- lib/thomas_utils/constant_var.rb
+- lib/thomas_utils/executor_service.rb
 - lib/thomas_utils/future.rb
 - lib/thomas_utils/future_wrapper.rb
 - lib/thomas_utils/key_child.rb
@@ -57,6 +59,7 @@ files:
 - lib/thomas_utils/key_indexer.rb
 - lib/thomas_utils/multi_future_wrapper.rb
 - lib/thomas_utils/object_stream.rb
+- lib/thomas_utils/observation.rb
 - lib/thomas_utils/periodic_flusher.rb
 - lib/thomas_utils/symbol_helpers.rb
 homepage: https://www.github.com/thomasrogers03/thomas_utils