remap 2.2.30 → 2.2.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97fa16337a644edef32848dd48ff70278fb40e23bb0ff03fbf800d8dd2bc529e
-  data.tar.gz: a917d4270f30eb710cc0e93fae3e47ec822aa0e95434a499c8b0886328a94ee3
+  metadata.gz: 38765a313ed6b492d7f898519fe1303dcad63ec19e266b2192e94a9f96813a87
+  data.tar.gz: 8a1fee97a5ea6a1f9d8e8d296e71e5b5dd1881580683870e9824f40158eb0e97
 SHA512:
-  metadata.gz: 3a6d777701ef4c9c42db2a2a103a80ce10e858e92c6c1ca1048498cc8c2c99882cdc4cb1f23eee2384691aef75c01e0fecebd1cde881b84bc7c0816d3f458d31
-  data.tar.gz: 1a5dd13ac57048a33976d78543eed796e7fcfff31435fcfd299d70051be14cabc9fcbaf81b8bf963b775b0c17fe013956678bab4616ce0312a5db8a2ac17302f
+  metadata.gz: 3542fc58722ff987b0307c83e339659af0bfcd358dabfbbec338c582f66cb78d10c0e325ca4ba319bb925001c14cc8f6174e189a7435abece4aff0e9276b716c
+  data.tar.gz: 1b82a610fd18d8583ff6f26098e733cbea67a92381af7bcd20cc0a15e41fc025e3a8642678fdd40a3e8224ecbd2abd5d0b6c29f19163302224bf670e452d000b

data/lib/remap/base.rb

@@ -37,7 +37,7 @@ module Remap
   #   class Mapper < Remap::Base
   #     define do
   #       each do
-  #         map.if_not do
+  #         map?.if_not do
   #           value.include?("B")
   #         end
   #       end
@@ -50,7 +50,7 @@ module Remap
   #   class Mapper < Remap::Base
   #     define do
   #       each do
-  #         map.if do
+  #         map?.if do
   #           value.include?("B")
   #         end
   #       end
@@ -85,7 +85,7 @@ module Remap
   #   Mapper.call({ people: [{ name: "John" }] }) # => { names: ["John"] }
   #
   # @example Map "Hello" to "Hello!"
-  #   class Mapper < Remap::Base
+  #   class HelloMapper < Remap::Base
   #     define do
   #       map.adjust do
   #         "#{value}!"
@@ -93,7 +93,7 @@ module Remap
   #     end
   #   end
   #
-  #   Mapper.call("Hello") # => "Hello!"
+  #   HelloMapper.call("Hello") # => "Hello!"
   #
   # @example Select the second element from an array
   #   class Mapper < Remap::Base

data/lib/remap/constructor/argument.rb

@@ -30,6 +30,11 @@ module Remap
       def call(state)
         super.fmap do |input|
           target.public_send(id, input)
+        rescue ArgumentError => e
+          raise e.exception("Failed to create [%p] with input [%s] (%s)" % [
+            target, input,
+            input.class
+          ])
         end
       end
     end

data/lib/remap/constructor/keyword.rb

@@ -27,13 +27,19 @@ module Remap
       #
       # @return [State]
       def call(state)
-        super.fmap do |input|
+        super.fmap do |input, &error|
           unless input.is_a?(Hash)
-            raise ArgumentError,
-                  "Keyword stategy requires a Hash, got %s (%s)" % [input, input.class]
+            return error["Input is not a hash"]
           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/object.rb

@@ -34,7 +34,9 @@ module Remap
           return self if path.empty?
 
           unless block_given?
-            raise PathError, trace
+            return get(*path, trace: trace) do
+              raise PathError, trace
+            end
           end
 
           yield

data/lib/remap/failure.rb

@@ -4,8 +4,8 @@ module Remap
   using Extensions::Hash
 
   class Failure < Dry::Concrete
-    attribute :failures, [Notice], min_size: 1
-    attribute? :notices, [Notice], default: EMPTY_ARRAY
+    attribute :failures, Types.Array(Types::Notice), min_size: 1
+    attribute? :notices, Types.Array(Types::Notice), default: EMPTY_ARRAY
 
     # Merges two failures and returns a new failure
     #
@@ -31,7 +31,7 @@ module Remap
 
     # @return [Error]
     def exception
-      Error.new(attributes.formatted)
+      Error.new(attributes)
     end
   end
 end

data/lib/remap/iteration/other.rb

@@ -11,7 +11,7 @@ module Remap
 
       # @see Iteration#map
       def call(&block)
-        state.fatal!("Expected an enumerable, got %s (%s)", value, value.class)
+        state.fatal!("Expected an enumerable")
       end
     end
   end

data/lib/remap/notice/error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Remap
+  class Notice
+    using Extensions::Hash
+    using State::Extension
+
+    class Error < Remap::Error
+      extend Dry::Initializer
+
+      delegate_missing_to :notice
+      delegate :inspect, :to_s, to: :notice
+      option :notice, type: Types.Instance(Notice)
+
+      def inspect
+        "#<%s %s>" % [self.class, to_hash.formatted]
+      end
+
+      def undefined(state)
+        state.set(notice: notice).except(:value)
+      end
+
+      def failure(state)
+        Failure.new(failures: [notice], notices: state.fetch(:notices))
+      end
+
+      def traced(backtrace)
+        tap { _1.set_backtrace(backtrace) }
+      end
+    end
+  end
+end

data/lib/remap/notice/fatal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Remap
+  class Notice
+    Fatal = Class.new(Error)
+  end
+end

data/lib/remap/notice/ignore.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Remap
+  class Notice
+    Ignore = Class.new(Error)
+  end
+end

data/lib/remap/notice.rb

@@ -3,17 +3,12 @@
 module Remap
   using Extensions::Hash
 
-  class Notice < Dry::Interface
+  class Notice < Dry::Concrete
     attribute? :value, Types::Any
     attribute :reason, String
     attribute :path, Array
 
-    class Error < Remap::Error
-      extend Dry::Initializer
-
-      param :notice, type: Notice
-    end
-
+    # @return [String]
     def inspect
       "#<%s %s>" % [self.class, to_hash.formatted]
     end
@@ -26,9 +21,18 @@ module Remap
       super.except(:backtrace).compact_blank
     end
 
-    # @return [Error]
-    def exception
-      Error.new(self)
+    # Used by State to skip mapping rules
+    #
+    # @raise [Notice::Ignore]
+    def ignore!
+      raise Ignore.new(notice: self)
+    end
+
+    # Used by the state to halt mappers
+    #
+    # @raise [Notice::Fatal]
+    def fatal!
+      raise Fatal.new(notice: self)
     end
   end
 end

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

@@ -35,13 +35,9 @@ module Remap
             raise ArgumentError, "map.call(state, &error) requires a block"
           end
 
-          fatal(state) do
-            return ignore(state) do
-              return notice(state) do
-                return super
-              end
-            end
-          end
+          super
+        rescue Notice::Ignore => e
+          e.undefined(state)
         end
 
         private

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

@@ -38,15 +38,9 @@ module Remap
             raise ArgumentError, "Required.call(state, &error) requires a block"
           end
 
-          notice = catch :ignore do
-            return fatal(state) do
-              return notice(state) do
-                return super
-              end
-            end
-          end
-
-          error[state.failure(notice)]
+          super
+        rescue Notice::Ignore => e
+          error[e.failure(state)]
         end
       end
     end

data/lib/remap/rule/map.rb

@@ -47,19 +47,19 @@ module Remap
           raise ArgumentError, "Map#call(state, &error) requires error handler block"
         end
 
-        notice = catch :fatal do
-          return path.input.call(state) do |inner_state|
-            other_state = rule.call(inner_state) do |failure|
-              return error[failure]
-            end
+        s1 = path.input.call(state) do |inner_state|
+          other_state = rule.call(inner_state) do |failure|
+            return error[failure]
+          end
 
-            callback(other_state) do |failure|
-              return error[failure]
-            end
-          end.then(&path.output)
-        end
+          callback(other_state) do |failure|
+            return error[failure]
+          end
+        end.then(&path.output)
 
-        raise notice.traced(backtrace).exception
+        s1.set(path: state.path).except(:key)
+      rescue Notice::Fatal => e
+        raise e.traced(backtrace)
       end
 
       # A post-processor method
@@ -93,7 +93,7 @@ module Remap
       # @return [Map]
       def pending(reason = "Pending mapping")
         add do |state|
-          state.notice!(reason)
+          state.ignore!(reason)
         end
       end
 
@@ -152,7 +152,7 @@ module Remap
       def if(&block)
         add do |outer_state|
           outer_state.execute(&block).fmap do |bool, state|
-            bool ? outer_state.value : state.notice!("#if returned false")
+            bool ? outer_state.value : state.ignore!("#if returned false")
           end
         end
       end
@@ -180,7 +180,7 @@ module Remap
       def if_not(&block)
         add do |outer_state|
           outer_state.execute(&block).fmap do |bool, state|
-            bool ? state.notice!("#if_not returned false") : outer_state.value
+            bool ? state.ignore!("#if_not returned false") : outer_state.value
           end
         end
       end

data/lib/remap/selector/all.rb

@@ -32,7 +32,7 @@ module Remap
 
         outer_state.bind(quantifier: "*") do |enum, state|
           requirement[enum] do
-            state.fatal!("Expected enumeration but got %p (%s)", enum, enum.class)
+            state.fatal!("Expected enumerable")
           end
 
           state.map(&block)

data/lib/remap/selector/index.rb

@@ -30,21 +30,18 @@ module Remap
       # @yieldreturn [State<U>]
       #
       # @return [State<U>]
-      def call(outer_state, &block)
+      def call(state, &block)
         unless block_given?
           raise ArgumentError, "The index selector requires an iteration block"
         end
 
-        outer_state.bind(index: index) do |array, state|
+        state.bind(index: index) do |array, s|
           requirement[array] do
-            state.fatal!("Expected array but got %p (%s)", array, array.class)
+            s.fatal!("Expected an array")
           end
 
           element = array.fetch(index) do
-            state.ignore!("Index %s in array %p (%s) not found",
-                          index,
-                          array,
-                          array.class)
+            s.ignore!("Index %s not found", index)
           end
 
           state.set(element, index: index).then(&block)

data/lib/remap/selector/key.rb

@@ -27,22 +27,18 @@ module Remap
       # @yieldreturn [State<U>]
       #
       # @return [State<U>]
-      def call(outer_state, &block)
+      def call(state, &block)
         unless block_given?
           raise ArgumentError, "The key selector requires an iteration block"
         end
 
-        outer_state.bind(key: key) do |hash, state|
+        state.bind(key: key) do |hash, s|
           requirement[hash] do
-            state.fatal!("Expected hash but got %p (%s)", hash, hash.class)
+            s.fatal!("Expected hash")
           end
 
           value = hash.fetch(key) do
-            state.ignore!("Key %p (%s) not found in hash %p (%s)",
-                          key,
-                          key.class,
-                          hash,
-                          hash.class)
+            s.ignore!("Key not found")
           end
 
           state.set(value, key: key).then(&block)

data/lib/remap/state/extension.rb

@@ -54,17 +54,17 @@ module Remap
 
         # Throws :fatal containing a Notice
         def fatal!(...)
-          throw :fatal, notice(...)
+          notice(...).fatal!
         end
 
         # Throws :warn containing a Notice
         def notice!(...)
-          throw :notice, notice(...)
+          raise NotImplementedError, "Not implemented"
         end
 
         # Throws :ignore containing a Notice
         def ignore!(...)
-          throw :ignore, notice(...)
+          notice(...).ignore!
         end
 
         # Creates a notice containing the given message
@@ -132,12 +132,12 @@ module Remap
               list1 + list2
             in [:value, left, right]
               fatal!(
-                "Could not merge [%p] (%s) with [%p] (%s) @ %s",
-                left,
+                "Could not merge [%p] (%s) with [%p] (%s)",
+                left.formatted,
                 left.class,
-                right,
-                right.class,
-                (path + [key]).join("."))
+                right.formatted,
+                right.class
+              )
             in [:notices, Array => n1, Array => n2]
               n1 + n2
             in [Symbol, _, value]
@@ -218,7 +218,8 @@ module Remap
                 Notice.call(
                   reason: inner_reason,
                   path: path + sufix,
-                  **only(:value))
+                  **only(:value)
+                )
               end
             end
           end
@@ -241,9 +242,11 @@ module Remap
             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).notice!(reason)
+          s = set(**options)
+
+          fetch(:value) { return s }.then do |value|
+            block[value, s] do |reason, **other|
+              return s.set(**other).ignore!(reason)
             end
           end
         end
@@ -263,11 +266,13 @@ module Remap
               return error["Undefined returned, skipping!"]
             end
 
-            set(result)._
-          rescue KeyError, IndexError => e
-            error[e.message]
+            set(result)
+          rescue KeyError => e
+            set(path: path + [e.key]).ignore!(e.message)
+          rescue IndexError => e
+            ignore!(e.message)
           rescue PathError => e
-            ignore!("Path %s not defined for %p (%s)", e.path.join("."), value, value.class)
+            set(path: path + e.path).ignore!("Undefined path")
           end
         end
 

data/lib/remap/types.rb

@@ -17,6 +17,7 @@ module Remap
     Mapper     = Interface(:call!)
     Rule       = Interface(:call) | Instance(Proc)
     Key        = Interface(:hash)
+    Notice     = Instance(Remap::Notice)
 
     # Validates a state according to State::Schema
     State = Hash.constructor do |input, type, &error|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remap
 version: !ruby/object:Gem::Version
-  version: 2.2.30
+  version: 2.2.35
 platform: ruby
 authors:
 - Linus Oleander
@@ -272,8 +272,9 @@ files:
 - lib/remap/mapper/xor.rb
 - lib/remap/nothing.rb
 - lib/remap/notice.rb
-- lib/remap/notice/traced.rb
-- lib/remap/notice/untraced.rb
+- lib/remap/notice/error.rb
+- lib/remap/notice/fatal.rb
+- lib/remap/notice/ignore.rb
 - lib/remap/operation.rb
 - lib/remap/path.rb
 - lib/remap/path/input.rb

data/lib/remap/notice/traced.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Notice
-    class Traced < Concrete
-      attribute? :backtrace, Types::Backtrace, default: EMPTY_ARRAY
-
-      def traced(backtrace)
-        Notice.call(**attributes, backtrace: backtrace)
-      end
-
-      def exception
-        return super if backtrace.blank?
-
-        super.tap { _1.set_backtrace(backtrace.map(&:to_s)) }
-      end
-    end
-  end
-end

data/lib/remap/notice/untraced.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Notice
-    class Untraced < Concrete
-      def traced(backtrace)
-        Traced.call(**attributes, backtrace: backtrace)
-      end
-    end
-  end
-end