remap 2.2.42 → 2.2.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 791eca1356feec6a254c824130b798026851d4f0e56207b32144ba36f64d06a5
-  data.tar.gz: f7908a2f3dd0d4847860e342d4f11fa298ba5f9689bf8293d585122993ba40cc
+  metadata.gz: 71b1a0f8a9cb714d568939ace38b13d053e4c1ddf9131a6040630ff4a1479e4a
+  data.tar.gz: fe768a12f868c085839145d28a609a707c4aacb10a18c16e2276e51b23de0fb5
 SHA512:
-  metadata.gz: 7eaed51a433437e884ea6af6485ad81752bfb5c7c388e678794c4e17447311b23aaa32d529451fbb70080617b9654f227fa7ac810d3dbff8e7c9c3e403f8de52
-  data.tar.gz: 3e14bdd50fa6e3ff3ad77589b969b294161a5878c007b9adba387614c3bcd86300e89ae72d9ea0252739269900757747294b7b89b8e0d2b6ad0ae162d363bd47
+  metadata.gz: 2f5f657a29f997cf1161eda204a2ddd38f1c6dcc991c8467732d367bc31302c7bafd1e05f5a7655cc5ef46dea5498b9caec6fb9d75d2bd1e9aa5c7f34f7a8ec9
+  data.tar.gz: 9263defd99a669a7bcee25381df7a74698cb2ab691b5a2cf22e7cfdb83a8898956b1a17e329e7560e920ad762093822b85c40587dd6bdcf77ab2433188857474

data/lib/remap/base.rb

@@ -107,13 +107,12 @@ module Remap
     include ActiveSupport::Configurable
     include Dry::Core::Constants
     include Catchable
-
     extend Mapper::API
-
     using State::Extension
 
     with_options instance_accessor: true do |scope|
       scope.config_accessor(:contract) { Dry::Schema.define {} }
+      scope.config_accessor(:config_options) { Config.new }
       scope.config_accessor(:constructor) { IDENTITY }
       scope.config_accessor(:options) { EMPTY_ARRAY }
       scope.config_accessor(:option) { EMPTY_HASH }
@@ -265,6 +264,25 @@ module Remap
       new(state.options).call(state, &error)
     end
 
+    # Configuration options for the mapper
+    #
+    # @yield [Config]
+    # @yieldreturn [void]
+    #
+    # @return [void]
+    def self.configuration(&block)
+      config = Config.new
+      block[config]
+      self.config_options = config
+    end
+
+    # @see Mapper::API
+    #
+    # @private
+    def self.validate?
+      config_options.validation
+    end
+
     # Mappers state according to the mapper rules
     #
     # @param state [State]
@@ -287,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/config.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Remap
+  class Config < OpenStruct
+    def initialize
+      super(validation: false)
+    end
+  end
+end

data/lib/remap/extensions/array.rb

@@ -4,6 +4,8 @@ module Remap
   module Extensions
     module Array
       refine ::Array do
+        using Object
+
         # @return [Array<Hash>]
         def to_hash
           map(&:to_hash)

data/lib/remap/extensions/hash.rb

@@ -5,7 +5,7 @@ module Remap
     module Hash
       refine ::Hash do
         def formatted
-          JSON.neat_generate(self, sort: true, wrap: 40, aligned: true, around_colon: 1)
+          JSON.neat_generate(compact_blank, sort: true, wrap: 40, aligned: true, around_colon: 1)
         end
       end
     end

data/lib/remap/mapper/and.rb

@@ -46,6 +46,12 @@ module Remap
 
         state1.combine(state2)
       end
+
+      # @return [String]
+      def inspect
+        "%s & %s" % [left, right]
+      end
+      alias to_s inspect
     end
   end
 end

data/lib/remap/mapper/binary.rb

@@ -8,6 +8,11 @@ module Remap
 
       attribute :left, Types::Mapper
       attribute :right, Types::Mapper
+
+      # @return [Bool]
+      def validate?
+        left.validate? && right.validate?
+      end
     end
   end
 end

data/lib/remap/mapper/or.rb

@@ -39,6 +39,12 @@ module Remap
           end
         end
       end
+
+      # @return [String]
+      def inspect
+        "%s | %s" % [left, right]
+      end
+      alias to_s inspect
     end
   end
 end

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

@@ -5,6 +5,22 @@ module Remap
     using State::Extension
 
     module API
+      # @return [Boolean]
+      #
+      # @abstract
+      # @private
+      def validate?
+        raise NotImplementedError, "`validate?` is not implemented for #{self}"
+      end
+
+      # @param input [Any]
+      # @param backtrace [Array<String>]
+      # @param options [Hash]
+      #
+      # @yieldparam [Failure]
+      # @yieldreturn [T]
+      #
+      # @return [Any, T]
       def call(input, backtrace: caller, **options, &error)
         unless block_given?
           return call(input, **options) do |failure|

data/lib/remap/mapper/xor.rb

@@ -44,6 +44,12 @@ module Remap
 
         state1.combine(state2).failure("Both left and right passed xor operation").then(&error)
       end
+
+      # @return [String]
+      def inspect
+        "%s ^ %s" % [left, right]
+      end
+      alias to_s inspect
     end
   end
 end

data/lib/remap/notice/error.rb

@@ -11,27 +11,6 @@ module Remap
       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)
-        e = Traced.new(notice: notice)
-        e.set_backtrace(backtrace)
-        e
-      end
-    end
-
-    class Traced < Error
     end
   end
 end

data/lib/remap/notice.rb

@@ -20,19 +20,5 @@ module Remap
     def to_hash
       super.except(:backtrace).compact_blank
     end
-
-    # 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/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 { 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.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
@@ -92,6 +87,8 @@ module Remap
         #
         # @return [self]
         def _(&block)
+          return self unless mapper.validate?
+
           unless block
             return _ do |reason|
               raise ArgumentError, "[BUG] State: #{formatted} reason: #{reason.formatted}"
@@ -320,6 +317,11 @@ module Remap
           fetch(:id)
         end
 
+        # @return [Mapper::API]
+        def mapper
+          fetch(:mapper)
+        end
+
         # @return [Array<Symbol>]
         def ids
           fetch(:ids)
@@ -378,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]

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/types.rb

@@ -18,6 +18,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|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: remap
 version: !ruby/object:Gem::Version
-  version: 2.2.42
+  version: 2.2.46
 platform: ruby
 authors:
 - Linus Oleander
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-15 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -251,6 +251,7 @@ files:
 - lib/remap/catchable.rb
 - lib/remap/class_interface.rb
 - lib/remap/compiler.rb
+- lib/remap/config.rb
 - lib/remap/constructor.rb
 - lib/remap/constructor/argument.rb
 - lib/remap/constructor/keyword.rb