remap 2.1.11 → 2.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f0c60203b3136553a963df2e9f574155d59548fb8eae484f5f1c0cf20fdfe47
-  data.tar.gz: e9a6b23ed253e56151fe7722846f7959bf769c7c37248f142194e83ec08ed0e8
+  metadata.gz: e3439c23b054b2470688ec55cedb4dc0d7c0f77544c45f8f47c82b5d8d9b954a
+  data.tar.gz: 515558fee642db02bd30e5194846a4486f6b59c67830c46581b9b3d3c529532e
 SHA512:
-  metadata.gz: 3cf87719908f3b0b5d3c51fd3b2d30f79ac7409f920045510351083519d579cae8c111b26d859b4592dec7735033918f22ab61fe21c6543a55125d7f9408478a
-  data.tar.gz: 22d6e07824458f296d81d7cc02fb3ca0c7394e7d22f524feb387cba22decd708313a837f156bdf6008ab4c5d542b5bb3c303118b1dc070dce5bb9736f8a3bef3
+  metadata.gz: 599b8f2de0d62e5d4ab8ded2d303243fe11292f0cc621b7cdf66bb9e70ac712bb3fe4811cd926e9929a06f110445e283b2b8c3134a68cec5c810c53f572f720c
+  data.tar.gz: 6cf4704750445ac8dfdac08cfe2beec2bff5ac34db4c61557f9239b49857c3a1423978d6cc38342917753d48b4edeeff397d012c8b91d32a3ee49ec96ab62fa4

data/lib/remap/base.rb

@@ -143,7 +143,7 @@ module Remap
     #
     # @return [void]
     def self.contract(&context)
-      self.contract = Dry::Schema.JSON(&context)
+      self.contract = Dry::Schema.define(&context)
     end
 
     # Defines a rule for the mapper
@@ -236,14 +236,12 @@ module Remap
     #
     # @return [void]
     def self.define(target = Nothing, method: :new, strategy: :argument, &context)
-      unless context
-        raise ArgumentError, "Missing block"
+      unless block_given?
+        raise ArgumentError, "#{self}.define requires a block"
       end
 
-      self.context = Compiler.call(&context)
       self.constructor = Constructor.call(method: method, strategy: strategy, target: target)
-    rescue Dry::Struct::Error => e
-      raise ArgumentError, e.message
+      self.context = Compiler.call(&context)
     end
 
     # Similar to {::call}, but takes a state
@@ -269,7 +267,7 @@ module Remap
     #
     # @private
     def call(state, &error)
-      unless error
+      unless block_given?
         raise ArgumentError, "Base#call(state, &error) requires block"
       end
 

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>]
@@ -28,13 +30,15 @@ module Remap
     #
     # @return [Rule]
     def self.call(&block)
-      unless block
-        return Rule::Void.new
+      unless block_given?
+        return Rule::VOID
       end
 
-      new([]).tap do |compiler|
+      rules = new([]).tap do |compiler|
         compiler.instance_exec(&block)
-      end.rule
+      end.rules
+
+      Rule::Block.new(rules)
     end
 
     # Maps input path [input] to output path [to]
@@ -58,14 +62,8 @@ module Remap
     #   output.fetch(:value) # => { nickname: "John" }
     #
     # @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))
+    def map(*path, to: EMPTY_ARRAY, backtrace: caller, &block)
+      add rule(*path, to: to, backtrace: backtrace, &block)
     end
 
     # Optional version of {#map}
@@ -91,14 +89,8 @@ module Remap
     # @see #map
     #
     # @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))
+    def map?(*path, to: EMPTY_ARRAY, backtrace: caller, &block)
+      add rule?(*path, to: to, backtrace: backtrace, &block)
     end
 
     # Select a path and uses the same path as output
@@ -121,8 +113,8 @@ module Remap
     #   output.fetch(:value) # => { name: "John" }
     #
     # @return [Rule::Map::Required]
-    def get(*path, backtrace: Kernel.caller, &block)
-      map(path, to: path, backtrace: backtrace, &block)
+    def get(*path, backtrace: caller, &block)
+      add rule(path, to: path, backtrace: backtrace, &block)
     end
 
     # Optional version of {#get}
@@ -146,8 +138,8 @@ module Remap
     # @see #get
     #
     # @return [Rule::Map::Optional]
-    def get?(*path, backtrace: Kernel.caller, &block)
-      map?(path, to: path, backtrace: backtrace, &block)
+    def get?(*path, backtrace: caller, &block)
+      add rule?(path, to: path, backtrace: backtrace, &block)
     end
 
     # Maps using mapper
@@ -184,14 +176,18 @@ module Remap
     #   output.fetch(:value) # => { car: "Volvo" }
     #
     # @return [Rule::Embed]
-    def embed(mapper, &block)
-      if block
+    def embed(mapper)
+      if block_given?
         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.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
@@ -229,14 +225,12 @@ module Remap
     # @raise [ArgumentError]
     #   if no path given
     #   if path is not a Symbol or Array<Symbol>
-    def set(*path, to:, &block)
-      if block
+    def set(*path, to:)
+      if block_given?
         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
@@ -260,8 +254,8 @@ module Remap
     #   output.fetch(:value) # => { nickname: "John" }
     #
     # @return [Rule::Map]
-    def to(*path, map: EMPTY_ARRAY, backtrace: Kernel.caller, &block)
-      map(*map, to: path, backtrace: backtrace, &block)
+    def to(*path, map: EMPTY_ARRAY, backtrace: caller, &block)
+      add rule(*map, to: path, backtrace: backtrace, &block)
     end
 
     # Optional version of {#to}
@@ -287,7 +281,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
@@ -315,11 +309,11 @@ module Remap
     # @return [Rule::Each]]
     # @raise [ArgumentError] if no block given
     def each(&block)
-      unless block
+      unless block_given?
         raise ArgumentError, "#each requires a block"
       end
 
-      add Rule::Each.new(rule: call(&block))
+      add rule(all, &block)
     end
 
     # Wraps output in type
@@ -348,13 +342,11 @@ module Remap
     # @return [Rule::Wrap]
     # @raise [ArgumentError] if type is not :array
     def wrap(type, &block)
-      unless block
+      unless block_given?
         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
@@ -376,8 +368,8 @@ module Remap
     #   output.fetch(:value) # => { names: ["John", "Jane"] }
     #
     # @return [Rule::Path::Segment::Quantifier::All]
-    def all(&block)
-      if block
+    def all
+      if block_given?
         raise ArgumentError, "all selector does not take a block"
       end
 
@@ -402,8 +394,8 @@ module Remap
     #   output.fetch(:value) # => { api_key: "<SECRET>" }
     #
     # @return [Rule::Static::Fixed]
-    def value(value, &block)
-      if block
+    def value(value)
+      if block_given?
         raise ArgumentError, "option selector does not take a block"
       end
 
@@ -428,8 +420,8 @@ module Remap
     # @param id [Symbol]
     #
     # @return [Rule::Static::Option]
-    def option(id, backtrace: Kernel.caller, &block)
-      if block
+    def option(id, backtrace: caller)
+      if block_given?
         raise ArgumentError, "option selector does not take a block"
       end
 
@@ -457,8 +449,8 @@ module Remap
     #
     # @return [Path::Segment::Key]
     # @raise [ArgumentError] if index is not an Integer
-    def at(index, &block)
-      if block
+    def at(index)
+      if block_given?
         raise ArgumentError, "first selector does not take a block"
       end
 
@@ -486,8 +478,8 @@ module Remap
     #   output.fetch(:value) # => { name: "John" }
     #
     # @return [Path::Segment::Key]]
-    def first(&block)
-      if block
+    def first
+      if block_given?
         raise ArgumentError, "first selector does not take a block"
       end
 
@@ -513,27 +505,39 @@ module Remap
     #   output.fetch(:value) # => { name: "Linus" }
     #
     # @return [Path::Segment::Key]
-    def last(&block)
-      if block
+    def last
+      if block_given?
         raise ArgumentError, "last selector does not take a block"
       end
 
       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: 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: 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

@@ -28,19 +28,20 @@ module Remap
         # @return [Any]
         #
         # @raise When path cannot be found
-        def get(*path, &error)
-          _, result = path.reduce([
-            EMPTY_ARRAY,
-            self
-          ]) do |(current_path, element), key|
-            value = element.fetch(key) do
-              raise PathError, current_path + [key]
-            end
+        def get(*path, trace: [], &fallback)
+          return self if path.empty?
+
+          key = path.first
 
-            [current_path + [key], value]
+          unless block_given?
+            get(*path, trace: trace) do
+              raise PathError, trace + [key]
+            end
           end
 
-          result
+          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

@@ -17,14 +17,29 @@ module Remap
           block["Expected a state, got [#{self}] (#{self.class})"]
         end
 
+        # @return [Array]
+        #
+        # @see Extension::Paths::Hash
+        def paths
+          []
+        end
+
         # Fallback method used when #get is called on an object that does not respond to #get
         #
         # Block is invoked, if provided
         # Otherwise a symbol is thrown
         #
         # @param path [Array<Key>]
-        def get(*path, &block)
-          raise PathError, []
+        def get(*path, trace: [], &fallback)
+          return self if path.empty?
+
+          unless block_given?
+            get(*path, trace: trace) do
+              raise PathError, trace
+            end
+          end
+
+          yield
         end
         alias_method :fetch, :get
 

data/lib/remap/failure.rb

@@ -14,22 +14,21 @@ module Remap
     # @return [Failure]
     def merge(other)
       unless other.is_a?(self.class)
-        raise ArgumentError, "can't merge #{self.class} with #{other.class}"
+        raise ArgumentError, "Cannot merge %s (%s) with %s (%s)" % [
+          self, self.class, other, other.class
+        ]
       end
 
-      failure = attributes.deep_merge(other.attributes) do |_, value1, value2|
-        case [value1, value2]
-        in [Array, Array]
+      failure = attributes.deep_merge(other.attributes) do |key, value1, value2|
+        case [key, value1, value2]
+        in [:failures | :notices, Array, Array]
           value1 + value2
-        else
-          raise ArgumentError, "can't merge #{self.class} with #{other.class}"
         end
       end
 
       new(failure)
     end
 
-    # @return [String]
     def exception
       Error.new(attributes.formated)
     end

data/lib/remap/proxy.rb

@@ -8,6 +8,7 @@ module Remap
 
     include Dry::Core::Constants
     extend Dry::Initializer
+    include Kernel
 
     # See Object#tap
     def tap(&block)

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

@@ -9,11 +9,29 @@ module Remap
         # Represents an optional mapping rule
         # When the mapping fails, the value is ignored
         #
+        # @example Map [:name] to [:nickname]
+        #   map = Map::Optional.call({
+        #     path: {
+        #       input: [:name],
+        #       output: [:nickname]
+        #     }
+        #   })
+        #
+        #   state = Remap::State.call({
+        #     name: "John"
+        #   })
+        #
+        #   output = map.call(state) do |failure|
+        #     raise failure.exeception
+        #   end
+        #
+        #   output.fetch(:value) # => { nickname: "John" }
+        #
         # @param state [State]
         #
         # @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/required.rb

@@ -11,6 +11,25 @@ module Remap
         # Represents a required mapping rule
         # When it fails, the entire mapping is marked as failed
         #
+        # @example Map [:name] to [:nickname]
+        #   map = Map::Required.call({
+        #     backtrace: caller,
+        #     path: {
+        #       input: [:name],
+        #       output: [:nickname]
+        #     }
+        #   })
+        #
+        #   state = Remap::State.call({
+        #     name: "John"
+        #   })
+        #
+        #   output = map.call(state) do |failure|
+        #     raise failure.exeception
+        #   end
+        #
+        #   output.fetch(:value) # => { nickname: "John" }
+        #
         # @param state [State]
         #
         # @return [State]

data/lib/remap/rule/map.rb

@@ -28,7 +28,7 @@ module Remap
       attribute? :path, Path.default { Path.call(EMPTY_HASH) }
 
       # @return [Rule]
-      attribute :rule, Rule.default { Void.call(EMPTY_HASH) }
+      attribute? :rule, Rule.default { Void.call(EMPTY_HASH) }
 
       # @return [Array<String>]
       attribute? :backtrace, Types::Backtrace, default: EMPTY_ARRAY
@@ -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,14 @@ 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|
+    #     value = element.fetch(:value)
+    #     element.merge(value: value.upcase)
+    #   end
+    #
+    #   result.fetch(:value) # => :TWO
     class Index < Unit
       # @return [Integer]
       attribute :index, Integer
@@ -25,7 +31,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

@@ -7,13 +7,6 @@ module Remap
       using Extensions::Object
       using Extensions::Hash
 
-      refine Object do
-        # @see Extension::Paths::Hash
-        def paths
-          EMPTY_ARRAY
-        end
-      end
-
       refine Hash do
         # Returns a list of all key paths
         #
@@ -23,7 +16,7 @@ module Remap
         #       b: :c
         #     },
         #     d: :e
-        #   }.hur_paths # => [[:a, :b], [:d]]
+        #   }.paths # => [[:a, :b], [:d]]
         #
         # @return [Array<Array<Symbol>>] a list of key paths
         def paths
@@ -47,7 +40,7 @@ module Remap
         #       b: :c
         #     },
         #     d: :e
-        #   }.hur_only(:a, :b) # => { a: { b: :c } }
+        #   }.only(:a, :b) # => { a: { b: :c } }
         #
         # @returns [Hash] a hash containing the given path
         # @raise Europace::Error when path doesn't exist
@@ -117,11 +110,7 @@ module Remap
         def map(&block)
           bind do |value, state|
             Iteration.call(state: state, value: value).call do |other, **options|
-              state.set(other, **options).then do |inner_state|
-                block[inner_state] do |failure|
-                  throw :failure, failure
-                end
-              end
+              state.set(other, **options).then(&block)
             end.except(:index, :element, :key)
           end
         end
@@ -275,10 +264,6 @@ module Remap
             end
 
             set(result)._
-          rescue NoMethodError => e
-            e.name == :fetch ? error["Fetch not defined on value: #{e}"] : raise
-          rescue NameError => e
-            e.name == :Undefined ? error["Undefined returned, skipping!: #{e}"] : raise
           rescue KeyError, IndexError => e
             error[e.message]
           rescue PathError => e
@@ -351,7 +336,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 +344,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.11
+  version: 2.1.15
 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
@@ -307,6 +301,9 @@ homepage: https://github.com/oleander/remap
 licenses:
 - MIT
 metadata:
+  bug_tracker_uri: https://github.com/oleander/remap/issues
+  homepage_uri: https://github.com/oleander/remap
+  documentation_uri: http://oleander.io/remap/
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []

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