remap 2.2.45 → 2.2.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd36dff737c5c3965b1a7bc5dd643bc83098a908c7dac7426a13e6c40a76af95
-  data.tar.gz: 958e0d19bc7d57a72697af4c1dea86f47810f87025a99ab1e13824f82822ce53
+  metadata.gz: 71b1a0f8a9cb714d568939ace38b13d053e4c1ddf9131a6040630ff4a1479e4a
+  data.tar.gz: fe768a12f868c085839145d28a609a707c4aacb10a18c16e2276e51b23de0fb5
 SHA512:
-  metadata.gz: 62e4ad82b773e57a113f190ab5cb3d238e9e0059aa4f692475c8372c91ed25dc9c564782a0522cb1902c2d5f408f0109136487ceb6176bfd5e0e4dd3b92cba23
-  data.tar.gz: 647d4ee1c543073752b92d4e04a7deadde0dd4522ae793cf475544f58a88986d9077bf44fcb2b3cf0acf2b9ee7d5400ff4c95d246f05b78f9e9ce62c800e0c2f
+  metadata.gz: 2f5f657a29f997cf1161eda204a2ddd38f1c6dcc991c8467732d367bc31302c7bafd1e05f5a7655cc5ef46dea5498b9caec6fb9d75d2bd1e9aa5c7f34f7a8ec9
+  data.tar.gz: 9263defd99a669a7bcee25381df7a74698cb2ab691b5a2cf22e7cfdb83a8898956b1a17e329e7560e920ad762093822b85c40587dd6bdcf77ab2433188857474

data/lib/remap/base.rb

@@ -305,11 +305,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

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

@@ -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/rule/block.rb

@@ -16,29 +16,23 @@ 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)
-
-            rules.reduce(s2) do |s3, rule|
-              s5 = s3
-              s6 = rule.call(s4)
-              s7 = s6.set(id: id)
-              s5.combine(s7)
+          catch_ignored(s1) do |s3, id:|
+            rules.reduce(s3) do |s4, rule|
+              s5 = rule.call(s2)
+              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/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_ignored { super(state.set(id: _1)).remove_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.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.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/state/extension.rb

@@ -53,7 +53,7 @@ module Remap
           end
         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 +62,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
@@ -385,6 +380,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]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remap
 version: !ruby/object:Gem::Version
-  version: 2.2.45
+  version: 2.2.46
 platform: ruby
 authors:
 - Linus Oleander