remap 2.2.44 → 2.2.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9c58b85124adc855131d9efee5ce1ff8653cf4828882a5ad1b60ebb0d1ea99b
-  data.tar.gz: ace57dfce51c7b820d2db5c2f742e5e44828bc998cc719a817bb040e4d08f139
+  metadata.gz: a564dcf130adbf8c40eb089d14f498f993362b74823728ec8ad44b98014034e6
+  data.tar.gz: 3dcac97cd1e4c630ec55ccdbdb6c43922f2ce5367d770e471ebaa77f5ae3fc8c
 SHA512:
-  metadata.gz: d868e87397958d9c68f2048a7888e306c3764dbac799ff5c34c2d8d00e08463fe5abacc708dcc232605c33f319b1cca0b34252108cfb8f4ca1f7831718956d9e
-  data.tar.gz: 3880cde868fbfa68702db58d6db914825f34614b140c3284c264f6b4303338dfda22f1a0f151419d610225c4cd029a776c149b4901607915988acf3c6598386a
+  metadata.gz: 237c0305757a4a12e5d3c24358fd9ed6295d0159baf0bb5786a9b019e3b50c98bd163334b35b04bab99ef1f19adeb232aec234a2aed76ad16ade778c3950606e
+  data.tar.gz: 1c6637383207baf0bd32fd6398f34dc935a5237e2fa67eafa2fccaa1db0d1f9d3f569c6f0695f9c148e737b1c4de15a974a09ba193d0af55ffaf3bef21bad07d

data/lib/remap/base.rb

@@ -34,33 +34,33 @@ module Remap
   #   Mapper.call({}) # => { api_key: "ABC-123" }
   #
   # @example Maps ["A", "B", "C"] to ["A", "C"]
-  #   class Mapper < Remap::Base
+  #   class IfNotMapper < Remap::Base
   #     define do
   #       each do
-  #         map?.if_not do
+  #         map?.if_not do |value|
   #           value.include?("B")
   #         end
   #       end
   #     end
   #   end
   #
-  #   Mapper.call(["A", "B", "C"]) # => ["A", "C"]
+  #   IfNotMapper.call(["A", "B", "C"]) # => ["A", "C"]
   #
   # @example Maps ["A", "B", "C"] to ["B"]
-  #   class Mapper < Remap::Base
+  #   class IfMapper < Remap::Base
   #     define do
   #       each do
-  #         map?.if do
+  #         map?.if do |value|
   #           value.include?("B")
   #         end
   #       end
   #     end
   #   end
   #
-  #   Mapper.call(["A", "B", "C"]) # => ["B"]
+  #   IfMapper.call(["A", "B", "C"]) # => ["B"]
   #
   # @example Maps { a: { b: "A" } } to "A"
-  #   class Mapper < Remap::Base
+  #   class EnumMapper < Remap::Base
   #     define do
   #       map(:a, :b).enum do
   #         value "A", "B"
@@ -68,11 +68,11 @@ module Remap
   #     end
   #   end
   #
-  #   Mapper.call({ a: { b: "A" } }) # => "A"
-  #   Mapper.call({ a: { b: "B" } }) # => "B"
+  #   EnumMapper.call({ a: { b: "A" } }) # => "A"
+  #   EnumMapper.call({ a: { b: "B" } }) # => "B"
   #
   # @example Map { people: [{ name: "John" }] } to { names: ["John"] }
-  #   class Mapper < Remap::Base
+  #   class PeopleMapper < Remap::Base
   #     define do
   #       map :people, to: :names do
   #         each do
@@ -82,12 +82,12 @@ module Remap
   #     end
   #   end
   #
-  #   Mapper.call({ people: [{ name: "John" }] }) # => { names: ["John"] }
+  #   PeopleMapper.call({ people: [{ name: "John" }] }) # => { names: ["John"] }
   #
   # @example Map "Hello" to "Hello!"
   #   class HelloMapper < Remap::Base
   #     define do
-  #       map.adjust do
+  #       map.adjust do |value|
   #         "#{value}!"
   #       end
   #     end
@@ -105,6 +105,7 @@ module Remap
   #   Mapper.call([1, 2, 3]) # => 2
   class Base < Mapper
     include ActiveSupport::Configurable
+    include Dry::Core::Memoizable
     include Dry::Core::Constants
     include Catchable
     extend Mapper::API
@@ -239,7 +240,7 @@ module Remap
     # @return [void]
     # rubocop:disable Layout/LineLength
     def self.define(target = Nothing, method: :new, strategy: :argument, backtrace: caller, &context)
-      unless block_given?
+      unless context
         raise ArgumentError, "#{self}.define requires a block"
       end
 
@@ -305,11 +306,11 @@ module Remap
         end
       end
 
-      s1 = catch_ignored do |id|
-        return context.call(state.set(id: id)).then(&constructor).remove_id
+      s1 = catch_ignored(state) do |s0|
+        return context.call(s0).then(&constructor).remove_id
       end
 
-      Failure.new(failures: s1.notices).then(&error)
+      error[s1.failure]
     end
 
     private
@@ -318,5 +319,7 @@ module Remap
     def validation
       Contract.call(attributes: attributes, contract: contract, options: options, rules: rules)
     end
+
+    memoize :validation
   end
 end

data/lib/remap/catchable.rb

@@ -1,21 +1,42 @@
 # frozen_string_literal: true
 
 module Remap
+  # @api private
   module Catchable
-    # @yieldparam id [Symbol]
-    # @yieldreturn [T]
+    using State::Extension
+
+    # @param state [State]
+    #
+    # @yieldparam state [State]
+    # @yieldparam id [Symbol, String]
+    # @yieldreturn [State<T>]
     #
-    # @return [T]
-    def catch_ignored(&block)
-      catch(to_id(:ignored), &block)
+    # @return [State<T>]
+    def catch_ignored(state, &block)
+      id = to_id(:ignored)
+
+      catch(id) do
+        block[state.set(id: id), id: id].remove_id
+      end
     end
 
-    # @yieldparam id [Symbol]
-    # @yieldreturn [T]
+    # @param state [State]
+    # @param backtrace [Array<String>]
     #
-    # @return [T]
-    def catch_fatal(&block)
-      catch(to_id(:fatal), &block)
+    # @yieldparam state [State]
+    # @yieldparam id [Symbol, String]
+    # @yieldreturn [State<T>]
+    #
+    # @return [State<T>]
+    # @raise [Failure::Error]
+    def catch_fatal(state, backtrace, &block)
+      id = to_id(:fatal)
+
+      failure = catch(id) do
+        return block[state.set(fatal_id: id), fatal_id: id].remove_fatal_id
+      end
+
+      raise failure.exception(backtrace)
     end
 
     private

data/lib/remap/compiler.rb

@@ -32,7 +32,7 @@ module Remap
     #
     # @return [Rule]
     def self.call(backtrace: caller, &block)
-      unless block_given?
+      unless block
         return Rule::VOID
       end
 
@@ -317,7 +317,7 @@ module Remap
     # @return [Rule::Each]]
     # @raise [ArgumentError] if no block given
     def each(backtrace: caller, &block)
-      unless block_given?
+      unless block
         raise ArgumentError, "#each requires a block"
       end
 
@@ -350,7 +350,7 @@ module Remap
     # @return [Rule::Wrap]
     # @raise [ArgumentError] if type is not :array
     def wrap(type, backtrace: caller, &block)
-      unless block_given?
+      unless block
         raise ArgumentError, "#wrap requires a block"
       end
 
@@ -548,13 +548,13 @@ module Remap
           output: [to].flatten,
           input: path.flatten
         },
+        backtrace: backtrace,
         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)
+      catch_fatal(s0, backtrace) do |s1|
         s2 = s1.set(mapper: mapper)
         old_mapper = s0.fetch(:mapper)
 
@@ -563,8 +563,6 @@ module Remap
           s3.return!
         end.except(:scope).merge(mapper: old_mapper)
       end
-
-      raise f0.exception(backtrace)
     end
   end
 end

data/lib/remap/extensions/enumerable.rb

@@ -33,15 +33,13 @@ module Remap
 
           key = path.first
 
-          unless block_given?
+          unless fallback
             return get(*path, trace: trace) do
-              raise PathError, trace + [key]
+              throw :ignore, trace + [key]
             end
           end
 
           fetch(key, &fallback).get(*path[1..], trace: trace + [key], &fallback)
-        rescue TypeError
-          raise PathError, trace + [key]
         end
       end
     end

data/lib/remap/extensions/object.rb

@@ -38,9 +38,9 @@ module Remap
         def get(*path, trace: [], &fallback)
           return self if path.empty?
 
-          unless block_given?
+          unless fallback
             return get(*path, trace: trace) do
-              raise PathError, trace
+              throw :ignore, trace + path
             end
           end
 

data/lib/remap/failure.rb

@@ -17,7 +17,7 @@ module Remap
         ]
       end
 
-      failure = attributes.deep_merge(other.attributes) do |key, value1, value2|
+      failure = attributes.merge(other.attributes) do |key, value1, value2|
         case [key, value1, value2]
         in [:failures | :notices, Array, Array]
           value1 + value2

data/lib/remap/mapper/support/api.rb

@@ -22,7 +22,7 @@ module Remap
       #
       # @return [Any, T]
       def call(input, backtrace: caller, **options, &error)
-        unless block_given?
+        unless error
           return call(input, **options) do |failure|
             raise failure.exception(backtrace)
           end

data/lib/remap/path/input.rb

@@ -25,7 +25,7 @@ module Remap
       #
       # @return [State]
       def call(state, &iterator)
-        unless block_given?
+        unless iterator
           raise ArgumentError, "Input path requires an iterator block"
         end
 

data/lib/remap/rule/block.rb

@@ -16,29 +16,26 @@ module Remap
       #
       # @return [State]
       def call(state)
-        s0 = state.except(:value)
+        init = state.except(:value)
 
         if rules.empty?
-          return s0
+          return init
         end
 
-        failure = catch_fatal do |fatal_id|
-          s1 = s0.set(fatal_id: fatal_id)
-          s4 = state.set(fatal_id: fatal_id)
+        catch_fatal(init, backtrace) do |s1, fatal_id:|
+          s2 = state.set(fatal_id: fatal_id)
 
-          return catch_ignored do |id|
-            s2 = s1.set(id: id)
+          catch_ignored(s1) do |s3, id:|
+            states = rules.map do |rule|
+              rule.call(s2)
+            end
 
-            rules.reduce(s2) do |s3, rule|
-              s5 = s3
-              s6 = rule.call(s4)
-              s7 = s6.set(id: id)
-              s5.combine(s7)
+            states.reduce(s3) do |s4, s5|
+              s6 = s5.set(id: id)
+              s4.combine(s6)
             end
-          end.remove_id.remove_fatal_id
+          end
         end
-
-        raise failure.exception(backtrace)
       end
     end
   end

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

@@ -4,13 +4,9 @@ module Remap
   class Rule
     class Map
       class Enum < Proxy
-        include Dry::Monads[:maybe]
-
         # @return [Hash]
-        option :mappings, default: -> { Hash.new { default } }
-
-        # @return [Maybe]
-        option :default, default: -> { None() }
+        option :table, default: -> { {} }
+        option :default, default: -> { Undefined }
 
         alias execute instance_eval
 
@@ -37,7 +33,7 @@ module Remap
           new.tap { _1.execute(&block) }
         end
 
-        # Translates key into a value using predefined mappings
+        # Translates key into a value using predefined table
         #
         # @param key [#hash]
         #
@@ -50,24 +46,21 @@ module Remap
             return get(key) { raise Error, _1 }
           end
 
-          self[key].bind { return _1 }.or do
-            error["Enum key [#{key}] not found among [#{mappings.keys.inspect}]"]
+          table.fetch(key) do
+            unless default == Undefined
+              return default
+            end
+
+            error["Enum key [#{key}] not found among [#{table.keys.inspect}]"]
           end
         end
         alias call get
 
-        # @return [Maybe]
-        def [](key)
-          mappings[key]
-        end
-
         # @return [void]
         def from(*keys, to:)
-          value = Some(to)
-
           keys.each do |key|
-            mappings[key] = value
-            mappings[to] = value
+            table[key] = to
+            table[to] = to
           end
         end
 
@@ -80,7 +73,7 @@ module Remap
 
         # @return [void]
         def otherwise(value)
-          mappings.default = Some(value)
+          @default = value
         end
       end
     end

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

@@ -5,12 +5,14 @@ module Remap
     class Map
       using State::Extension
 
-      class Optional < Concrete
+      # @api private
+      class Optional < Required
         # Represents an optional mapping rule
         # When the mapping fails, the value is ignored
         #
         # @example Map [:name] to [:nickname]
         #   map = Map::Optional.call({
+        #     backtrace: caller,
         #     path: {
         #       input: [:name],
         #       output: [:nickname]
@@ -22,16 +24,14 @@ module Remap
         #   })
         #
         #   output = map.call(state) do |failure|
-        #     raise failure.exeception
+        #     raise failure.exception(caller)
         #   end
         #
         #   output.fetch(:value) # => { nickname: "John" }
         #
-        # @param state [State]
-        #
-        # @return [State]
+        # @see Map#call
         def call(state)
-          catch { super(state.set(id: _1)).except(:id) }
+          catch_ignored(state) { super(_1) }
         end
       end
     end

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

@@ -8,7 +8,19 @@ module Remap
       class Required < Concrete
         attribute :backtrace, Types::Backtrace
 
-        # TODO: Remove
+        # @see Map#call
+        def call(state)
+          catch_fatal(state, backtrace) do |s0|
+            s2 = path.input.call(s0) do |s1|
+              callback(rule.call(s1))
+            end
+
+            s3 = s2.then(&path.output)
+            s4 = s3.set(path: state.path)
+
+            s4.except(:key)
+          end
+        end
       end
     end
   end

data/lib/remap/rule/map.rb

@@ -43,29 +43,14 @@ module Remap
       #
       # @abstract
       def call(state)
-        failure = catch_fatal do |fatal_id|
-          s0 = state.set(fatal_id: fatal_id)
-
-          s2 = path.input.call(s0) do |s1|
-            s2 = rule.call(s1)
-            callback(s2)
-          end
-
-          s3 = s2.then(&path.output)
-          s4 = s3.set(path: state.path)
-          s5 = s4.except(:key)
-
-          return s5.remove_fatal_id
-        end
-
-        raise failure.exception(backtrace)
+        raise NotImplementedError, "#{self.class}#call not implemented"
       end
 
       # A post-processor method
       #
       # @example Up-case mapped value
       #   state = Remap::State.call("Hello World")
-      #   map = Remap::Rule::Map.call({})
+      #   map = Remap::Rule::Map.call(backtrace: caller)
       #   upcase = map.adjust(&:upcase)
       #   error = -> failure { raise failure.exception }
       #   upcase.call(state, &error).fetch(:value) # => "HELLO WORLD"
@@ -84,7 +69,7 @@ module Remap
       #
       # @example Pending mapping
       #   state = Remap::State.call(:value)
-      #   map = Remap::Rule::Map.call({})
+      #   map = Remap::Rule::Map::Optional.call(backtrace: caller)
       #   pending = map.pending("this is pending")
       #   error = -> failure { raise failure.exception }
       #   pending.call(state, &error).key?(:value) # => false
@@ -99,7 +84,7 @@ module Remap
       # An enumeration processor
       #
       # @example A mapped enum
-      #   enum = Remap::Rule::Map.call({}).enum do
+      #   enum = Remap::Rule::Map.call(backtrace: caller).enum do
       #     value "A", "B"
       #     otherwise "C"
       #   end
@@ -132,7 +117,7 @@ module Remap
       # Keeps map, only if block is true
       #
       # @example Keep if value contains "A"
-      #   map = Remap::Rule::Map.call({}).if do
+      #   map = Remap::Rule::Map::Optional.call(backtrace: caller).if do |value|
       #     value.include?("A")
       #   end
       #
@@ -160,11 +145,11 @@ module Remap
       #
 
       # @example Keep unless value contains "A"
-      #   map = Remap::Rule::Map.call({}).if_not do
+      #   map = Remap::Rule::Map::Optional.new(backtrace: caller).if_not do |value|
       #     value.include?("A")
       #   end
       #
-      #   error = -> failure { raise failure.exception }
+      #   error = -> failure { raise failure.exception(caller) }
       #
       #   a = Remap::State.call("A")
       #   map.call(a, &error).key?(:value) # => false

data/lib/remap/selector/all.rb

@@ -26,7 +26,7 @@ module Remap
       #
       # @return [State<U>]
       def call(outer_state, &block)
-        unless block_given?
+        unless block
           raise ArgumentError, "All selector requires an iteration block"
         end
 

data/lib/remap/selector/index.rb

@@ -31,7 +31,7 @@ module Remap
       #
       # @return [State<U>]
       def call(state, &block)
-        unless block_given?
+        unless block
           raise ArgumentError, "The index selector requires an iteration block"
         end
 

data/lib/remap/selector/key.rb

@@ -28,7 +28,7 @@ module Remap
       #
       # @return [State<U>]
       def call(state, &block)
-        unless block_given?
+        unless block
           raise ArgumentError, "The key selector requires an iteration block"
         end
 

data/lib/remap/state/extension.rb

@@ -46,14 +46,10 @@ module Remap
         # @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)
-
-            hash.deep_merge(key => fetch(key))
-          end
+          dup.extract!(*path)
         end
 
-        # Throws :fatal containing a Notice
+        # @see #notice
         def fatal!(...)
           fatal_id = fetch(:fatal_id) do
             raise ArgumentError, "Missing :fatal_id in %s" % formatted
@@ -62,12 +58,7 @@ module Remap
           throw fatal_id, Failure.new(failures: [notice(...)], notices: notices)
         end
 
-        # Throws :warn containing a Notice
-        def notice!(...)
-          raise NotImplementedError, "Not implemented"
-        end
-
-        # Throws :ignore containing a Notice
+        # @see #notice
         def ignore!(...)
           set(notice: notice(...)).except(:value).return!
         end
@@ -117,11 +108,30 @@ module Remap
         #
         # @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.except(:index, :element, :key)
+          result = case self
+          in { value: Array => array }
+            array.each_with_index.each_with_object([]) do |(value, index), array|
+              s1 = block[set(value, index: index)]
+
+              if s1.key?(:value)
+                array << s1[:value]
+              end
+            end
+          in { value: Hash => hash }
+            hash.each_with_object({}) do |(key, value), acc|
+              s1 = block[set(value, key: key)]
+
+              if s1.key?(:value)
+                acc[key] = s1[:value]
+              end
+            end
+          in { value: }
+            fatal!("Expected an enumerable got %s", value.class)
+          else
+            return self
           end
+
+          set(result)
         end
 
         # @return [String]
@@ -135,10 +145,14 @@ module Remap
         #
         # @return [State]
         def combine(other)
-          deep_merge(other) do |key, value1, value2|
+          merge(other) do |key, value1, value2|
             case [key, value1, value2]
-            in [:value, Array => list1, Array => list2]
-              list1 + list2
+            in [_, Hash => left, Hash => right]
+              left.merge(right)
+            in [:ids | :fatal_ids, _, right]
+              right
+            in [_, Array => left, Array => right]
+              left + right
             in [:value, left, right]
               other.fatal!(
                 "Could not merge [%s] (%s) with [%s] (%s)",
@@ -147,15 +161,6 @@ module Remap
                 right.formatted,
                 right.class
               )
-            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
@@ -165,31 +170,39 @@ module Remap
         # @todo Merge with {#remove_fatal_id}
         # @return [State]
         def remove_id
-          case self
+          state = dup
+
+          case state
           in { ids: [], id: }
-            except(:id)
+            state.except!(:id)
           in { ids:, id: }
-            merge(ids: ids[1...], id: ids[0])
+            state.merge!(ids: ids[1...], id: ids[0])
           in { ids: [] }
-            self
+            state
           in { ids: }
             raise ArgumentError, "[BUG] #ids for state are set, but not #id: %s" % formatted
-          end._
+          end
+
+          state
         end
 
         # @todo Merge with {#remove_id}
         # @return [State]
         def remove_fatal_id
-          case self
+          state = dup
+
+          case state
           in { fatal_ids: [], fatal_id: }
-            except(:fatal_id)
-          in { fatal_ids: ids, fatal_id: id }
-            merge(fatal_ids: ids[1...], fatal_id: ids[0])
+            state.except!(:fatal_id)
+          in { fatal_ids: ids, fatal_id: }
+            state.merge!(fatal_ids: ids[1...], fatal_id: ids[0])
           in { fatal_ids: [] }
-            self
+            state
           in { fatal_ids: }
             raise ArgumentError, "[BUG] #ids for state are set, but not #id: %s" % formatted
-          end._
+          end
+
+          state
         end
 
         # Creates a new state with params
@@ -203,24 +216,30 @@ module Remap
             return set(**options, value: value)
           end
 
-          case [self, options]
-          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}]
-            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)
-          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)
+          state = dup
+
+          case [state, options]
+          in [{notices:}, {notice: notice}]
+            state.merge!(notices: notices + [notice])
+          in [{value:}, {mapper:}]
+            state.merge!(scope: value, mapper: mapper)
+          in [{path:}, {key:, value:}]
+            state.merge!(path: path + [key], key: key, value: value)
+          in [{path:}, {key:}]
+            state.merge!(path: path + [key], key: key)
+          in [{path:}, {index:, value:}]
+            state.merge!(path: path + [index], element: value, index: index, value: value)
+          in [{path:}, {index:}]
+            state.merge!(path: path + [index], index: index)
+          in [{ids:, id: old_id}, {id: new_id}]
+            state.merge!(ids: [old_id] + ids, id: new_id)
+          in [{fatal_ids:, fatal_id: old_id}, {fatal_id: new_id}]
+            state.merge!(fatal_ids: [old_id] + fatal_ids, fatal_id: new_id)
           else
-            merge(options)
+            state.merge!(options)
           end
+
+          state
         end
 
         # Passes {#value} to block, if defined
@@ -240,22 +259,6 @@ module Remap
           end
         end
 
-        # 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)
-          raise NotImplementedError, "Not implemented"
-        end
-
         # Passes {#value} to block, if defined
         # {options} are combine into the final state
         #
@@ -267,7 +270,7 @@ module Remap
         #
         # @return [Y]
         def bind(**options, &block)
-          unless block_given?
+          unless block
             raise ArgumentError, "State#bind requires a block"
           end
 
@@ -287,19 +290,37 @@ module Remap
         # @return [State<U>]
         def execute(&block)
           bind do |value|
-            result = context(value).instance_exec(value, &block)
+            result = catch :done do
+              tail_path = catch :ignore do
+                names = block.parameters.reduce([]) do |acc, (type, name)|
+                  case type
+                  in :keyreq
+                    acc + [name]
+                  else
+                    acc
+                  end
+                end
+
+                r = Proc.new(&block).call(value, **only(*names), **options.only(*names)) do |reason|
+                  ignore!(reason)
+                end
+                throw :done, r
+              rescue NameError => e
+                fatal!(e.message)
+              rescue KeyError => e
+                [e.key]
+              rescue IndexError
+                []
+              end
+
+              set(path: path + tail_path).ignore!("Undefined path")
+            end
 
             if result.equal?(Dry::Core::Constants::Undefined)
               ignore!("Undefined returned, skipping!")
             end
 
             set(result)
-          rescue KeyError => e
-            set(path: path + [e.key]).ignore!(e.message)
-          rescue IndexError => e
-            ignore!(e.message)
-          rescue PathError => e
-            set(path: path + e.path).ignore!("Undefined path")
           end
         end
 
@@ -385,6 +406,8 @@ module Remap
         # @return [Failure]
         def failure(reason = Undefined)
           failures = case [path, reason]
+          in [_, Undefined]
+            return Failure.new(failures: notices)
           in [_, Notice => notice]
             [notice]
           in [path, Array => reasons]
@@ -419,27 +442,6 @@ module Remap
 
           throw id, remove_id
         end
-
-        private
-
-        # Creates a context containing {options} and {self}
-        #
-        # @param value [Any]
-        #
-        # @yieldparam reason [T]
-        #
-        # @return [Struct]
-        def context(value, context: self)
-          ::Struct.new(*except(:id).keys, *options.keys, :state, keyword_init: true) do
-            define_method :method_missing do |name, *|
-              context.fatal!("Method [%s] not defined", name)
-            end
-
-            define_method(:skip!) do |message = "Manual skip!"|
-              context.ignore!(message)
-            end
-          end.new(**to_hash, **options, value: value, state: self)
-        end
       end
     end
   end

data/lib/remap/state/schema.rb

@@ -9,8 +9,12 @@ 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)
+
+      required(:ids).array(Types::ID)
+      optional(:id).filled(Types::ID)
+
+      required(:fatal_ids).array(Types::ID)
+      optional(:fatal_id).filled(Types::ID)
 
       optional(:index).filled(:integer)
       optional(:element).filled

data/lib/remap/state.rb

@@ -31,11 +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,
+        fatal_ids: [],
+        notices: [],
+        path: [],
         options: options,
-        ids: EMPTY_ARRAY,
+        ids: [],
         mapper: mapper,
         values: value,
         value: value,

data/lib/remap/types.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/monads/maybe"
 require "dry/logic/operations/negation"
 require "dry/logic"
 
@@ -18,6 +17,7 @@ module Remap
     Rule       = Interface(:call) | Instance(Proc)
     Key        = Interface(:hash)
     Notice     = Instance(Remap::Notice)
+    ID         = String | Symbol
 
     # Validates a state according to State::Schema
     State = Hash.constructor do |input, type, &error|

data/lib/remap.rb

@@ -5,11 +5,11 @@ require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/wrap"
 require "active_support/proxy_object"
 
+require "dry/core/memoizable"
 require "dry/validation"
 require "dry/interface"
 require "dry/schema"
 require "dry/struct"
-require "dry/monads"
 require "dry/types"
 
 require "neatjson"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remap
 version: !ruby/object:Gem::Version
-  version: 2.2.44
+  version: 2.2.48
 platform: ruby
 authors:
 - Linus Oleander
@@ -66,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.3
-- !ruby/object:Gem::Dependency
-  name: dry-monads
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: dry-schema
   requirement: !ruby/object:Gem::Requirement
@@ -264,10 +250,6 @@ files:
 - 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
-- lib/remap/iteration/other.rb
 - lib/remap/mapper.rb
 - lib/remap/mapper/and.rb
 - lib/remap/mapper/binary.rb

data/lib/remap/iteration/array.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Iteration
-    using State::Extension
-
-    # Implements an array iterator which defines index in state
-    class Array < Concrete
-      # @return [Array<T>]
-      attribute :value, Types::Array, alias: :array
-
-      # @return [State<Array<T>>]
-      attribute :state, Types::State
-
-      # @see Iteration#map
-      def call(&block)
-        array.each_with_index.reduce(init) do |state, (value, index)|
-          reduce(state, value, index, &block)
-        end
-      end
-
-      private
-
-      def init
-        state.set(EMPTY_ARRAY)
-      end
-
-      def reduce(state, value, index, &block)
-        s0 = block[value, index: index]
-        s1 = s0.set(**state.only(:ids, :fatal_id))
-        state.combine(s1.fmap { [_1] })
-      end
-    end
-  end
-end

data/lib/remap/iteration/hash.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Iteration
-    using State::Extension
-
-    # Implements a hash iterator which defines key in state
-    class Hash < Concrete
-      # @return [Hash]
-      attribute :value, Types::Hash, alias: :hash
-
-      # @return [State<Hash>]
-      attribute :state, Types::State
-
-      # @see Iteration#map
-      def call(&block)
-        hash.reduce(init) do |state, (key, value)|
-          reduce(state, key, value, &block)
-        end
-      end
-
-      private
-
-      def reduce(state, key, value, &block)
-        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
-        state.set(EMPTY_HASH)
-      end
-    end
-  end
-end

data/lib/remap/iteration/other.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Iteration
-    using State::Extension
-
-    # Default iterator which doesn't do anything
-    class Other < Concrete
-      attribute :value, Types::Any, alias: :other
-      attribute :state, Types::State
-
-      # @see Iteration#map
-      def call(&block)
-        state.fatal!("Expected an enumerable")
-      end
-    end
-  end
-end

data/lib/remap/iteration.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Iteration < Dry::Interface
-    # @return [State<T>]
-    attribute :state, Types::State
-
-    # @return [T]
-    attribute :value, Types::Any
-
-    # Maps every element in {#value}
-    #
-    # @abstract
-    #
-    # @yieldparam element [V]
-    # @yieldparam key [K, Integer]
-    # @yieldreturn [Array<V>, Hash<V, K>]
-    #
-    # @return [Array<V>, Hash<V, K>]
-    def call(state)
-      raise NotImplementedError, "#{self.class}#call not implemented"
-    end
-
-    order :Hash, :Array, :Other
-  end
-end