dry-effects 0.1.0.alpha

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+require 'dry/effects/constructors'
+
+module Dry
+  module Effects
+    module Effects
+      class Resolve < ::Module
+        Resolve = Effect.new(type: :resolve)
+
+        def Constructors.Resolve(key)
+          Resolve.(key)
+        end
+
+        def initialize(*keys, **aliases)
+          module_eval do
+            (keys.zip(keys) + aliases.to_a).each do |name, key|
+              define_method(name) { |&block| ::Dry::Effects.yield(Resolve.(key), &block) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry/effects/effect'
+
+module Dry
+  module Effects
+    module Effects
+      class State < ::Module
+        class StateEffect < Effect
+          include ::Dry::Equalizer(:type, :name, :payload, :scope)
+
+          option :scope
+        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)
+
+          module_eval do
+            if Undefined.equal?(default)
+              define_method(as) do |&block|
+                if block
+                  Undefined.default(::Dry::Effects.yield(read) { Undefined }, &block)
+                else
+                  value = ::Dry::Effects.yield(read) { raise Errors::MissingStateError, read }
+
+                  Undefined.default(value) { raise Errors::UndefinedStateError, read }
+                end
+              end
+            else
+              define_method(as) do |&block|
+                if block
+                  Undefined.default(::Dry::Effects.yield(read) { Undefined }, &block)
+                else
+                  Undefined.default(::Dry::Effects.yield(read) { Undefined }, default)
+                end
+              end
+            end
+
+            if writer
+              define_method(:"#{as}=") do |value|
+                ::Dry::Effects.yield(write.(value))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/errors.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Dry
+  module Effects
+    module Errors
+      module Error
+      end
+
+      class UnhandledEffectError < RuntimeError
+        include Error
+
+        attr_reader :effect
+
+        def initialize(effect, message = Undefined)
+          @effect = effect
+
+          super(
+            Undefined.default(message) {
+              "Effect #{effect.inspect} not handled. "\
+              'Effects must be wrapped with corresponding handlers'
+            }
+          )
+        end
+      end
+
+      class MissingStateError < UnhandledEffectError
+        def initialize(effect)
+          message = "Value of +#{effect.scope}+ is not set, "\
+                    'you need to provide value with an effect handler'
+
+          super(effect, message)
+        end
+      end
+
+      class UndefinedStateError < RuntimeError
+        include Error
+
+        def initialize(effect)
+          message = "+#{effect.scope}+ is not defined, you need to assign it first "\
+                    'by using a writer, passing initial value to the handler, or '\
+                    'providing a fallback value'
+
+          super(message)
+        end
+      end
+
+      class EffectRejectedError < RuntimeError
+        include Error
+      end
+
+      class ResolutionError < RuntimeError
+        include Error
+
+        def initialize(key)
+          super("Key +#{key.inspect}+ cannot be resolved")
+        end
+      end
+
+      class InvalidValueError < ArgumentError
+        include Error
+
+        def initialize(value, scope)
+          super("#{value.inspect} is invalid and cannot be assigned to #{scope}")
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/extensions.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'dry/core/extensions'
+
+Dry::Effects.extend(Dry::Core::Extensions)
+
+Dry::Effects.register_extension(:auto_inject) do
+  require 'dry/effects/extensions/auto_inject'
+end
+
+Dry::Effects.register_extension(:system) do
+  require 'dry/effects/extensions/system'
+end

data/lib/dry/effects/extensions/auto_inject.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'concurrent/map'
+require 'dry/auto_inject/strategies/constructor'
+require 'dry/effects/effects/resolve'
+
+module Dry
+  module Effects
+    class DryAutoEffectsStrategies
+      extend Dry::Container::Mixin
+
+      class Base < AutoInject::Strategies::Constructor
+        private
+
+        def define_new
+          # nothing to do
+        end
+
+        def define_initialize(_)
+          # nothing to do
+        end
+      end
+
+      class Static < Base
+        private
+
+        def define_readers(dynamic = false)
+          map = dependency_map.to_h
+          cache = ::Concurrent::Map.new
+          instance_mod.class_exec do
+            map.each do |name, identifier|
+              resolve = ::Dry::Effects::Constructors::Resolve(identifier)
+
+              if dynamic
+                define_method(name) { ::Dry::Effects.yield(resolve) }
+              else
+                define_method(name) do
+                  cache.fetch_or_store(name) do
+                    ::Dry::Effects.yield(resolve)
+                  end
+                end
+              end
+            end
+          end
+          self
+        end
+      end
+
+      class Dynamic < Static
+        private
+
+        def define_readers(dynamic = true)
+          super
+        end
+      end
+
+      register :static, Static
+      register :dynamic, Dynamic
+      register :default, Static
+    end
+
+    def self.AutoInject(dynamic: false)
+      mod = Dry.AutoInject(EMPTY_HASH, strategies: DryAutoEffectsStrategies)
+      dynamic ? mod.dynamic : mod
+    end
+  end
+end

data/lib/dry/effects/extensions/system.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'dry/system/container'
+
+Dry::Effects.load_extensions(:auto_inject)
+
+module Dry
+  module Effects
+    module System
+      class AutoRegistrar < ::Dry::System::AutoRegistrar
+        def call(dir)
+          super do |config|
+            config.memoize = true
+            config.instance { |c| c.instance.freeze }
+            yield(config) if block_given?
+          end
+        end
+      end
+
+      class Container < ::Dry::System::Container
+        setting :auto_registrar, AutoRegistrar
+
+        def self.injector(effects: true, **kwargs)
+          if effects
+            Dry::Effects.AutoInject(**kwargs)
+          else
+            super()
+          end
+        end
+
+        def self.finalize!
+          return self if finalized?
+
+          super
+
+          # Force all components to load
+          each_key { |key| resolve(key) }
+          self
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/halt.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'concurrent/map'
+require 'dry/core/class_attributes'
+require 'dry/effects/inflector'
+
+module Dry
+  module Effects
+    class Halt < StandardError
+      extend Core::ClassAttributes
+
+      @constants = ::Concurrent::Map.new
+
+      def self.[](key)
+        @constants.fetch_or_store(key) do
+          klass = ::Class.new(Halt)
+          const_set(Inflector.camelize(key), klass)
+        end
+      end
+
+      attr_reader :payload
+
+      def initialize(payload = Undefined)
+        super(EMPTY_STRING)
+        @payload = payload
+      end
+    end
+  end
+end

data/lib/dry/effects/handler.rb

@@ -0,0 +1,58 @@
+# 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?
+
+            provided = stack.(result) do
+              ::Dry::Effects.yield(result) do |_, error|
+                Instructions.Raise(error)
+              end
+            end
+
+            result = fiber.resume(provided)
+          end
+        end
+      end
+
+      extend Initializer
+
+      param :provider
+
+      def call(args = EMPTY_ARRAY, &block)
+        stack = Handler.stack
+
+        if stack.empty?
+          stack.push(provider.dup, args) { Handler.spawn_fiber(stack, &block) }
+        else
+          stack.push(provider.dup, args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/dry/effects/inflector.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'dry/inflector'
+
+module Dry
+  module Effects
+    Inflector = ::Dry::Inflector.new
+  end
+end

data/lib/dry/effects/initializer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'dry/initializer'
+
+module Dry
+  module Effects
+    module Initializer
+      # @api private
+      module DefineWithHook
+        # @api private
+        def param(*)
+          super.tap do
+            @params_arity = nil
+            __define_with__
+          end
+        end
+
+        # @api private
+        def option(*)
+          super.tap do
+            __define_with__ unless method_defined?(:with)
+            @has_options = true
+          end
+        end
+
+        # @api private
+        def params_arity
+          @params_arity ||= begin
+            dry_initializer
+              .definitions
+              .reject { |_, d| d.option }
+              .size
+          end
+        end
+
+        # @api private
+        def options?
+          return @has_options if defined? @has_options
+          @has_options = false
+        end
+
+        # @api private
+        def __define_with__
+          seq_names = dry_initializer
+            .definitions
+            .reject { |_, d| d.option }
+            .keys
+            .join(', ')
+
+          seq_names << ', ' unless seq_names.empty?
+
+          undef_method(:with) if method_defined?(:with)
+
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def with(new_options = EMPTY_HASH)
+              if new_options.empty?
+                self
+              else
+                self.class.new(#{seq_names}options.merge(new_options))
+              end
+            end
+          RUBY
+        end
+      end
+
+      # @api private
+      def self.extended(base)
+        base.extend(::Dry::Initializer)
+        base.extend(DefineWithHook)
+        base.include(InstanceMethods)
+      end
+
+      # @api private
+      module InstanceMethods
+        # Instance options
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def options
+          @__options__ ||= self.class.dry_initializer.definitions.values.each_with_object({}) do |item, obj|
+            obj[item.target] = instance_variable_get(item.ivar)
+          end
+        end
+
+        define_method(:class, Kernel.instance_method(:class))
+        define_method(:instance_variable_get, Kernel.instance_method(:instance_variable_get))
+
+        # This makes sure we memoize options before an object becomes frozen
+        #
+        # @api public
+        def freeze
+          options
+          super
+        end
+      end
+    end
+  end
+end