remap 2.0.2

data/lib/remap/state/extension.rb

@@ -0,0 +1,393 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/deep_transform_values"
+
+module Remap
+  module State
+    module Extension
+      refine Object do
+        def _(&block)
+          unless block
+            return _ { raise _1 }
+          end
+
+          block["Expected a state, got [#{self}] (#{self.class})"]
+        end
+
+        def paths
+          EMPTY_ARRAY
+        end
+
+        def get(*path)
+          throw :missing, path
+        end
+      end
+
+      refine Array do
+        def hide(value)
+          reverse.reduce(value) do |element, key|
+            { key => element }
+          end
+        end
+
+        def get(*path, last)
+          if path.empty?
+            return fetch(last) do
+              throw :missing, path + [last]
+            end
+          end
+
+          dig(*path).fetch(last) do
+            throw :missing, path + [last]
+          end
+        end
+      end
+
+      refine Hash do
+        def _(&block)
+          unless block
+            return _ { raise "Input: #{self} output: #{JSON.pretty_generate(_1)}" }
+          end
+
+          unless (result = Schema.call(self)).success?
+            return block[result.errors.to_h]
+          end
+
+          self
+        end
+
+        def paths
+          reduce(EMPTY_ARRAY) do |acc, (path, leaves)|
+            if (paths = leaves.paths).empty?
+              next acc + [[path]]
+            end
+
+            acc + paths.map { |inner| [path] + inner }
+          end
+        end
+
+        def paths_pair
+          paths.map do |path|
+            [dig(*path), path]
+          end
+        end
+
+        # Makes the state iterable
+        #
+        # @yieldparam value [Any]
+        # @yieldoption key [Symbol]
+        # @yieldoption index [Integer]
+        #
+        # @yieldreturn [State]
+        #
+        # @return [State]
+        def map(&block)
+          bind do |value, state|
+            Iteration.call(state: state, value: value).call do |other, **options|
+              state.set(other, **options)._.then(&block)._
+            end
+          end
+        end
+
+        # @return [String]
+        def inspect
+          reject { _2.blank? }.then do |cleaned|
+            format("#<State %<json>s>", json: JSON.pretty_generate(cleaned))
+          end
+        end
+
+        # Merges {self} with {other} and returns a new state
+        #
+        # @param other [State]
+        #
+        # @return [State]
+        def merged(other)
+          all_problems = problems.deep_merge(other.problems) do |key, a, b|
+            case [a, b]
+            in [Array, Array]
+              a + b
+            else
+              raise ArgumentError, "Can't merge #{a.inspect} with #{b.inspect} @ #{key}"
+            end
+          end
+
+          catch :undefined do
+            value = recursive_merge(other) do |reason|
+              return merge(problems: all_problems).problem(reason)
+            end
+
+            return set(value, problems: all_problems)
+          end
+
+          set(problems: all_problems)
+        end
+
+        # Resolves conflicts unsovable by ActiveSupport#deep_merge
+        #
+        # @param key [Symbol] the key that cannot be merged
+        # @param left [Any] the left value that cannot be merged
+        # @param right [Any] the right value that cannot be merged
+        #
+        # @yieldparam reason [String] if {left} and {right} cannot be merged
+        # @yieldreturn [State]
+        #
+        # @return [Any]
+        def conflicts(key, left, right, &error)
+          case [left, right]
+          in [Array, Array]
+            left + right
+          in [value, ^value]
+            value
+          in [left, right]
+            reason(left, right) do |reason|
+              [reason, "[#{key}]"].join(" @ ").then(&error)
+            end
+          end
+        end
+
+        def get(*path, last)
+          if path.empty?
+            return fetch(last) do
+              throw :missing, path + [last]
+            end
+          end
+
+          dig(*path).fetch(last) do
+            throw :missing, path + [last]
+          end
+        end
+
+        # Recursively merges {self} with {other}
+        # Invokes {error} when a conflict is detected
+        #
+        # @param other [State]
+        #
+        # @yieldparam key [Symbol]
+        # @yieldparam left [Any]
+        # @yieldparam right [Any]
+        # @yieldparam error [Proc]
+        #
+        # @yieldreturn [Any]
+        #
+        # @return [Any] Merge result (not a state)
+        def recursive_merge(other, &error)
+          case [self, other]
+          in [{value: Hash => left}, {value: Hash => right}]
+            left.deep_merge(right) { |*args| conflicts(*args, &error) }
+          in [{value: Array => left}, {value: Array => right}]
+            left + right
+          in [{value: left}, {value: right}]
+            reason(left, right, &error)
+          in [{value: left}, _]
+            left
+          in [_, {value: right}]
+            right
+          in [_, _]
+            throw :undefined
+          end
+        end
+
+        def reason(left, right, &error)
+          params = { left: left, cleft: left.class, right: right, cright: right.class }
+          message = format("Could not merge [%<left>p] (%<cleft>s) with [%<right>p] (%<cright>s)", params)
+          error[message]
+        end
+
+        # Creates a new state with params
+        #
+        # @param value [Any, Undefined] Used as {value:}
+        # @options [Hash] To be merged into {self}
+        #
+        # @return [State]
+        def set(value = Undefined, **options)
+          if value != Undefined
+            return set(**options, value: value)
+          end
+
+          case [self, options]
+          in [{path:}, {quantifier:, **rest}]
+            merge(path: path + [quantifier]).set(**rest)
+          in [_, {mapper:, value:, **rest}]
+            merge(scope: value, value: value, mapper: mapper).set(**rest)
+          in [{value:}, {mapper:, **rest}]
+            merge(scope: value, mapper: mapper).set(**rest)
+          in [{path:}, {key:, **rest}]
+            merge(path: path + [key], key: key).set(**rest)
+          in [{path:}, {index:, value:, **rest}]
+            merge(path: path + [index], element: value, index: index, value: value).set(**rest)
+          in [{path:}, {index:, **rest}]
+            merge(path: path + [index], index: index).set(**rest)
+          else
+            merge(options)
+          end
+        end
+
+        # Passes {#value} to block, if defined
+        # The return value is then wrapped in a state
+        # and returned with {options} merged into the state
+        #
+        # @yieldparam value [T]
+        # @yieldparam self [State]
+        # @yieldparam error [Proc]
+        #
+        # @yieldreturn [Y]
+        #
+        # @return [State<Y>]
+        def fmap(**options, &block)
+          bind(**options) do |input, state, &error|
+            state.set(block[input, state, &error])
+          end
+        end
+
+        def failure(reason)
+          explaination(reason)
+        end
+
+        def explaination(reason, explainations = EMPTY_HASH)
+          Remap::Types::Report::Self[explainations]
+
+          report = ->(message) { [{}.merge(reason: message)] }
+
+          explaination = case [self, reason]
+          in [{path: []}, String]
+            { base: report[reason] }
+          in [{path:}, String]
+            path.hide(report[reason])
+          in [{path:}, Hash]
+            reason.paths_pair.reduce(EMPTY_HASH) do |acc, (item, suffix)|
+              Array.wrap(item).map { (path + suffix).hide(report[_1]) }.reduce(acc, &:deep_merge)
+            end
+          end
+
+          output = explainations.deep_merge(explaination) do |key, left, right|
+            case [left, right]
+            in [Array, Array]
+              left + right
+            else
+              raise ArgumentError, "Cannot merge #{left} with #{right} @ #{key}"
+            end
+          end
+
+          # Remap::Types::Report::Self[output] do
+          #   binding.pry
+          # end
+        end
+
+        def no_of_problems
+          a = problems.except(:base).paths.count
+          b = problems.fetch(:base, []).count
+          a + b
+        end
+
+        # Passes {#value} to block, if defined
+        # {options} are merged into the final state
+        #
+        # @yieldparam value [T]
+        # @yieldparam self [State]
+        # @yieldparam error [Proc]
+        #
+        # @yieldreturn [Y]
+        #
+        # @return [Y]
+        def bind(**options, &block)
+          unless block
+            raise ArgumentError, "no block given"
+          end
+
+          fetch(:value) { return self }.then do |value|
+            block[value, self] do |reason, **other|
+              return set(**options, **other).problem(reason)._
+            end
+          end
+        end
+
+        # Execute {block} in the current context
+        # Only calls {block} if {#value} is defined
+        #
+        # @yieldparam value [T]
+        # @yieldreturn [U]
+        #
+        # @return [State<U>]
+        def execute(&block)
+          bind do |value, &error|
+            catch :success do
+              path = catch :missing do
+                throw :success, set(context(value, &error).instance_exec(value, &block))._
+              end
+
+              return error["Could not fetch value at", path: path]
+            end
+          rescue NoMethodError => e
+            e.name == :fetch ? error["Fetch not defined on value: #{e}"] : raise
+          rescue NameError => e
+            e.name == :Undefined ? error["Undefined returned, skipping!: #{e}"] : raise
+          rescue KeyError, IndexError => e
+            error[e.message]
+          end
+        end
+
+        # Passes {#value} to block and returns {self}
+        #
+        # @return [self]
+        def tap(&block)
+          super { fmap(&block) }
+        end
+
+        # Ensures {value:} is not a state
+        #
+        # @param options [Hash]
+        #
+        # @return [Hash]
+        def merge(options)
+          case options
+          in {value:}
+            value._ { return super }
+          else
+            return super
+          end
+
+          raise ArgumentError, "Expected State#value not to be a State [#{value}] (#{value.class})"
+        end
+
+        def to_hash
+          except(:options, :mapper, :problems, :value)
+        end
+
+        def value
+          fetch(:value)
+        end
+
+        def problem(message)
+          merge(problems: explaination(message, problems)).except(:value)
+        end
+
+        def problems
+          fetch(:problems)
+        end
+
+        def options
+          fetch(:options)
+        end
+
+        # Creates a context containing {options} and {self}
+        #
+        # @param value [Any]
+        #
+        # @yieldparam reason [T]
+        #
+        # @return [Struct]
+        def context(value, state: self, &error)
+          ::Struct.new(*keys, *options.keys, keyword_init: true) do
+            define_method :method_missing do |name, *|
+              error["Method [#{name}] not defined"]
+            end
+
+            define_method :skip! do |message = "Manual skip!"|
+              error[message]
+            end
+          end.new(**to_hash, **options, value: value)
+        end
+      end
+    end
+  end
+end

data/lib/remap/state/schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Remap
+  module State
+    Schema = Dry::Schema.define do
+      required(:input)
+
+      required(:mapper).filled(Remap::Types::Mapper)
+      required(:problems).hash
+      required(:options).value(:hash)
+      required(:path).array(Types::Key)
+
+      optional(:index).filled(:integer)
+      optional(:element).filled
+      optional(:key).filled
+
+      optional(:scope)
+      optional(:value)
+    end
+  end
+end

data/lib/remap/state/types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Remap
+  module State
+    module Types
+      include Dry.Types()
+
+      Key = String | Symbol | Integer
+    end
+  end
+end

data/lib/remap/state.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "dry/schema"
+require "dry/validation"
+require "dry/core/constants"
+require "factory_bot"
+require "dry/logic"
+require "dry/logic/operations"
+require "dry/logic/predicates"
+require "json"
+require "pry"
+
+module Remap
+  module State
+    include Dry::Core::Constants
+    using Extension
+
+    def state(value, mapper:, options: {})
+      { value: value, input: value, mapper: mapper, problems: {}, path: [], options: options, values: value }._
+    end
+  end
+end

data/lib/remap/static/fixed.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Remap
+  class Static
+    class Fixed < Concrete
+      using State::Extension
+
+      attribute :value, Types::Any
+
+      # Set {state#value} to {#value}
+      #
+      # @param state [State]
+      #
+      # @return [State]
+      def call(state)
+        state.set(value)
+      end
+    end
+  end
+end

data/lib/remap/static/option.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Remap
+  class Static
+    class Option < Concrete
+      using State::Extension
+
+      attribute :name, Symbol
+
+      # Selects {#value} from {state#params}
+      #
+      # @param state [State]
+      #
+      # @return [State]
+      def call(state)
+        state.set state.options.fetch(name) {
+          return state.problem("Option [#{name}] not found in [#{state.options.inspect}]")
+        }
+      end
+    end
+  end
+end

data/lib/remap/static.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Remap
+  class Static < Dry::Interface
+  end
+end

data/lib/remap/struct.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Remap
+  class Struct < Dry::Struct
+    schema schema.strict(true)
+  end
+end

data/lib/remap/success.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Remap
+  class Success < Result
+    attribute :result, Types::Any
+
+    def inspect
+      format("Success<[%<result>s]>", result: JSON.pretty_generate(to_h))
+    end
+
+    def to_hash
+      { success: result, problems: problems }
+    end
+
+    def failure?
+      false
+    end
+
+    def success?(value = Undefined)
+      return true if value.equal?(Undefined)
+
+      result == value
+    end
+
+    def fmap(&block)
+      block[result]
+    end
+  end
+end

data/lib/remap/types.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "dry/monads/maybe"
+require "dry/logic/operations/negation"
+require "dry/logic"
+
+module Remap
+  module Types
+    include Dry::Types()
+    include Dry::Logic::Operations
+
+    using State::Extension
+
+    Enumerable = Any.constrained(type: Enumerable)
+    Mapper     = Interface(:call!) # Class.constrained(lt: Remap::Mapper) | Instance(Remap::Mapper).constructor { |v, &e| Instance(Remap::Mapper::Binary).call(v, &e) }
+    Nothing    = Constant(Remap::Nothing)
+    Maybe      = Instance(Dry::Monads::Maybe).fallback(&Dry::Monads::Maybe)
+    # Remap      = Class.constrained(lt: Remap)
+    Proc       = Instance(Proc)
+    Key        = Interface(:hash) | Integer
+    Value = Any # .constrained(not_eql: nil)
+
+    State = Hash.constructor do |value, type, &error|
+      type[value, &error]._(&error)
+    end
+
+    Selectors = Array.of(Remap::Selector)
+
+    Dry::Types.define_builder(:not) do |type, owner = Object|
+      type.constrained_type.new(Instance(owner), rule: Negation.new(type.rule))
+    end
+
+    module Report
+      include Dry.Types()
+
+      Problem = Hash.schema(value?: Any, reason: String)
+
+      Key = String | Symbol | Integer
+
+      Value = Any.constructor do |value, &error|
+        (Array(Problem) | Self).call(value, &error)
+      end
+
+      Self = Hash.map(Key, Value) | Hash.schema(base: Array(Problem))
+    end
+  end
+end

data/lib/remap/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Remap
+  VERSION = "0.1.0"
+end

data/lib/remap.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "dry/struct"
+require "dry/validation"
+
+require "active_support/core_ext/module/delegation"
+require "dry/core/class_builder"
+require "dry/core/memoizable"
+require "dry/core/deprecations"
+require "dry/logic/builder"
+require "dry-configurable"
+require "dry/schema"
+require "dry/types"
+require "dry/monads"
+require "dry/logic"
+require "zeitwerk"
+require "dry/interface"
+
+Dry::Types.load_extensions(:maybe)
+
+loader = Zeitwerk::Loader.for_gem
+loader.collapse("#{__dir__}/remap/rule/support")
+loader.setup
+
+module Remap
+end
+
+loader.eager_load