remap 2.2.37 → 2.2.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0c1f52a49e1b423fdf9e5eb2ffc98da0b4ba1941d6243998e033d30d4aae344
-  data.tar.gz: f9c476e98e76f6e9fd82a6df8ffdf42ad20e15db775b5108346e94ab44956e01
+  metadata.gz: 5a8ee7751985c548b272cb12bb0b08b655f52de3143075afafd8578f9e604eba
+  data.tar.gz: f333d2922e7d5ef7a6bd050eb2fc0261446097fdd17f2745eef1a3bc35eb96ee
 SHA512:
-  metadata.gz: 3f8db44f46bc9ec9e5b286213f34dedd05d0d8d39d816eb367d62712591eb901bd09e1534710de153ce4e776e53b2e6bad53aa7cdcc8cf5c7f3fb94b0ed8c25e
-  data.tar.gz: 1eb289f6d77f57b8d2c5e5396e2d2c727bfdce97fa5a8878a89b69f2d52c5a1e59262a33e6cf8a7ae23dbf1870f4b1c59f28cbe03d2499e88a4051a0b4d1c250
+  metadata.gz: 69b98a323c17562a06d4b83f3455c2b1c7e6a482280f5afe283f0d9570411391bb2d0de353d96250436d8aa51ad8443f1a3e25805dde0d6baebbc5286d019a9e
+  data.tar.gz: 86f03041d4cf3ef2ebd1c597269645ae83c55e5d3326077a9d55f51f3f0a47aea131523e9e314d635f34d60487dbba20350a28ffa3eca9b032f0aecd01bf006f

data/lib/remap/base.rb

@@ -106,8 +106,10 @@ module Remap
   class Base < Mapper
     include ActiveSupport::Configurable
     include Dry::Core::Constants
+
+    include Catchable
+
     using State::Extension
-    extend Operation
 
     with_options instance_accessor: true do |scope|
       scope.config_accessor(:contract) { Dry::Schema.define {} }
@@ -120,6 +122,31 @@ module Remap
 
     schema schema.strict(false)
 
+    # extend Operation
+
+    def self.call(input, backtrace: caller, **options, &error)
+      unless block_given?
+        return call(input, **options) do |failure|
+          raise failure.exception(backtrace)
+        end
+      end
+
+      s0 = State.call(input, options: options, mapper: self)._
+
+      s1 = call!(s0) do |failure|
+        return error[failure]
+      end
+
+      case s1
+      in { value: value }
+        value
+      in { notices: [] }
+        error[s1.failure("No data could be mapped")]
+      in { notices: }
+        error[Failure.new(failures: notices)]
+      end
+    end
+
     # Defines a schema for the mapper
     # If the schema fail, the mapper will fail
     #
@@ -235,26 +262,31 @@ module Remap
     #   Mapper.call({name: "John"}).first_name # => "John"
     #
     # @return [void]
-    def self.define(target = Nothing, method: :new, strategy: :argument, &context)
+    # rubocop:disable Layout/LineLength
+    def self.define(target = Nothing, method: :new, strategy: :argument, backtrace: caller, &context)
       unless block_given?
         raise ArgumentError, "#{self}.define requires a block"
       end
 
       self.constructor = Constructor.call(method: method, strategy: strategy, target: target)
-      self.context = Compiler.call(&context)
+      self.context = Compiler.call(backtrace: backtrace, &context)
     end
+    # rubocop:enable Layout/LineLength
 
-    # Similar to {::call}, but takes a state
-    #
     # @param state [State]
     #
-    # @yield [Failure] if mapper fails
+    # @yield [Failure]
+    #   when a non-critical error occurs
+    # @yieldreturn T
     #
-    # @return [Result] if mapper succeeds
+    # @return [State, T]
+    #   when request is a success
+    # @raise [Remap::Error]
+    #   when a fatal error occurs
     #
     # @private
     def self.call!(state, &error)
-      new(state.options).call(state._.set(mapper: self), &error)
+      new(state.options).call(state, &error)
     end
 
     # Mappers state according to the mapper rules
@@ -267,8 +299,8 @@ module Remap
     #
     # @private
     def call(state, &error)
-      unless block_given?
-        raise ArgumentError, "Base#call(state, &error) requires block"
+      state._ do |reason|
+        raise ArgumentError, "Invalid state due to #{reason.formatted}"
       end
 
       state.tap do |input|
@@ -279,13 +311,11 @@ module Remap
         end
       end
 
-      notice = catch :fatal do
-        return context.call(state) do |failure|
-          return error[failure]
-        end.then(&constructor)
+      s1 = catch_ignored do |id|
+        return context.call(state.set(id: id)).then(&constructor).remove_id
       end
 
-      error[state.failure(notice)]
+      Failure.new(failures: s1.notices).then(&error)
     end
 
     private

data/lib/remap/catchable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Remap
+  module Catchable
+    # @yieldparam id [Symbol]
+    # @yieldreturn [T]
+    #
+    # @return [T]
+    def catch_ignored(&block)
+      catch(to_id(:ignored), &block)
+    end
+
+    # @yieldparam id [Symbol]
+    # @yieldreturn [T]
+    #
+    # @return [T]
+    def catch_fatal(&block)
+      catch(to_id(:fatal), &block)
+    end
+
+    private
+
+    def to_id(value)
+      [value, self.class.name&.downcase || :unknown].join("::")
+    end
+  end
+end

data/lib/remap/compiler.rb

@@ -5,6 +5,8 @@ module Remap
 
   # Constructs a {Rule} from the block passed to {Remap::Base.define}
   class Compiler < Proxy
+    extend Catchable
+    include Catchable
     # @return [Array<Rule>]
     param :rules, type: Types.Array(Rule)
 
@@ -29,7 +31,7 @@ module Remap
     #   rule.call(state, &error).fetch(:value) # => { name: "John", age: 50 }
     #
     # @return [Rule]
-    def self.call(&block)
+    def self.call(backtrace: caller, &block)
       unless block_given?
         return Rule::VOID
       end
@@ -38,7 +40,7 @@ module Remap
         compiler.instance_exec(&block)
       end.rules
 
-      Rule::Block.new(rules)
+      Rule::Block.new(backtrace: backtrace, rules: rules)
     end
 
     # Maps input path [input] to output path [to]
@@ -176,18 +178,20 @@ module Remap
     #   output.fetch(:value) # => { car: "Volvo" }
     #
     # @return [Rule::Embed]
-    def embed(mapper)
+    def embed(mapper, backtrace: caller)
       if block_given?
         raise ArgumentError, "#embed does not take a block"
       end
 
-      embeding = rule.add do |state, &error|
-        mapper.call!(state.set(mapper: mapper)) do |failure|
-          next error[failure]
-        end.except(:mapper, :scope)
+      Types::Mapper[mapper] do
+        raise ArgumentError, "Argument to #embed must be a mapper, got #{mapper.class}"
       end
 
-      add embeding
+      result = rule(backtrace: backtrace).add do |s0|
+        build_embed(s0, mapper, backtrace)
+      end
+
+      add result
     end
 
     # Set a static value
@@ -225,12 +229,16 @@ module Remap
     # @raise [ArgumentError]
     #   if no path given
     #   if path is not a Symbol or Array<Symbol>
-    def set(*path, to:)
+    def set(*path, to:, backtrace: caller)
       if block_given?
         raise ArgumentError, "#set does not take a block"
       end
 
-      add rule(to: path).add { to.call(_1) }
+      unless to.is_a?(Static)
+        raise ArgumentError, "Argument to #set must be a static value, got #{to.class}"
+      end
+
+      add rule(to: path, backtrace: backtrace).add { to.call(_1) }
     end
 
     # Maps to path from map with block in between
@@ -280,8 +288,8 @@ module Remap
     # @see #to
     #
     # @return [Rule::Map::Optional]
-    def to?(*path, map: EMPTY_ARRAY, &block)
-      add rule?(*map, to: path, &block)
+    def to?(*path, map: EMPTY_ARRAY, backtrace: caller, &block)
+      add rule?(*map, to: path, backtrace: backtrace, &block)
     end
 
     # Iterates over the input value, passes each value
@@ -308,12 +316,12 @@ module Remap
     #
     # @return [Rule::Each]]
     # @raise [ArgumentError] if no block given
-    def each(&block)
+    def each(backtrace: caller, &block)
       unless block_given?
         raise ArgumentError, "#each requires a block"
       end
 
-      add rule(all, &block)
+      add rule(all, backtrace: backtrace, &block)
     end
 
     # Wraps output in type
@@ -341,12 +349,16 @@ module Remap
     #
     # @return [Rule::Wrap]
     # @raise [ArgumentError] if type is not :array
-    def wrap(type, &block)
+    def wrap(type, backtrace: caller, &block)
       unless block_given?
         raise ArgumentError, "#wrap requires a block"
       end
 
-      add rule(&block).then { Array.wrap(_1) }
+      unless type == :array
+        raise ArgumentError, "Argument to #wrap must equal :array, got [#{type}] (#{type.class})"
+      end
+
+      add rule(backtrace: backtrace, &block).then { Array.wrap(_1) }
     end
 
     # Selects all elements
@@ -394,12 +406,12 @@ module Remap
     #   output.fetch(:value) # => { api_key: "<SECRET>" }
     #
     # @return [Rule::Static::Fixed]
-    def value(value)
+    def value(value, backtrace: caller)
       if block_given?
         raise ArgumentError, "option selector does not take a block"
       end
 
-      Static::Fixed.new(value: value)
+      Static::Fixed.new(value: value, backtrace: backtrace)
     end
 
     # Static option to be selected
@@ -526,7 +538,7 @@ module Remap
           input: path.flatten
         },
         backtrace: backtrace,
-        rule: call(&block)
+        rule: call(backtrace: backtrace, &block)
       })
     end
 
@@ -536,8 +548,23 @@ module Remap
           output: [to].flatten,
           input: path.flatten
         },
-        rule: call(&block)
+        rule: call(backtrace: backtrace, &block)
       })
     end
+
+    def build_embed(s0, mapper, backtrace)
+      f0 = catch_fatal do |fatal_id|
+        s1 = s0.set(fatal_id: fatal_id)
+        s2 = s1.set(mapper: mapper)
+        old_mapper = s0.fetch(:mapper)
+
+        return mapper.call!(s2) do |f1|
+          s3 = s2.set(notices: f1.notices + f1.failures)
+          s3.return!
+        end.except(:scope).merge(mapper: old_mapper)
+      end
+
+      raise f0.exception(backtrace)
+    end
   end
 end

data/lib/remap/constructor/keyword.rb

@@ -27,19 +27,12 @@ module Remap
       #
       # @return [State]
       def call(state)
-        super.fmap do |input, &error|
+        super.fmap do |input|
           unless input.is_a?(Hash)
-            return error["Input is not a hash"]
+            raise ArgumentError, "Expected Hash, got #{input.class}"
           end
 
           target.public_send(id, **input)
-        rescue ArgumentError => e
-          raise e.exception("Failed to create [%p] with input [%s] (%s}) using method %s" % [
-            target,
-            input,
-            input.class,
-            id
-          ])
         end
       end
     end

data/lib/remap/extensions/array.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Remap
+  module Extensions
+    module Array
+      refine ::Array do
+        # @return [Array<Hash>]
+        def to_hash
+          map(&:to_hash)
+        end
+      end
+    end
+  end
+end

data/lib/remap/extensions/object.rb

@@ -4,6 +4,11 @@ module Remap
   module Extensions
     module Object
       refine ::Object do
+        # @return [Any]
+        def to_hash
+          self
+        end
+
         # Fallback validation method
         #
         # @yield if block is provided
@@ -43,6 +48,7 @@ module Remap
         end
         alias_method :fetch, :get
 
+        # return [Any]
         def formatted
           self
         end

data/lib/remap/failure/error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Remap
+  class Failure
+    using Extensions::Hash
+
+    class Error < Error
+      extend Dry::Initializer
+
+      option :failure, type: Types.Instance(Failure)
+      delegate_missing_to :failure
+
+      # @return [String]
+      def inspect
+        "#<%s %s>" % [self.class, to_hash.formatted]
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/remap/failure.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module Remap
-  using Extensions::Hash
-
   class Failure < Dry::Concrete
     attribute :failures, Types.Array(Types::Notice), min_size: 1
     attribute? :notices, Types.Array(Types::Notice), default: EMPTY_ARRAY
@@ -29,9 +27,13 @@ module Remap
       new(failure)
     end
 
-    # @return [Error]
-    def exception
-      Error.new(attributes)
+    # @param backtrace [Array<String>] Backtrace from Kernel.caller
+    #
+    # @return [Failure::Error]
+    def exception(backtrace)
+      e = Error.new(failure: self)
+      e.set_backtrace(backtrace)
+      e
     end
   end
 end

data/lib/remap/iteration/array.rb

@@ -26,12 +26,9 @@ module Remap
       end
 
       def reduce(state, value, index, &block)
-        notice = catch :ignore do
-          other = block[value, index: index]
-          return state.combine(other.fmap { [_1] })
-        end
-
-        state.set(notice: notice)
+        s0 = block[value, index: index]
+        s1 = s0.set(**state.only(:ids, :fatal_id))
+        state.combine(s1.fmap { [_1] })
       end
     end
   end

data/lib/remap/iteration/hash.rb

@@ -22,12 +22,9 @@ module Remap
       private
 
       def reduce(state, key, value, &block)
-        notice = catch :ignore do
-          other = block[value, key: key]
-          return state.combine(other.fmap { { key => _1 } })
-        end
-
-        state.set(notice: notice)
+        s0 = block[value, key: key]
+        s1 = s0.set(fatal_id: state.fatal_id, ids: state.ids)
+        state.combine(s1.fmap { { key => _1 } })
       end
 
       def init

data/lib/remap/notice/error.rb

@@ -25,8 +25,13 @@ module Remap
       end
 
       def traced(backtrace)
-        tap { _1.set_backtrace(backtrace) }
+        e = Traced.new(notice: notice)
+        e.set_backtrace(backtrace)
+        e
       end
     end
+
+    class Traced < Error
+    end
   end
 end

data/lib/remap/operation.rb

@@ -7,32 +7,37 @@ module Remap
   module Operation
     # Public interface for mappers
     #
-    # @param input [Any] Data to be mapped
-    # @param options [Hash] Mapper arguments
+    # @param input [Any] data to be mapped
+    # @param options [Hash] mapper options
     #
-    # @yield [Failure] if mapper fails
+    # @yield [Failure]
+    #   when a non-critical error occurs
+    # @yieldreturn T
     #
-    # @return [Success] if mapper succeeds
-    def call(input, **options, &error)
-      unless error
+    # @return [Any, T]
+    #   when request is a success
+    # @raise [Remap::Error]
+    #   when a fatal error occurs
+    def call(input, backtrace: caller, **options, &error)
+      unless block_given?
         return call(input, **options) do |failure|
-          raise failure.exception
+          raise failure.exception(backtrace)
         end
       end
 
-      other = State.call(input, options: options, mapper: self).then do |state|
-        call!(state) do |failure|
-          return error[failure]
-        end
+      s0 = State.call(input, options: options, mapper: self)._
+
+      s1 = call!(s0) do |failure|
+        return error[failure]
       end
 
-      case other
-      in { value: }
+      case s1
+      in { value: value }
         value
       in { notices: [] }
-        error[other.failure("No return value")]
+        error[s1.failure("No data could be mapped")]
       in { notices: }
-        error[Failure.call(failures: notices)]
+        error[Failure.new(failures: notices)]
       end
     end
   end

data/lib/remap/rule/block.rb

@@ -6,6 +6,7 @@ module Remap
 
     class Block < Unit
       # @return [Array<Rule>]
+      attribute :backtrace, [String], min_size: 1
       attribute :rules, [Types::Rule]
 
       # Represents a non-empty define block with one or more rules
@@ -14,20 +15,30 @@ module Remap
       # @param state [State]
       #
       # @return [State]
-      def call(state, &error)
-        unless block_given?
-          raise ArgumentError, "Block#call(state, &error) requires a block"
-        end
+      def call(state)
+        s0 = state.except(:value)
 
         if rules.empty?
-          return state.except(:value)
+          return s0
+        end
+
+        failure = catch_fatal do |fatal_id|
+          s1 = s0.set(fatal_id: fatal_id)
+          s4 = state.set(fatal_id: fatal_id)
+
+          return catch_ignored do |id|
+            s2 = s1.set(id: id)
+
+            rules.reduce(s2) do |s3, rule|
+              s5 = s3
+              s6 = rule.call(s4)
+              s7 = s6.set(id: id)
+              s5.combine(s7)
+            end
+          end.remove_id.remove_fatal_id
         end
 
-        rules.map do |rule|
-          rule.call(state) do |failure|
-            return error[failure]
-          end
-        end.reduce(&:combine)
+        raise failure.exception(backtrace)
       end
     end
   end

data/lib/remap/rule/map/optional.rb

@@ -30,25 +30,8 @@ module Remap
         # @param state [State]
         #
         # @return [State]
-        def call(state, &error)
-          unless block_given?
-            raise ArgumentError, "map.call(state, &error) requires a block"
-          end
-
-          super
-        rescue Notice::Ignore => e
-          e.undefined(state)
-        end
-
-        private
-
-        # Catches :ignore exceptions and re-package them as a state
-        #
-        # @param state [State]
-        #
-        # @return [State]
-        def ignore(state, &block)
-          state.set(notice: catch(:ignore, &block).traced(backtrace)).except(:value)
+        def call(state)
+          catch { super(state.set(id: _1)).except(:id) }
         end
       end
     end

data/lib/remap/rule/map/required.rb

@@ -8,40 +8,7 @@ module Remap
       class Required < Concrete
         attribute :backtrace, Types::Backtrace
 
-        # Represents a required mapping rule
-        # When it fails, the entire mapping is marked as failed
-        #
-        # @example Map [:name] to [:nickname]
-        #   map = Map::Required.call({
-        #     backtrace: caller,
-        #     path: {
-        #       input: [:name],
-        #       output: [:nickname]
-        #     }
-        #   })
-        #
-        #   state = Remap::State.call({
-        #     name: "John"
-        #   })
-        #
-        #   output = map.call(state) do |failure|
-        #     # ...
-        #   end
-        #
-        #   output.fetch(:value) # => { nickname: "John" }
-        #
-        # @param state [State]
-        #
-        # @return [State]
-        def call(state, &error)
-          unless block_given?
-            raise ArgumentError, "Required.call(state, &error) requires a block"
-          end
-
-          super
-        rescue Notice::Ignore => e
-          error[e.failure(state)]
-        end
+        # TODO: Remove
       end
     end
   end

data/lib/remap/rule/map.rb

@@ -42,29 +42,28 @@ module Remap
       # @return [State]
       #
       # @abstract
-      def call(state, &error)
-        unless block_given?
-          raise ArgumentError, "Map#call(state, &error) requires error handler block"
-        end
+      def call(state)
+        failure = catch_fatal do |fatal_id|
+          s0 = state.set(fatal_id: fatal_id)
 
-        s1 = path.input.call(state) do |inner_state|
-          other_state = rule.call(inner_state) do |failure|
-            return error[failure]
+          s2 = path.input.call(s0) do |s1|
+            s2 = rule.call(s1)
+            callback(s2)
           end
 
-          callback(other_state) do |failure|
-            return error[failure]
-          end
-        end.then(&path.output)
+          s3 = s2.then(&path.output)
+          s4 = s3.set(path: state.path)
+          s5 = s4.except(:key)
+
+          return s5.remove_fatal_id
+        end
 
-        s1.set(path: state.path).except(:key)
-      rescue Notice::Fatal => e
-        raise e.traced(backtrace)
+        raise failure.exception(backtrace)
       end
 
       # A post-processor method
       #
-      # @example Upcase mapped value
+      # @example Up-case mapped value
       #   state = Remap::State.call("Hello World")
       #   map = Remap::Rule::Map.call({})
       #   upcase = map.adjust(&:upcase)
@@ -198,40 +197,8 @@ module Remap
       end
 
       # @return [Proc]
-      def callback(state, &error)
-        unless block_given?
-          raise ArgumentError, "Map#callback(state, &error) requires error handler block"
-        end
-
-        fn.reduce(state) do |inner, fn|
-          fn[inner] do |failure|
-            return error[failure]
-          end
-        end
-      end
-
-      # Catches :fatal and raises {Notice::Error}
-      #
-      # @param state [State]
-      # @param id (:fatal) [:fatal, :notice, :ignore]
-      #
-      # raise [Notice::Error]
-      def fatal(state, id: :fatal, &block)
-        raise catch(id, &block).traced(backtrace).exception
-      end
-
-      # Catches :notice exceptions and repackages them as a state
-      #
-      # @param state [State]
-      #
-      # @return [State]
-      def notice(state, &block)
-        state.set(notice: catch(:notice, &block).traced(backtrace)).except(:value)
-      end
-
-      # @abstract
-      def ignore(...)
-        raise NotImplementedError, "#{self.class}#ignore"
+      def callback(state)
+        fn.reduce(state) { |s1, f1| f1[s1] }
       end
     end
   end

data/lib/remap/rule/void.rb

@@ -19,9 +19,7 @@ module Remap
       #
       # @return [State<T>]
       def call(state)
-        state.bind do |value, inner_state|
-          inner_state.set(value)
-        end
+        state
       end
     end
   end

data/lib/remap/rule.rb

@@ -2,6 +2,10 @@
 
 module Remap
   class Rule < Dry::Interface
+    using Extensions::Hash
+    using Extensions::Array
+    using Extensions::Object
+    include Catchable
     defines :requirement
     requirement Types::Any
 
@@ -13,5 +17,16 @@ module Remap
     def call(state)
       raise NotImplementedError, "#{self.class}#call not implemented"
     end
+
+    # @return [String]
+    def inspect
+      "#<#{self.class} #{to_hash.formatted}>"
+    end
+    alias to_s inspect
+
+    # @return [Hash]
+    def to_hash
+      attributes.transform_values(&:to_hash).except(:backtrace)
+    end
   end
 end

data/lib/remap/selector/index.rb

@@ -24,7 +24,7 @@ module Remap
 
       # Selects the {#index}th element from state and passes it to block
       #
-      # @param outer_state [State<Array<T>>]
+      # @param state [State<Array<T>>]
       #
       # @yieldparam [State<T>]
       # @yieldreturn [State<U>]
@@ -41,7 +41,7 @@ module Remap
           end
 
           element = array.fetch(index) do
-            s.ignore!("Index %s not found", index)
+            s.ignore!("Index not found")
           end
 
           state.set(element, index: index).then(&block)

data/lib/remap/selector/key.rb

@@ -21,7 +21,7 @@ module Remap
 
       # Selects {#key} from state and passes it to block
       #
-      # @param outer_state [State<Hash<K, V>>]
+      # @param state [State<Hash<K, V>>]
       #
       # @yieldparam [State<V>]
       # @yieldreturn [State<U>]

data/lib/remap/state/extension.rb

@@ -2,6 +2,7 @@
 
 module Remap
   module State
+    # @api private
     module Extension
       using Extensions::Enumerable
       using Extensions::Object
@@ -54,7 +55,11 @@ module Remap
 
         # Throws :fatal containing a Notice
         def fatal!(...)
-          notice(...).fatal!
+          fatal_id = fetch(:fatal_id) do
+            raise ArgumentError, "Missing :fatal_id in %s" % formatted
+          end
+
+          throw fatal_id, Failure.new(failures: [notice(...)], notices: notices)
         end
 
         # Throws :warn containing a Notice
@@ -64,7 +69,7 @@ module Remap
 
         # Throws :ignore containing a Notice
         def ignore!(...)
-          notice(...).ignore!
+          set(notice: notice(...)).except(:value).return!
         end
 
         # Creates a notice containing the given message
@@ -88,7 +93,9 @@ module Remap
         # @return [self]
         def _(&block)
           unless block
-            return _ { raise ArgumentError, "Input: #{self} output: #{_1.formatted}" }
+            return _ do |reason|
+              raise ArgumentError, "[BUG] State: #{formatted} reason: #{reason.formatted}"
+            end
           end
 
           unless (result = Schema.call(self)).success?
@@ -98,11 +105,11 @@ module Remap
           self
         end
 
-        # Makes the state iterable
+        # Iterates over {#value}
         #
         # @yieldparam value [Any]
-        # @yieldoption key [Symbol]
-        # @yieldoption index [Integer]
+        # @yieldparam key [Symbol]
+        # @yieldparam index [Integer]
         #
         # @yieldreturn [State]
         #
@@ -131,8 +138,8 @@ module Remap
             in [:value, Array => list1, Array => list2]
               list1 + list2
             in [:value, left, right]
-              fatal!(
-                "Could not merge [%p] (%s) with [%p] (%s)",
+              other.fatal!(
+                "Could not merge [%s] (%s) with [%s] (%s)",
                 left.formatted,
                 left.class,
                 right.formatted,
@@ -140,10 +147,47 @@ module Remap
               )
             in [:notices, Array => n1, Array => n2]
               n1 + n2
+            in [:ids, i1, i2] if i1.all? { i2.include?(_1) }
+              i2
+            in [:ids, i1, i2] if i2.all? { i1.include?(_1) }
+              i1
+            in [:ids, i1, i2]
+              other.fatal!("Could not merge #ids [%s] (%s) with [%s] (%s)", i1, i1.class, i2,
+                           i2.class)
             in [Symbol, _, value]
               value
             end
-          end
+          end._
+        end
+
+        # @todo Merge with {#remove_fatal_id}
+        # @return [State]
+        def remove_id
+          case self
+          in { ids: [], id: }
+            except(:id)
+          in { ids:, id: }
+            merge(ids: ids[1...], id: ids[0])
+          in { ids: [] }
+            self
+          in { ids: }
+            raise ArgumentError, "[BUG] #ids for state are set, but not #id: %s" % formatted
+          end._
+        end
+
+        # @todo Merge with {#remove_id}
+        # @return [State]
+        def remove_fatal_id
+          case self
+          in { fatal_ids: [], fatal_id: }
+            except(:fatal_id)
+          in { fatal_ids: ids, fatal_id: id }
+            merge(fatal_ids: ids[1...], fatal_id: ids[0])
+          in { fatal_ids: [] }
+            self
+          in { fatal_ids: }
+            raise ArgumentError, "[BUG] #ids for state are set, but not #id: %s" % formatted
+          end._
         end
 
         # Creates a new state with params
@@ -168,6 +212,10 @@ module Remap
             merge(path: path + [index], element: value, index: index, value: value).set(**rest)
           in [{path:}, {index:, **rest}]
             merge(path: path + [index], index: index).set(**rest)
+          in [{ids:, id: old_id}, {id: new_id, **rest}]
+            merge(ids: [old_id] + ids, id: new_id).set(**rest)
+          in [{fatal_ids:, fatal_id: old_id}, {fatal_id: new_id, **rest}]
+            merge(fatal_ids: [old_id] + fatal_ids, fatal_id: new_id).set(**rest)
           else
             merge(options)
           end
@@ -185,8 +233,8 @@ module Remap
         #
         # @return [State<Y>]
         def fmap(**options, &block)
-          bind(**options) do |input, state, &error|
-            state.set(block[input, state, &error])
+          bind(**options) do |input, state:|
+            state.set(block[input, state, state: state])
           end
         end
 
@@ -203,28 +251,7 @@ module Remap
         # 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
-          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
-
-          Failure.new(failures: failures, notices: notices)
+          raise NotImplementedError, "Not implemented"
         end
 
         # Passes {#value} to block, if defined
@@ -242,12 +269,10 @@ module Remap
             raise ArgumentError, "State#bind requires a block"
           end
 
-          s = set(**options)
+          s1 = set(**options)
 
-          fetch(:value) { return s }.then do |value|
-            block[value, s] do |reason, **other|
-              return s.set(**other).ignore!(reason)
-            end
+          fetch(:value) { return s1 }.then do |value|
+            block[value, s1, state: s1]
           end
         end
 
@@ -259,11 +284,11 @@ module Remap
         #
         # @return [State<U>]
         def execute(&block)
-          bind do |value, &error|
-            result = context(value, &error).instance_exec(value, &block)
+          bind do |value|
+            result = context(value).instance_exec(value, &block)
 
             if result.equal?(Dry::Core::Constants::Undefined)
-              return error["Undefined returned, skipping!"]
+              ignore!("Undefined returned, skipping!")
             end
 
             set(result)
@@ -290,6 +315,21 @@ module Remap
           fetch(:path, EMPTY_ARRAY)
         end
 
+        # @return [Symbol]
+        def id
+          fetch(:id)
+        end
+
+        # @return [Array<Symbol>]
+        def ids
+          fetch(:ids)
+        end
+
+        # @return [Symbol]
+        def fatal_id
+          fetch(:fatal_id)
+        end
+
         # Represents options to a mapper
         #
         # @see Rule::Embed
@@ -303,7 +343,7 @@ module Remap
         #
         # @return [Hash]
         def to_hash
-          super.except(:options, :notices, :value)
+          super.except(:options, :notices, :value, :id, :ids, :fatal_id, :fatal_ids)
         end
 
         # @return [Any]
@@ -331,6 +371,48 @@ module Remap
           fetch(:notices)
         end
 
+        # Creates a failure from the current state
+        #
+        # @param reason [String, Hash, Undefined]
+        #
+        # @return [Failure]
+        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
+          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
+
+          Failure.new(failures: failures, notices: notices)
+        end
+
+        # @raise [ArgumentError]
+        #   when {#id} is not defined
+        #
+        # @private
+        def return!
+          id = fetch(:id) do
+            raise ArgumentError, "#id not defined for state [%s]" % [formatted]
+          end
+
+          throw id, remove_id
+        end
+
         private
 
         # Creates a context containing {options} and {self}
@@ -340,13 +422,13 @@ module Remap
         # @yieldparam reason [T]
         #
         # @return [Struct]
-        def context(value, context: self, &error)
-          ::Struct.new(*keys, *options.keys, :state, keyword_init: true) do
+        def context(value, context: self)
+          ::Struct.new(*except(:id).keys, *options.keys, :state, keyword_init: true) do
             define_method :method_missing do |name, *|
-              error["Method [#{name}] not defined"]
+              context.fatal!("Method [%s] not defined", name)
             end
 
-            define_method :skip! do |message = "Manual skip!"|
+            define_method(:skip!) do |message = "Manual skip!"|
               context.ignore!(message)
             end
           end.new(**to_hash, **options, value: value, state: self)

data/lib/remap/state/schema.rb

@@ -9,6 +9,8 @@ module Remap
       required(:notices).array(Types.Instance(Notice))
       required(:options).value(:hash)
       required(:path).array(Types::Key)
+      required(:ids).value(:array)
+      required(:fatal_ids).value(:array)
 
       optional(:index).filled(:integer)
       optional(:element).filled

data/lib/remap/state.rb

@@ -31,9 +31,11 @@ module Remap
     # @return [Hash] A valid state
     def self.call(value, mapper: Dummy, options: EMPTY_HASH)
       {
+        fatal_ids: EMPTY_ARRAY,
         notices: EMPTY_ARRAY,
         path: EMPTY_ARRAY,
         options: options,
+        ids: EMPTY_ARRAY,
         mapper: mapper,
         values: value,
         value: value,

data/lib/remap/static/option.rb

@@ -26,11 +26,11 @@ module Remap
       #
       # @return [State]
       def call(state)
-        state.set(state.options.fetch(name))
-      rescue KeyError => e
-        raise ArgumentError, e.exception("Option [%s] not found in input [%p]" % [
-          name, state.options
-        ])
+        value = state.options.fetch(name) do
+          raise ArgumentError, "Option [%s] not found" % [name], backtrace
+        end
+
+        state.set(value)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: remap
 version: !ruby/object:Gem::Version
-  version: 2.2.37
+  version: 2.2.41
 platform: ruby
 authors:
 - Linus Oleander
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-12 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -248,6 +248,7 @@ extra_rdoc_files: []
 files:
 - lib/remap.rb
 - lib/remap/base.rb
+- lib/remap/catchable.rb
 - lib/remap/class_interface.rb
 - lib/remap/compiler.rb
 - lib/remap/constructor.rb
@@ -256,10 +257,12 @@ files:
 - lib/remap/constructor/none.rb
 - lib/remap/contract.rb
 - lib/remap/error.rb
+- lib/remap/extensions/array.rb
 - lib/remap/extensions/enumerable.rb
 - lib/remap/extensions/hash.rb
 - lib/remap/extensions/object.rb
 - lib/remap/failure.rb
+- lib/remap/failure/error.rb
 - lib/remap/iteration.rb
 - lib/remap/iteration/array.rb
 - lib/remap/iteration/hash.rb