remap 2.1.13 → 2.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 526ddded05ad56900a9f6d1276069c48297adc6f5cb32ef08b955949bf9ee426
-  data.tar.gz: 239295549c9f0365453d19254fe21ff046755b6066f86a81596abaf102a98bbb
+  metadata.gz: 88204af4f42ce85893ec029d953e2e6c417bbacba673522eedadca9561f8f749
+  data.tar.gz: 9e3e6040baf0426590b4c920d33f0979e74a084a19bbd87079d474a9e251663a
 SHA512:
-  metadata.gz: 1c8d02457838ffe470359e5b9ff97cd2a31288928d238362eb38d85c190160b430242d2cfb401e9f7dbb418be4838dd6cbb1c282b68a7eababf5ad2d48030440
-  data.tar.gz: 191f1570f40e582c31e724e788882b54f83ff82e6d37931519451975355ceab5fb708260352523ddc10c849daa86d31c915221e9d539f2c069288462ca5dc45b
+  metadata.gz: 612cf547b8207f305cf9b1f4788d3b36c0d487f0c42bdbf657336c04982060f6dd46a0cfc2a57c39588cef15287ede98205ab5beb46c9245b3270a99b586934d
+  data.tar.gz: a11492555b465f2d9f2db0611ed8d6457579dc6546805a9a867fc7b951061572f0faae84caec4be50907efa99e15647a8ae52aefd0de14362d29d6fea45cb166

data/lib/remap/compiler.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Remap
+  using State::Extension
+
   # Constructs a {Rule} from the block passed to {Remap::Base.define}
   class Compiler < Proxy
     # @return [Array<Rule>]
@@ -29,12 +31,18 @@ module Remap
     # @return [Rule]
     def self.call(&block)
       unless block
-        return Rule::Void.new
+        return Rule::VOID
       end
 
-      new([]).tap do |compiler|
+      rules = new([]).tap do |compiler|
         compiler.instance_exec(&block)
-      end.rule
+      end.rules
+
+      if rules.empty?
+        return Rule::VOID
+      end
+
+      Rule::Block.new(rules)
     end
 
     # Maps input path [input] to output path [to]
@@ -59,13 +67,7 @@ module Remap
     #
     # @return [Rule::Map::Required]
     def map(*path, to: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
-      add Rule::Map::Required.call(
-        path: {
-          output: [to].flatten,
-          input: path.flatten
-        },
-        backtrace: backtrace,
-        rule: call(&block))
+      add rule(*path, to: to, backtrace: backtrace, &block)
     end
 
     # Optional version of {#map}
@@ -92,13 +94,7 @@ module Remap
     #
     # @return [Rule::Map::Optional]
     def map?(*path, to: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
-      add Rule::Map::Optional.call(
-        path: {
-          output: [to].flatten,
-          input: path.flatten
-        },
-        backtrace: backtrace,
-        rule: call(&block))
+      add rule?(*path, to: to, backtrace: backtrace, &block)
     end
 
     # Select a path and uses the same path as output
@@ -122,7 +118,7 @@ module Remap
     #
     # @return [Rule::Map::Required]
     def get(*path, backtrace: Kernel.caller, &block)
-      map(path, to: path, backtrace: backtrace, &block)
+      add rule(path, to: path, backtrace: backtrace, &block)
     end
 
     # Optional version of {#get}
@@ -147,7 +143,7 @@ module Remap
     #
     # @return [Rule::Map::Optional]
     def get?(*path, backtrace: Kernel.caller, &block)
-      map?(path, to: path, backtrace: backtrace, &block)
+      add rule?(path, to: path, backtrace: backtrace, &block)
     end
 
     # Maps using mapper
@@ -189,9 +185,13 @@ module Remap
         raise ArgumentError, "#embed does not take a block"
       end
 
-      add Rule::Embed.new(mapper: mapper)
-    rescue Dry::Struct::Error
-      raise ArgumentError, "Embeded mapper must be [Remap::Mapper], got [#{mapper}]"
+      embeding = rule(&block).add do |state, &error|
+        mapper.call!(state.set(mapper: mapper)) do |failure|
+          next error[failure]
+        end.except(:mapper, :scope)
+      end
+
+      add embeding
     end
 
     # Set a static value
@@ -234,9 +234,7 @@ module Remap
         raise ArgumentError, "#set does not take a block"
       end
 
-      add Rule::Set.new(path: path.flatten, value: to)
-    rescue Dry::Struct::Error => e
-      raise ArgumentError, e.message
+      add rule(to: path).add { to.call(_1) }
     end
 
     # Maps to path from map with block in between
@@ -261,7 +259,7 @@ module Remap
     #
     # @return [Rule::Map]
     def to(*path, map: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
-      map(*map, to: path, backtrace: backtrace, &block)
+      add rule(*map, to: path, backtrace: backtrace, &block)
     end
 
     # Optional version of {#to}
@@ -287,7 +285,7 @@ module Remap
     #
     # @return [Rule::Map::Optional]
     def to?(*path, map: EMPTY_ARRAY, &block)
-      map?(*map, to: path, &block)
+      add rule?(*map, to: path, &block)
     end
 
     # Iterates over the input value, passes each value
@@ -319,7 +317,7 @@ module Remap
         raise ArgumentError, "#each requires a block"
       end
 
-      add Rule::Each.new(rule: call(&block))
+      add rule(all, &block)
     end
 
     # Wraps output in type
@@ -352,9 +350,7 @@ module Remap
         raise ArgumentError, "#wrap requires a block"
       end
 
-      add Rule::Wrap.new(type: type, rule: call(&block))
-    rescue Dry::Struct::Error => e
-      raise ArgumentError, e.message
+      add rule(&block).then { Array.wrap(_1) }
     end
 
     # Selects all elements
@@ -521,19 +517,31 @@ module Remap
       at(-1)
     end
 
-    # The final rule
-    #
-    # @return [Rule]
-    #
-    # @private
-    def rule
-      Rule::Collection.call(rules: rules)
-    end
-
     private
 
     def add(rule)
       rule.tap { rules << rule }
     end
+
+    def rule(*path, to: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
+      Rule::Map::Required.call({
+        path: {
+          output: [to].flatten,
+          input: path.flatten
+        },
+        backtrace: backtrace,
+        rule: call(&block)
+      })
+    end
+
+    def rule?(*path, to: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
+      Rule::Map::Optional.call({
+        path: {
+          output: [to].flatten,
+          input: path.flatten
+        },
+        rule: call(&block)
+      })
+    end
   end
 end

data/lib/remap/extensions/enumerable.rb

@@ -38,6 +38,8 @@ module Remap
             end
 
             [current_path + [key], value]
+          rescue TypeError
+            raise PathError, current_path + [key]
           end
 
           result

data/lib/remap/rule/block.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    using State::Extension
+
+    class Block < Unit
+      # @return [Array<Rule>]
+      attribute :rules, [Types::Rule]
+
+      # Represents a non-empty define block with one or more rules
+      # Calls every {#rules} with state and merges the output
+      #
+      # @param state [State]
+      #
+      # @return [State]
+      def call(state, &error)
+        unless block_given?
+          raise ArgumentError, "Block#call(state, &error) requires a block"
+        end
+
+        if rules.empty?
+          return state.except(:value)
+        end
+
+        rules.map do |rule|
+          rule.call(state) do |failure|
+            return error[failure]
+          end
+        end.reduce(&:combine)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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() }
+
+        alias execute instance_eval
+
+        # Builds an enumeration using the block as context
+        #
+        # @example
+        #   enum = Remap::Rule::Map::Enum.call do
+        #     from "B", to: "C"
+        #     value "A"
+        #     otherwise "D"
+        #   end
+        #
+        #   enum.get("A") # => "A"
+        #   enum.get("B") # => "C"
+        #   enum.get("C") # => "C"
+        #   enum.get("MISSING") # => "D"
+        #
+        # @return [Any]
+        def self.call(&block)
+          unless block
+            raise ArgumentError, "no block given"
+          end
+
+          new.tap { _1.execute(&block) }
+        end
+
+        # Translates key into a value using predefined mappings
+        #
+        # @param key [#hash]
+        #
+        # @yield [String]
+        #   If the key is not found & no default value is set
+        #
+        # @return [Any]
+        def get(key, &error)
+          unless error
+            return get(key) { raise Error, _1 }
+          end
+
+          self[key].bind { return _1 }.or do
+            error["Enum key [#{key}] not found among [#{mappings.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
+          end
+        end
+
+        # @return [void]
+        def value(*ids)
+          ids.each do |id|
+            from(id, to: id)
+          end
+        end
+
+        # @return [void]
+        def otherwise(value)
+          mappings.default = Some(value)
+        end
+      end
+    end
+  end
+end

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

@@ -31,7 +31,7 @@ module Remap
         #
         # @return [State]
         def call(state, &error)
-          unless error
+          unless block_given?
             raise ArgumentError, "map.call(state, &error) requires a block"
           end
 

data/lib/remap/rule/map.rb

@@ -43,15 +43,19 @@ module Remap
       #
       # @abstract
       def call(state, &error)
-        unless error
+        unless block_given?
           raise ArgumentError, "Map#call(state, &error) requires error handler block"
         end
 
         notice = catch :fatal do
           return path.input.call(state) do |inner_state|
-            rule.call(inner_state) do |failure|
+            other_state = rule.call(inner_state) do |failure|
               return error[failure]
-            end.then(&callback)
+            end
+
+            callback(other_state) do |failure|
+              return error[failure]
+            end
           end.then(&path.output)
         end
 
@@ -181,23 +185,27 @@ module Remap
         end
       end
 
-      private
-
       # @return [self]
       def add(&block)
         tap { fn << block }
       end
 
+      private
+
       # @return [Array<Proc>]
       def fn
         @fn ||= []
       end
 
       # @return [Proc]
-      def callback
-        -> state do
-          fn.reduce(state) do |inner, fn|
-            fn[inner]
+      def callback(state, &error)
+        unless block_given?
+          raise ArgumentError, "Map#callback(state, &error) requires error handler block"
+        end
+
+        fn.reduce(state) do |inner, fn|
+          fn[inner] do |failure|
+            return error[failure]
           end
         end
       end

data/lib/remap/rule.rb

@@ -5,6 +5,8 @@ module Remap
     defines :requirement
     requirement Types::Any
 
+    VOID = Void.new(EMPTY_HASH)
+
     # @param state [State]
     #
     # @abstract

data/lib/remap/selector/index.rb

@@ -8,8 +8,15 @@ module Remap
     #
     # @example Select the value at index 1 from a array
     #   state = Remap::State.call([:one, :two, :tree])
-    #   result = Remap::Selector::Index.new(1).call(state)
-    #   result.fetch(:value) # => :two
+    #   index = Remap::Selector::Index.new(1)
+    #
+    #   result = index.call(state) do |element|
+    #     element.fmap do |value|
+    #       value.upcase
+    #     end
+    #   end
+
+    #   result.fetch(:value) # => :TWO
     class Index < Unit
       # @return [Integer]
       attribute :index, Integer
@@ -25,7 +32,9 @@ module Remap
       #
       # @return [State<U>]
       def call(outer_state, &block)
-        return call(outer_state, &:itself) unless block
+        unless block_given?
+          raise ArgumentError, "The index selector requires an iteration block"
+        end
 
         outer_state.bind(index: index) do |array, state|
           requirement[array] do

data/lib/remap/state/extension.rb

@@ -351,7 +351,7 @@ module Remap
         #
         # @return [Struct]
         def context(value, context: self, &error)
-          ::Struct.new(*keys, *options.keys, keyword_init: true) do
+          ::Struct.new(*keys, *options.keys, :state, keyword_init: true) do
             define_method :method_missing do |name, *|
               error["Method [#{name}] not defined"]
             end
@@ -359,7 +359,7 @@ module Remap
             define_method :skip! do |message = "Manual skip!"|
               context.ignore!(message)
             end
-          end.new(**to_hash, **options, value: value)
+          end.new(**to_hash, **options, value: value, state: self)
         end
       end
     end

data/lib/remap/types.rb

@@ -15,7 +15,7 @@ module Remap
     Enumerable = Any.constrained(type: Enumerable)
     Nothing    = Constant(Remap::Nothing)
     Mapper     = Interface(:call!)
-    Rule       = Interface(:call)
+    Rule       = Interface(:call) | Instance(Proc)
     Key        = Interface(:hash)
 
     # Validates a state according to State::Schema

data/lib/remap.rb

@@ -17,7 +17,6 @@ require "zeitwerk"
 
 module Remap
   loader = Zeitwerk::Loader.for_gem
-  loader.collapse("#{__dir__}/remap/rule/support")
   loader.collapse("#{__dir__}/remap/mapper/support")
   loader.setup
   loader.eager_load

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remap
 version: !ruby/object:Gem::Version
-  version: 2.1.13
+  version: 2.1.14
 platform: ruby
 authors:
 - Linus Oleander
@@ -279,18 +279,12 @@ files:
 - lib/remap/path_error.rb
 - lib/remap/proxy.rb
 - lib/remap/rule.rb
-- lib/remap/rule/each.rb
-- lib/remap/rule/embed.rb
+- lib/remap/rule/block.rb
 - lib/remap/rule/map.rb
+- lib/remap/rule/map/enum.rb
 - lib/remap/rule/map/optional.rb
 - lib/remap/rule/map/required.rb
-- lib/remap/rule/set.rb
-- lib/remap/rule/support/collection.rb
-- lib/remap/rule/support/collection/empty.rb
-- lib/remap/rule/support/collection/filled.rb
-- lib/remap/rule/support/enum.rb
 - lib/remap/rule/void.rb
-- lib/remap/rule/wrap.rb
 - lib/remap/selector.rb
 - lib/remap/selector/all.rb
 - lib/remap/selector/index.rb

data/lib/remap/rule/each.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Rule
-    using State::Extension
-
-    # Iterates over a rule, even if the rule is not a collection
-    #
-    # @example Upcase each value in an array
-    #   state = Remap::State.call(["John", "Jane"])
-    #   upcase = Remap::Rule::Map.call({}).then(&:upcase)
-    #   each = Remap::Rule::Each.call(rule: upcase)
-    #   error = -> failure { raise failure.exception }
-    #   each.call(state, &error).fetch(:value) # => ["JOHN", "JANE"]
-    class Each < Unit
-      # @return [Rule]
-      attribute :rule, Types::Rule
-
-      # Iterates over state and passes each value to rule
-      # Restores element, key & index before returning state
-      #
-      # @param state [State<Enumerable>]
-      #
-      # @return [State<Enumerable>]
-      def call(state, &error)
-        unless error
-          raise ArgumentError, "Each#call(state, &error) requires a block"
-        end
-
-        state.map do |inner_state|
-          rule.call(inner_state) do |failure|
-            return error[failure]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/remap/rule/embed.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Rule
-    using State::Extension
-
-    # Embed mappers into each other
-    #
-    # @example Embed Mapper A into B
-    #   class Car < Remap::Base
-    #     define do
-    #       map :name, to: :model
-    #     end
-    #   end
-    #
-    #   class Person < Remap::Base
-    #     define do
-    #       to :person do
-    #         to :car do
-    #           embed Car
-    #         end
-    #       end
-    #     end
-    #   end
-    #
-    #   Person.call({name: "Volvo"}) # => { person: { car: { model: "Volvo" } } }
-    class Embed < Unit
-      # @return [#call!]
-      attribute :mapper, Types::Mapper
-
-      # Evaluates input against mapper and returns the result
-      #
-      # @param state [State<T>]
-      #
-      # @return [State<U>]
-      def call(state, &error)
-        unless error
-          raise ArgumentError, "A block is required to evaluate the embed"
-        end
-
-        mapper.call!(state.set(mapper: mapper)) do |failure|
-          return error[failure]
-        end.except(:mapper, :scope)
-      end
-    end
-  end
-end

data/lib/remap/rule/set.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Rule
-    using State::Extension
-
-    # Set path to a static value
-    #
-    # @example Set path [:a, :b] to value "C"
-    #   value = Remap::Static::Fixed.new(value: "a value")
-    #   set = Remap::Rule::Set.new(value: value, path: [:a, :b])
-    #   state = Remap::State.call("ANY VALUE")
-    #   set.call(state).fetch(:value) # => { a: { b: "a value" } }
-    #
-    # @example Set path [:a, :b] to option :c
-    #   value = Remap::Static::Option.new(name: :c)
-    #   set = Remap::Rule::Set.new(value: value, path: [:a, :b])
-    #   state = Remap::State.call("ANY VALUE", options: { c: "C" })
-    #   set.call(state).fetch(:value) # => { a: { b: "C" } }
-    class Set < Concrete
-      # @return [Static]
-      attribute :value, Static, alias: :rule
-
-      # @return [Path::Output]
-      attribute :path, Path::Output
-
-      # @see Rule#call
-      def call(...)
-        rule.call(...).then(&path)
-      end
-    end
-  end
-end

data/lib/remap/rule/support/collection/empty.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Rule
-    class Collection
-      using State::Extension
-
-      # Represents an empty rule block
-      class Empty < Unit
-        attribute? :rules, Value(EMPTY_ARRAY), default: EMPTY_ARRAY
-
-        # Represents an empty define block, without any rules
-        #
-        # @param state [State<T>]
-        #
-        # @return [State<T>]
-        def call(state)
-          state.notice!("No rules, empty block")
-        end
-      end
-    end
-  end
-end

data/lib/remap/rule/support/collection/filled.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Rule
-    class Collection
-      using State::Extension
-
-      # Represents a non-empty rule block
-      #
-      # @example A collection containing a single rule
-      #   state = Remap::State.call("A")
-      #   void = Remap::Rule::Void.call({})
-      #   rule = Remap::Rule::Collection.call([void])
-      #   error = -> failure { raise failure.exception }
-      #   rule.call(state, &error).fetch(:value) # => "A"
-      class Filled < Unit
-        # @return [Array<Rule>]
-        attribute :rules, [Types.Interface(:call)], min_size: 1
-
-        # Represents a non-empty define block with one or more rules
-        # Calls every {#rules} with state and merges the output
-        #
-        # @param state [State]
-        #
-        # @return [State]
-        def call(state, &error)
-          unless error
-            raise ArgumentError, "Collection::Filled#call(state, &error) requires a block"
-          end
-
-          rules.map do |rule|
-            rule.call(state) do |failure|
-              return error[failure]
-            end
-          end.reduce(&:combine)
-        end
-      end
-    end
-  end
-end

data/lib/remap/rule/support/collection.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Rule
-    # Represents a block defined by a rule
-    class Collection < Abstract
-      attribute :rules, Array
-
-      # @param state [State]
-      #
-      # @return [State]
-      #
-      # @abstract
-      def call(state)
-        raise NotImplementedError, "#{self.class}#call not implemented"
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Rule
-    class Enum < Proxy
-      include Dry::Monads[:maybe]
-
-      # @return [Hash]
-      option :mappings, default: -> { Hash.new { default } }
-
-      # @return [Maybe]
-      option :default, default: -> { None() }
-
-      alias execute instance_eval
-
-      # Builds an enumeration using the block as context
-      #
-      # @example
-      #   enum = Remap::Rule::Enum.call do
-      #     from "B", to: "C"
-      #     value "A"
-      #     otherwise "D"
-      #   end
-      #
-      #   enum.get("A") # => "A"
-      #   enum.get("B") # => "C"
-      #   enum.get("C") # => "C"
-      #   enum.get("MISSING") # => "D"
-      #
-      # @return [Any]
-      def self.call(&block)
-        unless block
-          raise ArgumentError, "no block given"
-        end
-
-        new.tap { _1.execute(&block) }
-      end
-
-      # Translates key into a value using predefined mappings
-      #
-      # @param key [#hash]
-      #
-      # @yield [String]
-      #   If the key is not found & no default value is set
-      #
-      # @return [Any]
-      def get(key, &error)
-        unless error
-          return get(key) { raise Error, _1 }
-        end
-
-        self[key].bind { return _1 }.or do
-          error["Enum key [#{key}] not found among [#{mappings.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
-        end
-      end
-
-      # @return [void]
-      def value(*ids)
-        ids.each do |id|
-          from(id, to: id)
-        end
-      end
-
-      # @return [void]
-      def otherwise(value)
-        mappings.default = Some(value)
-      end
-    end
-  end
-end

data/lib/remap/rule/wrap.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Rule
-    using State::Extension
-
-    # Wraps rule in a type
-    #
-    # @example Maps { name: "Ford" } to { cars: ["Ford"] }
-    #   class Mapper < Remap::Base
-    #     define do
-    #       to :cars do
-    #         wrap(:array) do
-    #           map :name
-    #         end
-    #       end
-    #     end
-    #   end
-    #
-    #   Mapper.call({ name: "Ford" }) # => { cars: ["Ford"] }
-    class Wrap < Concrete
-      # @return [:array]
-      attribute :type, Value(:array)
-
-      # @return [Rule]
-      attribute :rule, Types::Rule
-
-      # Wraps the output from {#rule} in a {#type}
-      #
-      # @see Rule#call
-      def call(...)
-        rule.call(...).fmap do |value|
-          Array.wrap(value)
-        end
-      end
-    end
-  end
-end