remap 2.0.3 → 2.1.0

data/lib/remap/state/extension.rb

@@ -1,52 +1,101 @@
 # 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
+      using Extensions::Enumerable
+      using Extensions::Object
+      using Extensions::Hash
 
+      refine Object do
+        # @see Extension::Paths::Hash
         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 }
+      refine Hash do
+        # Returns a list of all key paths
+        #
+        # @example Get paths
+        #   {
+        #     a: {
+        #       b: :c
+        #     },
+        #     d: :e
+        #   }.hur_paths # => [[:a, :b], [:d]]
+        #
+        # @return [Array<Array<Symbol>>] a list of key paths
+        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 get(*path, last)
-          if path.empty?
-            return fetch(last) do
-              throw :missing, path + [last]
-            end
-          end
+        # Restrict hash to passed key path
+        #
+        # @param key [Symbol] to be kept
+        # @param rest [Array<Symbol>] of the key path
+        #
+        # @example Select key path
+        #   {
+        #     a: {
+        #       b: :c
+        #     },
+        #     d: :e
+        #   }.hur_only(:a, :b) # => { a: { b: :c } }
+        #
+        # @returns [Hash] a hash containing the given path
+        # @raise Europace::Error when path doesn't exist
+        def only(*path)
+          path.reduce(EMPTY_HASH) do |hash, key|
+            next hash unless key?(key)
 
-          dig(*path).fetch(last) do
-            throw :missing, path + [last]
+            hash.deep_merge(key => fetch(key))
           end
         end
-      end
 
-      refine Hash do
+        # Throws :fatal containing a Notice
+        def fatal!(...)
+          throw :fatal, notice(...)
+        end
+
+        # Throws :warn containing a Notice
+        def notice!(...)
+          throw :notice, notice(...)
+        end
+
+        # Throws :ignore containing a Notice
+        def ignore!(...)
+          throw :ignore, notice(...)
+        end
+
+        # Creates a notice containing the given message
+        #
+        # @param template [String]
+        # @param values [Array]
+        #
+        # @return [Notice]
+        def notice(template, *values)
+          Notice.call(only(:value, :path).merge(reason: template % values))
+        end
+
+        # Validates {self} against {Schema}
+        #
+        # Only used during development
+        #
+        # @yield [Hash] if schema fails
+        #
+        # @raise if schema fails and no block is given
+        #
+        # @return [self]
         def _(&block)
           unless block
-            return _ { raise "Input: #{self} output: #{JSON.pretty_generate(_1)}" }
+            return _ { raise ArgumentError, "Input: #{self} output: #{_1.formated}" }
           end
 
           unless (result = Schema.call(self)).success?
@@ -56,22 +105,6 @@ module Remap
           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]
@@ -84,16 +117,18 @@ module Remap
         def map(&block)
           bind do |value, state|
             Iteration.call(state: state, value: value).call do |other, **options|
-              state.set(other, **options)._.then(&block)._
-            end
+              state.set(other, **options).then do |inner_state|
+                block[inner_state] do |failure|
+                  throw :failure, failure
+                end
+              end
+            end.except(:index, :element, :key)
           end
         end
 
         # @return [String]
         def inspect
-          reject { _2.blank? }.then do |cleaned|
-            format("#<State %<json>s>", json: JSON.pretty_generate(cleaned))
-          end
+          "#<State %s>" % compact_blank.formated
         end
 
         # Merges {self} with {other} and returns a new state
@@ -101,102 +136,31 @@ module Remap
         # @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)
+        def combine(other)
+          deep_merge(other) do |key, value1, value2|
+            case [key, value1, value2]
+            in [:value, Array => list1, Array => list2]
+              list1 + list2
+            in [:value, left, right]
+              fatal!(
+                "Could not merge [%p] (%s) with [%p] (%s) @ %s",
+                left,
+                left.class,
+                right,
+                right.class,
+                (path + [key]).join("."))
+            in [:notices, Array => n1, Array => n2]
+              n1 + n2
+            in [Symbol, _, value]
+              value
             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}
+        # @options [Hash] To be combine into {self}
         #
         # @return [State]
         def set(value = Undefined, **options)
@@ -205,10 +169,8 @@ module Remap
           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 [{notices:}, {notice: notice, **rest}]
+            merge(notices: notices + [notice]).set(**rest)
           in [{value:}, {mapper:, **rest}]
             merge(scope: value, mapper: mapper).set(**rest)
           in [{path:}, {key:, **rest}]
@@ -224,7 +186,7 @@ module Remap
 
         # Passes {#value} to block, if defined
         # The return value is then wrapped in a state
-        # and returned with {options} merged into the state
+        # and returned with {options} combine into the state
         #
         # @yieldparam value [T]
         # @yieldparam self [State]
@@ -239,48 +201,44 @@ module Remap
           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)
+        # Creates a failure to be used in {Remap::Base} & {Remap::Mapper}
+        #
+        # @param reason [#to_s]
+        #
+        # @see State::Schema
+        #
+        # @return [Failure]
+
+        # class Failure < Dry::Interface
+        #   attribute :notices, [Notice], min_size: 1
+        # end
+
+        def failure(reason = Undefined)
+          failures = case [path, reason]
+          in [_, Notice => notice]
+            [notice]
+          in [path, Array => reasons]
+            reasons.map do |inner_reason|
+              Notice.call(path: path, reason: inner_reason, **only(:value))
             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}"
+          in [path, String => reason]
+            [Notice.call(path: path, reason: reason, **only(:value))]
+          in [path, Hash => errors]
+            errors.paths.flat_map do |sufix|
+              Array.wrap(errors.dig(*sufix)).map do |inner_reason|
+                Notice.call(
+                  reason: inner_reason,
+                  path: path + sufix,
+                  **only(:value))
+              end
             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
+          Failure.new(failures: failures, notices: notices)
         end
 
         # Passes {#value} to block, if defined
-        # {options} are merged into the final state
+        # {options} are combine into the final state
         #
         # @yieldparam value [T]
         # @yieldparam self [State]
@@ -290,13 +248,13 @@ module Remap
         #
         # @return [Y]
         def bind(**options, &block)
-          unless block
-            raise ArgumentError, "no block given"
+          unless block_given?
+            raise ArgumentError, "State#bind requires a block"
           end
 
           fetch(:value) { return self }.then do |value|
             block[value, self] do |reason, **other|
-              return set(**options, **other).problem(reason)._
+              return set(**options, **other).notice!(reason)
             end
           end
         end
@@ -304,25 +262,27 @@ module Remap
         # Execute {block} in the current context
         # Only calls {block} if {#value} is defined
         #
-        # @yieldparam value [T]
+        # @yieldparam [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
+            result = context(value, &error).instance_exec(value, &block)
 
-              return error["Could not fetch value at", path: path]
+            if result.equal?(Dry::Core::Constants::Undefined)
+              return error["Undefined returned, skipping!"]
             end
+
+            set(result)._
           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]
+          rescue PathError => e
+            ignore!("Path %s not defined for %p (%s)", e.path.join("."), value, value.class)
           end
         end
 
@@ -333,42 +293,56 @@ module Remap
           super { fmap(&block) }
         end
 
-        # Ensures {value:} is not a state
+        # A list of keys representing the path to {#value}
+        #
+        # @return [Array<Symbol, Integer, String>]
+        def path
+          fetch(:path, EMPTY_ARRAY)
+        end
+
+        # Represents options to a mapper
         #
-        # @param options [Hash]
+        # @see Rule::Embed
         #
         # @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})"
+        def options
+          fetch(:options)
         end
 
+        # Used by {#context} to create a limited context
+        #
+        # @return [Hash]
         def to_hash
-          except(:options, :mapper, :problems, :value)
+          super.except(:options, :notices, :value)
         end
 
+        # @return [Any]
         def value
           fetch(:value)
         end
 
-        def problem(message)
-          merge(problems: explaination(message, problems)).except(:value)
+        # @return [Integer]
+        def index
+          fetch(:index)
         end
 
-        def problems
-          fetch(:problems)
+        # @return [Any]
+        def element
+          fetch(:element)
         end
 
-        def options
-          fetch(:options)
+        # @return [Any]
+        def key
+          fetch(:key)
         end
 
+        # @return [Array<Notice>]
+        def notices
+          fetch(:notices)
+        end
+
+        private
+
         # Creates a context containing {options} and {self}
         #
         # @param value [Any]
@@ -376,14 +350,14 @@ module Remap
         # @yieldparam reason [T]
         #
         # @return [Struct]
-        def context(value, state: self, &error)
+        def context(value, context: 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]
+              context.ignore!(message)
             end
           end.new(**to_hash, **options, value: value)
         end

data/lib/remap/state/schema.rb

@@ -6,7 +6,7 @@ module Remap
       required(:input)
 
       required(:mapper).filled(Remap::Types::Mapper)
-      required(:problems).hash
+      required(:notices).array(Types.Instance(Notice))
       required(:options).value(:hash)
       required(:path).array(Types::Key)
 

data/lib/remap/state.rb

@@ -8,15 +8,41 @@ require "dry/logic"
 require "dry/logic/operations"
 require "dry/logic/predicates"
 require "json"
-require "pry"
 
 module Remap
+  # Represents the current state of a mapping
   module State
-    include Dry::Core::Constants
+    using Extensions::Object
     using Extension
 
-    def state(value, mapper:, options: {})
-      { value: value, input: value, mapper: mapper, problems: {}, path: [], options: options, values: value }._
+    include Dry::Core::Constants
+
+    class Dummy < Remap::Base
+      # NOP
+    end
+
+    # Creates a valid state
+    #
+    # @param value [Any] Internal state value
+    #
+    # @option mapper [Mapper::Class] Mapper class
+    # @option options [Hash] Mapper options / arguments
+    #
+    # @return [Hash] A valid state
+    def self.call(value, mapper: Dummy, options: EMPTY_HASH)
+      value._ do
+        return {
+          notices: EMPTY_ARRAY,
+          path: EMPTY_ARRAY,
+          options: options,
+          mapper: mapper,
+          values: value,
+          value: value,
+          input: value
+        }._
+      end
+
+      raise ArgumentError, "Input is a state: #{value}"
     end
   end
 end

data/lib/remap/static/fixed.rb

@@ -2,12 +2,23 @@
 
 module Remap
   class Static
-    class Fixed < Concrete
-      using State::Extension
+    using State::Extension
 
+    # Maps a fixed value to state
+    #
+    # @example Map a fixed value to path
+    #   class Mapper < Remap::Base
+    #     define do
+    #       set :a, :b, to: value('a value')
+    #     end
+    #   end
+    #
+    #   Mapper.call({}) # => { a: { b: 'a value' } }
+    class Fixed < Concrete
+      # @return [Any]
       attribute :value, Types::Any
 
-      # Set {state#value} to {#value}
+      # Set state to {#value}
       #
       # @param state [State]
       #

data/lib/remap/static/option.rb

@@ -2,20 +2,35 @@
 
 module Remap
   class Static
-    class Option < Concrete
-      using State::Extension
+    using State::Extension
 
+    # Maps a mapper argument to a path
+    #
+    # @example Maps a mapper argument to a path
+    #   class Mapper < Remap::Base
+    #     option :name
+    #
+    #     define do
+    #       set :nickname, to: option(:name)
+    #     end
+    #   end
+    #
+    #   Mapper.call({}, name: "John") # => { nickname: "John" }
+    class Option < Concrete
+      # @return [Symbol]
       attribute :name, Symbol
 
-      # Selects {#value} from {state#params}
+      # Selects {#name} from state
       #
       # @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}]")
-        }
+        state.set(state.options.fetch(name))
+      rescue KeyError => e
+        raise ArgumentError, e.exception("Option [%s] not found in input [%p]" % [
+          name, state.options
+        ])
       end
     end
   end

data/lib/remap/static.rb

@@ -1,6 +1,19 @@
 # frozen_string_literal: true
 
 module Remap
+  # A static mapped value either represented by an option or a value
   class Static < Dry::Interface
+    attribute? :backtrace, Types::Backtrace
+
+    # Maps a static value to state
+    #
+    # @param state [State<T>]
+    #
+    # @return [State<Y>]
+    #
+    # @abstract
+    def call(state)
+      raise NotImplementedError, "#{self.class}#call not implemented"
+    end
   end
 end