remap 2.2.46 → 2.2.47

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71b1a0f8a9cb714d568939ace38b13d053e4c1ddf9131a6040630ff4a1479e4a
-  data.tar.gz: fe768a12f868c085839145d28a609a707c4aacb10a18c16e2276e51b23de0fb5
+  metadata.gz: d745b7e030764a548c8cb8b2651e89cf22485154120bab89053743653d0ccd9a
+  data.tar.gz: '04408f1457593d3c2f3fb8fc5d52f275b74e9d3f0eb31a4088d073ee93ddeeb6'
 SHA512:
-  metadata.gz: 2f5f657a29f997cf1161eda204a2ddd38f1c6dcc991c8467732d367bc31302c7bafd1e05f5a7655cc5ef46dea5498b9caec6fb9d75d2bd1e9aa5c7f34f7a8ec9
-  data.tar.gz: 9263defd99a669a7bcee25381df7a74698cb2ab691b5a2cf22e7cfdb83a8898956b1a17e329e7560e920ad762093822b85c40587dd6bdcf77ab2433188857474
+  metadata.gz: 2fb3e7f89ed0dea90a33a33dee5f5a5b358f22de24b24a64e531a7a84196da067e621060ab21045efb810c02cc8af0f53e7ca43d36ddad3124fb1a2212973a81
+  data.tar.gz: ad67a4ec14390748e9df5d77f8093c44143ae63df023a5ea84434ab79f7c5a894f1df0cdf7b3ce38b19fea44668b19ba269b3185d18d6deaa435a4620f1a733f

data/lib/remap/base.rb

@@ -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
 
@@ -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/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
 

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

@@ -26,8 +26,11 @@ module Remap
           s2 = state.set(fatal_id: fatal_id)
 
           catch_ignored(s1) do |s3, id:|
-            rules.reduce(s3) do |s4, rule|
-              s5 = rule.call(s2)
+            states = rules.map do |rule|
+              rule.call(s2)
+            end
+
+            states.reduce(s3) do |s4, s5|
               s6 = s5.set(id: id)
               s4.combine(s6)
             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/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,11 +46,7 @@ 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
 
         # @see #notice
@@ -112,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]
@@ -130,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)",
@@ -142,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
@@ -160,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
@@ -198,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
@@ -235,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
         #
@@ -262,7 +270,7 @@ module Remap
         #
         # @return [Y]
         def bind(**options, &block)
-          unless block_given?
+          unless block
             raise ArgumentError, "State#bind requires a block"
           end
 
@@ -282,19 +290,23 @@ 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
+                throw :done, context(value).instance_exec(value, &block)
+              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
 

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"
 

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.46
+  version: 2.2.47
 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