dry-effects 0.1.0.alpha2 → 0.1.0

data/lib/dry/effects/handler.rb

@@ -1,58 +1,25 @@
 # 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
     class Handler
-      class << self
-        def stack
-          ::Thread.current[:dry_effects_stack] ||= Stack.new
-        end
-
-        def stack=(stack)
-          ::Thread.current[:dry_effects_stack] = stack
-        end
-
-        def spawn_fiber(stack)
-          fiber = ::Fiber.new do
-            self.stack = stack
-            yield
-          end
-          result = fiber.resume
-
-          loop do
-            break result unless fiber.alive?
+      attr_reader :provider
 
-            provided = stack.(result) do
-              ::Dry::Effects.yield(result) do |_, error|
-                Instructions.Raise(error)
-              end
-            end
+      attr_reader :frame
 
-            result = fiber.resume(provided)
-          end
-        end
+      def initialize(type, *args)
+        @provider = ::Dry::Effects.providers[type].new(*args)
+        @frame = Frame.new(provider)
       end
 
-      extend Initializer
-
-      param :provider
-
-      def call(args = EMPTY_ARRAY, &block)
-        stack = Handler.stack
+      def call(*args, &block)
+        frame.(args, &block)
+      end
 
-        if stack.empty?
-          stack.push(provider.dup, args) { Handler.spawn_fiber(stack, &block) }
-        else
-          stack.push(provider.dup, args, &block)
-        end
+      def to_s
+        "#<Dry::Effects::Handler #{provider.represent}>"
       end
+      alias_method :inspect, :to_s
     end
   end
 end

data/lib/dry/effects/provider.rb

@@ -5,22 +5,41 @@ require 'dry/effects/provider/class_interface'
 
 module Dry
   module Effects
+    # Base class for effect providers
+    #
+    # @api private
     class Provider
       extend Initializer
       extend ClassInterface
 
+      # yield the block with the handler installed
+      #
+      # @api private
       def call(_stack)
         yield
       end
 
+      # Effect-specific representation of the provider
+      #
+      # @return [String]
+      # @api public
       def represent
         type.to_s
       end
 
+      # Effect type
+      #
+      # @return [Symbol]
+      # @api public
       def type
         self.class.type
       end
 
+      # Whether the effect can be handled?
+      #
+      # @param [Effect] effect
+      # @return [Boolean]
+      # @api public
       def provide?(effect)
         type.equal?(effect.type)
       end

data/lib/dry/effects/provider/class_interface.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'dry/core/class_attributes'
+require 'dry/effects/frame'
 
 module Dry
   module Effects
@@ -30,7 +31,7 @@ module Dry
         def [](type)
           if self < Provider
             Provider.effects.fetch(type) do
-              Provider.effects[type] = Class.new(self).tap do |subclass|
+              Provider.effects[type] = ::Class.new(self).tap do |subclass|
                 subclass.type type
               end
             end
@@ -43,11 +44,11 @@ module Dry
           handle_method = handle_method(*args, **kwargs)
 
           provider = new(*args, **kwargs).freeze
-          handler = Handler.new(provider)
+          frame = Frame.new(provider)
 
           ::Module.new do
             define_method(handle_method) do |*xs, &block|
-              handler.(xs, &block)
+              frame.(xs, &block)
             end
           end
         end

data/lib/dry/effects/providers/async.rb

@@ -17,9 +17,12 @@ module Dry
         end
 
         def await(task)
-          Handler.spawn_fiber(stack, &@tasks.delete(task))
+          Frame.spawn_fiber(stack, &@tasks.delete(task))
         end
 
+        # Yield the block with the handler installed
+        #
+        # @api private
         def call(stack)
           @stack = stack
           super

data/lib/dry/effects/providers/cache.rb

@@ -21,15 +21,23 @@ module Dry
           end
         end
 
+        # Yield the block with the handler installed
+        #
+        # @api private
         def call(stack, cache = EMPTY_HASH.dup)
           @cache = cache
           super(stack)
         end
 
+        # @param [Effect] effect
+        # @return [Boolean]
+        # @api public
         def provide?(effect)
           super && scope.eql?(effect.scope)
         end
 
+        # @return [String]
+        # @api public
         def represent
           if cache.empty?
             "cache[#{scope} empty]"

data/lib/dry/effects/providers/cmp.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry/effects/provider'
+
+module Dry
+  module Effects
+    module Providers
+      class Cmp < Provider[:cmp]
+        include Dry::Equalizer(:id, :value)
+
+        attr_reader :value
+
+        param :id
+
+        def get
+          value
+        end
+
+        # Yield the block with the handler installed
+        #
+        # @return [Array(Any, Any)]
+        # @api private
+        def call(stack, value = Undefined)
+          if Undefined.equal?(value)
+            @value = false
+            first = super(stack)
+            @value = true
+            [first, super(stack)]
+          else
+            @value = value
+            super(stack)
+          end
+        end
+
+        # @param [Effect] effect
+        # @return [Boolean]
+        # @api public
+        def provide?(effect)
+          super && id.equal?(effect.id)
+        end
+
+        # @return [String]
+        # @api public
+        def represent
+          "cmp[#{id}=#{@value}]"
+        end
+      end
+    end
+  end
+end

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

@@ -20,31 +20,14 @@ module Dry
 
         attr_reader :generator
 
+        # Yield the block with the handler installed
+        #
+        # @api private
         def call(stack, generator = Undefined, **options)
           @generator = build_generator(generator, **options)
           super(stack)
         end
 
-        def build_generator(generator, step: Undefined, initial: Undefined, overridable: false)
-          if overridable
-            parent = ::Dry::Effects.yield(Locate) { nil }
-          else
-            parent = nil
-          end
-
-          if !parent.nil?
-            -> options { parent.current_time(options) }
-          elsif !Undefined.equal?(generator)
-            generator
-          elsif !Undefined.equal?(step)
-            IncrementingTimeGenerator.(initial, step)
-          elsif fixed?
-            FixedTimeGenerator.()
-          else
-            RunningTimeGenerator.()
-          end
-        end
-
         def current_time(round_to: Undefined, **options)
           time = generator.(**options)
 
@@ -57,17 +40,51 @@ module Dry
           end
         end
 
+        # Locate handler in the stack
+        #
+        # @return [Provider]
+        # @api private
         def locate
           self
         end
 
+        # @return [String]
+        # @api public
         def represent
           if fixed?
-            "current_time[fixed=#{generator.().iso8601(6)}]"
+            if generator.nil?
+              'current_time[fixed=true]'
+            else
+              "current_time[fixed=#{generator.().iso8601(6)}]"
+            end
           else
             'current_time[fixed=false]'
           end
         end
+
+        private
+
+        # @return [Proc] time generator
+        # @api private
+        def build_generator(generator, step: Undefined, initial: Undefined, overridable: false)
+          if overridable
+            parent = ::Dry::Effects.yield(Locate) { nil }
+          else
+            parent = nil
+          end
+
+          if !parent.nil?
+            -> **options { parent.current_time(**options) }
+          elsif !Undefined.equal?(generator)
+            generator
+          elsif !Undefined.equal?(step)
+            IncrementingTimeGenerator.(initial, step)
+          elsif fixed?
+            FixedTimeGenerator.()
+          else
+            RunningTimeGenerator.()
+          end
+        end
       end
     end
   end

data/lib/dry/effects/providers/defer.rb

@@ -19,21 +19,21 @@ module Dry
           stack = self.stack.dup
           at = Undefined.default(executor, self.executor)
           ::Concurrent::Promise.execute(executor: at) do
-            Handler.spawn_fiber(stack, &block)
+            Frame.spawn_fiber(stack, &block)
           end
         end
 
         def later(block, executor)
           if @later_calls.frozen?
             Instructions.Raise(Errors::EffectRejectedError.new(<<~MSG))
-              .later calls are not allowed, they would processed
+              .later calls are not allowed, they would be processed
               by another stack. Add another defer handler to the current stack
             MSG
           else
             at = Undefined.default(executor, self.executor)
             stack = self.stack.dup
             @later_calls << ::Concurrent::Promise.new(executor: at) do
-              Handler.spawn_fiber(stack, &block)
+              Frame.spawn_fiber(stack, &block)
             end
             nil
           end
@@ -47,6 +47,9 @@ module Dry
           end
         end
 
+        # Yield the block with the handler installed
+        #
+        # @api private
         def call(stack, executor: Undefined)
           unless Undefined.equal?(executor)
             @executor = executor
@@ -67,6 +70,8 @@ module Dry
           end
         end
 
+        # @return [String]
+        # @api public
         def represent
           info = []
           info << executor.to_s if executor.is_a?(::Symbol)

data/lib/dry/effects/providers/env.rb

@@ -30,10 +30,17 @@ module Dry
         end
         protected :fetch
 
+        # Locate handler in the stack
+        #
+        # @return [Provider]
+        # @api private
         def locate
           self
         end
 
+        # Yield the block with the handler installed
+        #
+        # @api private
         def call(stack, values = EMPTY_HASH, options = EMPTY_HASH)
           unless values.empty?
             @values = @values.merge(values)
@@ -48,6 +55,9 @@ module Dry
           super(stack)
         end
 
+        # @param [Effect] effect
+        # @return [Boolean]
+        # @api public
         def provide?(effect)
           if super
             !effect.name.equal?(:read) || key?(effect.payload[0])

data/lib/dry/effects/providers/fork.rb

@@ -10,7 +10,7 @@ module Dry
 
         def fork
           stack = self.stack.dup
-          -> &cont { Handler.spawn_fiber(stack.dup, &cont) }
+          -> &cont { Frame.spawn_fiber(stack.dup, &cont) }
         end
 
         def call(stack)

data/lib/dry/effects/providers/implicit.rb

@@ -18,6 +18,9 @@ module Dry
           dictionary.fetch(arg.class)
         end
 
+        # Yield the block with the handler installed
+        #
+        # @api private
         def call(stack, dynamic = EMPTY_HASH)
           if dynamic.empty?
             @dictionary = static
@@ -28,6 +31,9 @@ module Dry
           super(stack)
         end
 
+        # @param [Effect] effect
+        # @return [Boolean]
+        # @api public
         def provide?(effect)
           super &&
             dependency.equal?(effect.dependency) &&

data/lib/dry/effects/providers/interrupt.rb

@@ -14,20 +14,28 @@ module Dry
           Instructions.Raise(halt.new(payload))
         end
 
+        # Yield the block with the handler installed
+        #
+        # @api private
         def call(_stack)
-          yield
+          [false, yield]
         rescue halt => e
-          e.payload[0]
+          [true, e.payload[0]]
         end
 
         def halt
           Halt[scope]
         end
 
+        # @return [String]
+        # @api public
         def represent
           "interrupt[#{scope}]"
         end
 
+        # @param [Effect] effect
+        # @return [Boolean]
+        # @api public
         def provide?(effect)
           super && scope.equal?(effect.scope)
         end