attr-gather 1.0.0

data/lib/attr/gather/aggregators/deep_merge.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'attr/gather/aggregators/base'
+
+module Attr
+  module Gather
+    module Aggregators
+      # Deep merges result hashes
+      #
+      # @api public
+      class DeepMerge < Base
+        # Initialize a new DeepMerge aggregator
+        #
+        # @param reverse [Boolean] deep merge results in reverse order
+        #
+        # @api private
+        def initialize(reverse: false, **)
+          @reverse = reverse
+          super
+        end
+
+        def call(input, execution_results)
+          execution_results = execution_results.reverse_each if reverse?
+
+          result = execution_results.reduce(input.dup) do |memo, res|
+            deep_merge(memo, unwrap_result(res))
+          end
+
+          wrap_result(result)
+        end
+
+        private
+
+        def reverse?
+          @reverse
+        end
+
+        def deep_merge(hash, other)
+          Hash[hash].merge(other) do |_, orig, new|
+            if orig.respond_to?(:to_hash) && new.respond_to?(:to_hash)
+              deep_merge(Hash[orig], Hash[new])
+            else
+              new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/aggregators/shallow_merge.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'attr/gather/aggregators/base'
+
+module Attr
+  module Gather
+    module Aggregators
+      # Shallowly merges results
+      #
+      # @api public
+      class ShallowMerge < Base
+        # Initialize a new DeepMerge aggregator
+        #
+        # @param reverse [Boolean] merge results in reverse order
+        #
+        # @api private
+        def initialize(reverse: false, **)
+          @reverse = reverse
+          super
+        end
+
+        def call(input, execution_results)
+          items = reverse? ? execution_results.reverse_each : execution_results
+
+          result = items.reduce(input.dup) do |memo, res|
+            memo.merge(unwrap_result(res))
+          end
+
+          wrap_result(result)
+        end
+
+        private
+
+        def reverse?
+          @reverse
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/concerns/identifiable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Attr
+  module Gather
+    module Concerns
+      # Makes an entity identifiable by adding a #uuid attribute
+      #
+      # @!attribute [r] uuid
+      #   @return [String] UUID of the result
+      module Identifiable
+        def initialize(*)
+          @uuid = SecureRandom.uuid
+          super
+        end
+
+        def self.included(klass)
+          klass.attr_reader(:uuid)
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/concerns/registrable.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Attr
+  module Gather
+    # Makes a module registrable
+    module Registrable
+      # Error raised when item is already registered
+      class AlreadyRegisteredError < Error; end
+
+      # Error raised when item is not found
+      class NotFoundError < Attr::Gather::Error; end
+
+      def self.extended(klass)
+        klass.instance_variable_set(:@__storage__, {})
+      end
+
+      # Register item so it can be accessed by name
+      #
+      # @param name [Symbol] name of the item
+      # @yield [options] block to initialize the item
+      def register(name, &blk)
+        name = name.to_sym
+
+        @__storage__[name] = blk
+      end
+
+      # Resolve a named item
+      #
+      # @param name [Symbol]
+      #
+      # @return [#call]
+      def resolve(name, *args)
+        block = @__storage__.fetch(name) do
+          raise NotFoundError,
+                "no item with name #{name} registered"
+        end
+
+        block.call(*args)
+      end
+
+      # @api private
+      def ensure_name_not_already_registered!(name)
+        return unless @__storage__.key?(name)
+
+        raise AlreadyRegisteredError,
+              "item with name #{name} already registered"
+      end
+    end
+  end
+end

data/lib/attr/gather/filters.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'attr/gather/filters/base'
+require 'attr/gather/filters/result'
+require 'attr/gather/filters/filtering'
+require 'attr/gather/concerns/registrable'
+
+module Attr
+  module Gather
+    # Namespace for filters
+    module Filters
+      extend Registrable
+
+      # The default filter if none is specified
+      #
+      # @return [Attr::Gather::Filters::Noop]
+      def self.default
+        @default = resolve(:noop)
+      end
+
+      register(:contract) do |contract|
+        require 'attr/gather/filters/contract'
+
+        Contract.new(contract)
+      end
+
+      register(:noop) do |*|
+        require 'attr/gather/filters/noop'
+
+        Noop.new
+      end
+    end
+  end
+end

data/lib/attr/gather/filters/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Attr
+  module Gather
+    module Filters
+      # @abstract Subclass and override {#call} to implement
+      #   a custom Filter class.
+      class Base
+        # Applies the filter
+        #
+        # @param _input [Hash]
+        #
+        # @return [Attr::Gather::Filter::Result]
+        def call(_input)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/filters/contract.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Attr
+  module Gather
+    module Filters
+      # Filters values with a dry-validation contract
+      class Contract < Base
+        class IncompatibleContractError < Error; end
+
+        attr_reader :dry_contract
+
+        # Creates a new instance of the filter
+        #
+        # @param dry_contract [Dry::Contract]
+        def initialize(dry_contract)
+          validate_dry_contract!(dry_contract)
+
+          @dry_contract = dry_contract
+        end
+
+        def call(input)
+          value, filterings = filter_validation_errors input.dup
+
+          Result.new(value, filterings)
+        end
+
+        private
+
+        def filter_validation_errors(unvalidated)
+          contract_result = dry_contract.call(unvalidated)
+          errors = contract_result.errors
+          contract_hash = contract_result.to_h
+          errors.each { |err| filter_error_from_input(err, contract_hash) }
+          filterings = transform_errors_to_filtered_attributes(errors)
+
+          [contract_hash, filterings]
+        end
+
+        def filter_error_from_input(error, input)
+          *path, key_to_delete = error.path
+          target = path.empty? ? input : input.dig(*path)
+          target.delete(key_to_delete)
+        end
+
+        def transform_errors_to_filtered_attributes(errors)
+          errors.map do |err|
+            Filtering.new(err.path, err.text, err.input)
+          end
+        end
+
+        def validate_dry_contract!(con)
+          return if con.respond_to?(:call) && con.class.respond_to?(:schema)
+
+          raise IncompatibleContractError,
+                "contract is not compatible (#{con.inspect})"
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/filters/filtering.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Attr
+  module Gather
+    module Filters
+      # Information about a filtered item
+      #
+      # @!attribute [r] path
+      #   @return [Hash] path of the filtered key
+      #
+      # @!attribute [r] reason
+      #   @return [String] why the item was filtered
+      #
+      # @!attribute [r] input
+      #   @return [String] input value that was filtered
+      class Filtering
+        attr_reader :path, :reason, :input
+
+        def initialize(path, reason, input)
+          @path = path
+          @reason = reason
+          @input = input
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/filters/noop.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Attr
+  module Gather
+    module Filters
+      # Does not perform any filtering
+      class Noop < Base
+        def call(input)
+          Result.new(input, [])
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/filters/result.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Attr
+  module Gather
+    module Filters
+      # Result of a filter
+      #
+      # @!attribute [r] value
+      #   @return [Hash] the filtered hash
+      #
+      # @!attribute [r] filterings
+      #   @return [Array<Attr::Gather::Filtering>] info about filtered items
+      class Result
+        attr_reader :value, :filterings
+
+        def initialize(value, filterings)
+          @value = value
+          @filterings = filterings
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Attr
+  module Gather
+    VERSION = '1.0.0'
+  end
+end

data/lib/attr/gather/workflow.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'attr/gather/concerns/identifiable'
+require 'attr/gather/workflow/task'
+require 'attr/gather/workflow/task_graph'
+require 'attr/gather/workflow/dsl'
+require 'attr/gather/workflow/callable'
+require 'attr/gather/workflow/graphable'
+
+module Attr
+  module Gather
+    # Main mixin for functionality. Adds the ability to turn a class into a
+    # workflow.
+    module Workflow
+      # @!parse extend DSL
+      # @!parse include Callable
+      # @!parse extend Graphable::ClassMethods
+      # @!parse include Graphable::InstanceMethods
+      # @!parse include Concerns::Identifiable
+
+      def self.included(klass)
+        klass.extend(DSL)
+        klass.include(Callable)
+        klass.include(Graphable)
+        klass.include(Concerns::Identifiable)
+      end
+    end
+  end
+end

data/lib/attr/gather/workflow/async_task_executor.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'attr/gather/workflow/task_executor'
+
+module Attr
+  module Gather
+    module Workflow
+      # @api private
+      class AsyncTaskExecutor < TaskExecutor
+        def initialize(*)
+          super
+          @executor = :io
+        end
+      end
+    end
+  end
+end

data/lib/attr/gather/workflow/callable.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'attr/gather/workflow/task_executor'
+require 'attr/gather/workflow/async_task_executor'
+
+module Attr
+  module Gather
+    module Workflow
+      # @api private
+      module Callable
+        # Execute a workflow
+        #
+        # When executing the workflow, tasks are processed in dependant order,
+        # with the outputs of each batch being fed as inputs to the next batch.
+        # This means the you can enhance the data as the task moves through a
+        # workflow, so later tasks can use the enhanced input data.
+        #
+        # @example
+        #   enhancer = MyEnhancingWorkflow.new
+        #   enhancer.call(user_id: 1).value! # => {user_id: 1, email: 't@t.co}
+        #
+        # @param input [Hash]
+        #
+        # @return [Concurrent::Promise]
+        #
+        # @note For more information, check out {https://dry-rb.org/gems/dry-monads/1.0/result}
+        #
+        # @api public
+        def call(input)
+          final_results = []
+
+          each_task_batch.reduce(input.dup) do |aggregated_input, batch|
+            executor_results = execute_batch(aggregated_input, batch)
+            final_results << executor_results
+            aggregator.call(aggregated_input, executor_results).value!
+          end
+
+          aggregator.call(input.dup, final_results.flatten(1))
+        end
+
+        private
+
+        # Enumator for task batches
+        #
+        # @return [Enumerator]
+        #
+        # @api private
+        def each_task_batch
+          self.class.tasks.each_batch
+        end
+
+        # Executes a batch of tasks
+        #
+        # @return [Array<TaskExecutionResult>]
+        #
+        # @api private
+        def execute_batch(aggregated_input, batch)
+          executor = AsyncTaskExecutor.new(batch, container: container)
+          executor.call(aggregated_input)
+        end
+
+        # @api private
+        def container
+          self.class.container
+        end
+
+        # @api private
+        def aggregator
+          return @aggregator if defined?(@aggregator) && !@aggregator.nil?
+
+          @aggregator = self.class.aggregator
+          @aggregator.filter ||= filter
+
+          @aggregator
+        end
+
+        # @api private
+        def filter
+          self.class.filter
+        end
+      end
+    end
+  end
+end