dry-effects 0.1.0.alpha2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e467f4de9697568b05a68ccc58c3d7acc44ab3f196e6a93c07c574b6aaeca6f9
-  data.tar.gz: 4f3b5093c7aabb77aeab310080bc1a1e2091537da7724c5c1b70587cbcbce12b
+  metadata.gz: b4b516150a36745c1fac9a030dc079a629737b0a79b35b5e6901c413e7019479
+  data.tar.gz: 0f81389b62e44b1196535332407cec3d894ccc7f6413f97e32766d0b5109426f
 SHA512:
-  metadata.gz: bc7202bfd43a789fd1221323126eee3000479c45508ccb08874a29b91b86ee089a6248b7f33a64a651aa296b84a4ae425bcdab689b18709144ea33ab3cd9e582
-  data.tar.gz: 1e2a61bcfe1e64991317b028b1bae6e3ddd663c3b658c9f67ecb14dc0570610d75bccc94ad8ec9cb7d8f935099086dadcb6e075bc702a920820fc07b90bb8571
+  metadata.gz: 97c935e9b3b37f026c74b1e5e055f43f17b718dad48095b80f730c610d685990a0e9d1cd473859154d78fa388f44ae211f861ec066ec268b95b58d1543b2d07b
+  data.tar.gz: dc49f0fd42b63ec247322a177e73334a30f336e70b904c03c9708b2991dd85344b9b6f62833b768501082434b49fc69060980111ca0a137c922b66186d27d7a9

data/.travis.yml

@@ -7,9 +7,9 @@ before_script:
   - chmod +x ./cc-test-reporter
   - ./cc-test-reporter before-build
 rvm:
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
+  - 2.4.7
+  - 2.5.6
+  - 2.6.4
   - truffleruby
 after_script:
   - "[ -d coverage ] && ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT"
@@ -20,7 +20,7 @@ matrix:
   allow_failures:
     - rvm: truffleruby
   include:
-    - rvm: jruby-9.2.7.0
+    - rvm: jruby-9.2.8.0
       jdk: openjdk8
 notifications:
   email: false

data/examples/{amb.rb → cmp.rb}

@@ -2,7 +2,7 @@
 
 class Operation
   include Dry::Effects.State(:counter)
-  include Dry::Effects.Amb(:feature_enabled)
+  include Dry::Effects.Cmp(:feature_enabled)
 
   def call
     if feature_enabled?
@@ -17,10 +17,10 @@ end
 
 module Handler
   include Dry::Effects::Handler.State(:counter, as: :with_counter)
-  include Dry::Effects::Handler.Amb(:feature_enabled, as: :test_feature)
+  include Dry::Effects::Handler.Cmp(:feature_enabled, as: :test_feature)
 end
 
-class AmbState
+class CmpState
   include Handler
 
   def initialize
@@ -32,7 +32,7 @@ class AmbState
   end
 end
 
-class StateAmb
+class StateCmp
   include Handler
 
   def initialize
@@ -44,8 +44,8 @@ class StateAmb
   end
 end
 
-amb_then_state = AmbState.new
-state_then_amb = StateAmb.new
+cmp_then_state = CmpState.new
+state_then_cmp = State.Cmp.new
 
-amb_then_state.() # => [[1, :without_feature], [10, :with_feature]]
-state_then_amb.() # => [11, [:without_feature, :with_feature]]
+cmp_then_state.() # => [[1, :without_feature], [10, :with_feature]]
+state_then_cmp.() # => [11, [:without_feature, :with_feature]]

data/lib/dry/effects.rb

@@ -18,6 +18,21 @@ module Dry
     class << self
       attr_reader :effects, :providers
 
+      # Handle an effect.
+      # If no handler is present in the stack it will either
+      # raise an exception and yield a block if given.
+      # It is not recommended to build effects manually, hence
+      # this method shouldn't be used often.
+      #
+      # @example getting current user with yield
+      #
+      #   require 'dry/effects/effects/reader'
+      #   extend Dry::Effects::Constructors
+      #   Dry::Effects.yield(Read(:current_user))
+      #
+      # @param [Effect] effect
+      # @return [Object] Result value is determined by effect type
+      # @api public
       def yield(effect)
         result = ::Fiber.yield(effect)
 
@@ -26,17 +41,33 @@ module Dry
         else
           result
         end
-      rescue FiberError => e
+      rescue ::FiberError => e
         if block_given?
           yield(effect, e)
         else
           raise Errors::UnhandledEffectError, effect
         end
       end
+
+      # Build a handler.
+      # Normally, handlers are built via mixins.
+      # This method is useful for demonstration purposes.
+      #
+      # @example providing current user
+      #
+      #   Dry::Effects[:reader, :current_user].(User.new) do
+      #     code_using_current_user.()
+      #   end
+      #
+      # @param [Array<Object>] args Handler parameters
+      # @return [Handler]
+      # @api public
+      def [](*args)
+        Handler.new(*args)
+      end
     end
   end
 end
 
-require 'dry/effects/handler'
 require 'dry/effects/all'
 require 'dry/effects/extensions'

data/lib/dry/effects/all.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
 require 'concurrent/map'
-require 'dry/effects'
 require 'dry/effects/inflector'
+require 'dry/effects/handler'
 
 module Dry
   module Effects
     default = %i[
       cache current_time random resolve defer
-      state interrupt amb retry fork parallel
+      state interrupt cmp retry fork parallel
       async implicit env lock reader timestamp
+      timeout
     ]
 
     effect_modules = ::Concurrent::Map.new

data/lib/dry/effects/constructors.rb

@@ -3,6 +3,10 @@
 module Dry
   module Effects
     module Constructors
+      def self.register(name, &block)
+        define_method(name, &block)
+        module_function name
+      end
     end
   end
 end

data/lib/dry/effects/effects/{amb.rb → cmp.rb}

@@ -5,13 +5,13 @@ require 'dry/effects/effect'
 module Dry
   module Effects
     module Effects
-      class Amb < ::Module
-        class AmbEffect < Effect
+      class Cmp < ::Module
+        class CmpEffect < Effect
           option :id
         end
 
         def initialize(id)
-          get = AmbEffect.new(type: :amb, name: :get, id: id)
+          get = CmpEffect.new(type: :cmp, name: :get, id: id)
 
           module_eval do
             define_method(:"#{id}?") { ::Dry::Effects.yield(get) }

data/lib/dry/effects/effects/current_time.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'dry/effects/effect'
+require 'dry/effects/constructors'
 
 module Dry
   module Effects
@@ -8,6 +9,14 @@ module Dry
       class CurrentTime < ::Module
         CurrentTime = Effect.new(type: :current_time)
 
+        Constructors.register(:CurrentTime) do |**kwargs|
+          if kwargs.empty?
+            CurrentTime
+          else
+            CurrentTime.payload(kwargs)
+          end
+        end
+
         def initialize(options = EMPTY_HASH)
           module_eval do
             define_method(:current_time) do |round: Undefined, refresh: false|

data/lib/dry/effects/effects/resolve.rb

@@ -9,9 +9,7 @@ module Dry
       class Resolve < ::Module
         Resolve = Effect.new(type: :resolve)
 
-        def Constructors.Resolve(key)
-          Resolve.(key)
-        end
+        Constructors.register(:Resolve) { |key| Resolve.(key) }
 
         def initialize(*keys, **aliases)
           module_eval do

data/lib/dry/effects/effects/retry.rb

@@ -1,21 +1,26 @@
 # frozen_string_literal: true
 
 require 'dry/effects/effect'
+require 'dry/effects/constructors'
 
 module Dry
   module Effects
     module Effects
       class Retry < ::Module
-        class RetryEffect < Effect
+        class Retry < Effect
           include ::Dry::Equalizer(:type, :name, :payload, :scope)
 
           option :scope
         end
 
+        Constructors.register(:Retry) do |scope|
+          Retry.new(type: :retry, scope: scope)
+        end
+
         def initialize
           module_eval do
             define_method(:repeat) do |scope|
-              effect = RetryEffect.new(type: :retry, name: :repeat, scope: scope)
+              effect = Retry.new(type: :retry, scope: scope)
               ::Dry::Effects.yield(effect)
             end
           end

data/lib/dry/effects/effects/state.rb

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
 
 require 'dry/effects/effect'
+require 'dry/effects/constructors'
 
 module Dry
   module Effects
     module Effects
       class State < ::Module
-        class StateEffect < Effect
+        class State < Effect
           include ::Dry::Equalizer(:type, :name, :payload, :scope)
 
           option :scope
         end
 
+        Constructors.register(:Read) do |scope|
+          State.new(type: :state, name: :read, scope: scope)
+        end
+
+        Constructors.register(:Write) do |scope, value|
+          State.new(type: :state, name: :write, scope: scope, payload: [value])
+        end
+
         def initialize(scope, default: Undefined, writer: true, as: scope)
-          read = StateEffect.new(type: :state, name: :read, scope: scope)
-          write = StateEffect.new(type: :state, name: :write, scope: scope)
+          read = State.new(type: :state, name: :read, scope: scope)
+          write = State.new(type: :state, name: :write, scope: scope)
 
           module_eval do
             if Undefined.equal?(default)

data/lib/dry/effects/effects/timeout.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class Timeout < ::Module
+        class TimeoutEffect < Effect
+          include ::Dry::Equalizer(:type, :name, :scope)
+
+          option :scope
+        end
+
+        def initialize(scope)
+          timeout = TimeoutEffect.new(type: :timeout, name: :timeout, scope: scope)
+
+          module_eval do
+            define_method(:timeout) do
+              ::Dry::Effects.yield(timeout)
+            end
+
+            def timed_out?
+              timeout.zero?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/errors.rb

@@ -6,6 +6,9 @@ module Dry
       module Error
       end
 
+      # No handler in the stack
+      #
+      # @api private
       class UnhandledEffectError < RuntimeError
         include Error
 
@@ -23,6 +26,9 @@ module Dry
         end
       end
 
+      # No state handler
+      #
+      # @api private
       class MissingStateError < UnhandledEffectError
         def initialize(effect)
           message = "Value of +#{effect.scope}+ is not set, "\
@@ -32,6 +38,9 @@ module Dry
         end
       end
 
+      # Uninitialized state accessed
+      #
+      # @api private
       class UndefinedStateError < RuntimeError
         include Error
 
@@ -44,10 +53,17 @@ module Dry
         end
       end
 
+      # Effect cannot be handled
+      # Some effects are not compatible without re
+      #
+      # @api private
       class EffectRejectedError < RuntimeError
         include Error
       end
 
+      # Unresolved dependency
+      #
+      # @api private
       class ResolutionError < RuntimeError
         include Error
 
@@ -56,6 +72,9 @@ module Dry
         end
       end
 
+      # State value has invalid type
+      #
+      # @api private
       class InvalidValueError < ArgumentError
         include Error
 

data/lib/dry/effects/frame.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'fiber'
+require 'dry/effects/initializer'
+require 'dry/effects/effect'
+require 'dry/effects/errors'
+require 'dry/effects/stack'
+require 'dry/effects/instructions/raise'
+
+module Dry
+  module Effects
+    # Stack frame
+    #
+    # @api private
+    class Frame
+      class << self
+        # Accessing current stack of effect handlers.
+        # It is inherently thread/fiber-local.
+        #
+        # @return [Stack]
+        # @api private
+        def stack
+          ::Thread.current[:dry_effects_stack] ||= Stack.new
+        end
+
+        # @param [Stack] stack
+        # @api private
+        def stack=(stack)
+          ::Thread.current[:dry_effects_stack] = stack
+        end
+
+        # Spawn a new fiber with a stack of effect handlers
+        #
+        # @param [Stack] stack
+        # @api private
+        def spawn_fiber(stack)
+          fiber = ::Fiber.new do
+            self.stack = stack
+            yield
+          end
+          result = fiber.resume
+
+          loop do
+            break result unless fiber.alive?
+
+            provided = stack.(result) do
+              ::Dry::Effects.yield(result) do |_, error|
+                Instructions.Raise(error)
+              end
+            end
+
+            result = fiber.resume(provided)
+          end
+        end
+      end
+
+      extend Initializer
+
+      # @!attribute provider
+      #   @return [Provider] Effects provider
+      param :provider
+
+      # Add new handler to the current stack
+      # and run the given block
+      #
+      # @param [Array<Object>] args Handler arguments
+      # @param [Proc] block Program to run
+      # @api private
+      def call(args = EMPTY_ARRAY, &block)
+        stack = Frame.stack
+
+        if stack.empty?
+          stack.push(provider.dup, args) { Frame.spawn_fiber(stack, &block) }
+        else
+          stack.push(provider.dup, args, &block)
+        end
+      end
+    end
+  end
+end