remap 2.0.3 → 2.1.0

data/lib/remap/mapper.rb

@@ -3,54 +3,7 @@
 module Remap
   # @abstract
   class Mapper < Struct
-    # Tries {self} and {other} and returns the first successful result
-    #
-    # @param other [Mapper]
-    #
-    # @return [Mapper::Or]
-    module Operations
-      def |(other)
-        Or.new(left: self, right: other)
-      rescue Dry::Struct::Error => e
-        raise ArgumentError, e.message
-      end
-
-      # Returns a successful result when {self} & {other} are successful
-      #
-      # @param other [Mapper]
-      #
-      # @return [Mapper::And]
-      def &(other)
-        And.new(left: self, right: other)
-      rescue Dry::Struct::Error => e
-        raise ArgumentError, e.message
-      end
-
-      # Returns a successful result when only one of {self} & {other} are successful
-      #
-      # @param other [Mapper]
-      #
-      # @return [Mapper:Xor]
-      def ^(other)
-        Xor.new(left: self, right: other)
-      rescue Dry::Struct::Error => e
-        raise ArgumentError, e.message
-      end
-    end
-
-    include Operations
     extend Operations
-
-    # Creates a new mapper using {state}
-    #
-    # @param state [State]
-    #
-    # @yield [State]
-    #   If the call fails, the block is invoked with the state
-    # @yieldreturn [State]
-    #
-    # @return [State]
-    #
-    # @private
+    include Operations
   end
 end

data/lib/remap/notice/traced.rb

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

data/lib/remap/notice/untraced.rb

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

data/lib/remap/notice.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Remap
+  using Extensions::Hash
+
+  class Notice < Dry::Interface
+    attribute? :value, Types::Any
+    attribute :reason, String
+    attribute :path, Array
+
+    class Error < Remap::Error
+      extend Dry::Initializer
+
+      param :notice, type: Notice
+    end
+
+    def inspect
+      "#<%s %s>" % [self.class, to_hash.formated]
+    end
+    alias to_s inspect
+
+    # Hash representation of the notice
+    #
+    # @return [Hash]
+    def to_hash
+      super.except(:backtrace).compact_blank
+    end
+
+    # @return [Error]
+    def exception
+      Error.new(self)
+    end
+  end
+end

data/lib/remap/operation.rb

@@ -1,26 +1,39 @@
 # frozen_string_literal: true
 
 module Remap
-  module Operation
-    using State::Extension
-    include State
+  using State::Extension
 
+  # Class interface for {Remap::Base} and instance interface for {Mapper}
+  module Operation
+    # Public interface for mappers
+    #
+    # @param input [Any] Data to be mapped
+    # @param options [Hash] Mapper arguments
+    #
+    # @yield [Failure] if mapper fails
+    #
+    # @return [Success] if mapper succeeds
     def call(input, **options, &error)
-      new_state = state(input, options: options, mapper: self)
-
-      new_state = call!(new_state) do |failure|
-        return Failure.new(reasons: failure, problems: new_state.problems)
+      unless error
+        return call(input, **options) do |failure|
+          raise failure.exception
+        end
       end
 
-      if error
-        return error[new_state]
+      other = State.call(input, options: options, mapper: self).then do |state|
+        call!(state) do |failure|
+          return error[failure]
+        end
       end
 
-      value = new_state.fetch(:value) do
-        return Failure.new(reasons: new_state.failure("No mapped data"), problems: new_state.problems)
+      case other
+      in { value: }
+        value
+      in { notices: [] }
+        error[other.failure("No return value")]
+      in { notices: }
+        error[Failure.call(failures: notices)]
       end
-
-      Success.new(problems: new_state.problems, result: value)
     end
   end
 end

data/lib/remap/path/input.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Remap
+  class Path
+    using State::Extension
+
+    # Returns the value at a given path
+    #
+    # @example Select "A" from { a: { b: { c: ["A"] } } }
+    #   state = Remap::State.call({ a: { b: { c: ["A"] } } })
+    #   first = Remap::Selector::Index.new(index: 0)
+    #   path = Remap::Path::Input.new([:a, :b, :c, first])
+    #
+    #   path.call(state) do |state|
+    #     state.fetch(:value)
+    #   end
+    class Input < Unit
+      # @return [Array<Selector>]
+      attribute :segments, [Selector]
+
+      # Selects the value at the path {#segments}
+      #
+      # @param state [State]
+      #
+      # @return [State]
+      def call(state, &iterator)
+        unless block_given?
+          raise ArgumentError, "Input path requires an iterator block"
+        end
+
+        segments.reverse.reduce(iterator) do |inner_iterator, selector|
+          -> inner_state { selector.call(inner_state, &inner_iterator) }
+        end.call(state)
+      end
+    end
+  end
+end

data/lib/remap/path/output.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Remap
+  class Path
+    using Extensions::Enumerable
+    using State::Extension
+
+    # Sets the value to a given path
+    #
+    # @example Maps "A" to { a: { b: { c: "A" } } }
+    #   state = Remap::State.call("A")
+    #   result = Remap::Path::Output.new([:a, :b, :c]).call(state)
+    #
+    #   result.fetch(:value) # => { a: { b: { c: "A" } } }
+    class Output < Unit
+      attribute :segments, [Types::Key]
+
+      # @return [State]
+      def call(state)
+        state.fmap do |value|
+          segments.hide(value)
+        end
+      end
+    end
+  end
+end

data/lib/remap/path.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Remap
+  # Represents a sequence of keys and selects or maps a value given a path
+  class Path < Dry::Interface
+    attribute :segments, Types::Array
+
+    delegate :>>, to: :to_proc
+
+    # @return [State]
+    #
+    # @abstract
+    def call(state)
+      raise NotImplementedError, "#{self.class}#call not implemented"
+    end
+
+    # @return [Proc]
+    def to_proc
+      method(:call).to_proc
+    end
+  end
+end

data/lib/remap/path_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Remap
+  class PathError < Error
+    # @return [Array<Key>]
+    attr_reader :path
+
+    def initialize(path)
+      super(path.join("."))
+      @path = path
+    end
+  end
+end

data/lib/remap/proxy.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Remap
+  class Proxy < ActiveSupport::ProxyObject
+    def self.const_missing(name)
+      ::Object.const_get(name)
+    end
+
+    include Dry::Core::Constants
+    extend Dry::Initializer
+
+    # See Object#tap
+    def tap(&block)
+      block[self]
+      self
+    end
+  end
+end

data/lib/remap/rule/each.rb

@@ -2,34 +2,35 @@
 
 module Remap
   class Rule
-    class Each < Value
-      using State::Extension
+    using State::Extension
 
-      attribute :rule, Types.Interface(:call)
+    # 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 {path} before returning state
+      # Iterates over state and passes each value to rule
+      # Restores element, key & index before returning state
       #
+      # @param state [State<Enumerable>]
       #
-      # # @example
-      #   class Mapper < Remap::Base
-      #     define do
-      #       map :people, to: :names do
-      #         each do
-      #           map(:name)
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      #   Mapper.call(people: [{ name: "John" }, { name: "Jane" }]) # => { names: ["John", "Jane"] }
-      #
-      # @param state [State]
-      #
-      # @return [State]
-      def call(state)
-        state.map do |state|
-          rule.call(state)
+      # @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

data/lib/remap/rule/embed.rb

@@ -2,40 +2,45 @@
 
 module Remap
   class Rule
-    class Embed < Value
-      using State::Extension
+    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
+      # Evaluates input against mapper and returns the result
       #
-      # @param state [State]
+      # @param state [State<T>]
       #
-      # @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: { name: "Volvo" } } }
-      #
-      #
-      # @return [State]
-      def call(state)
-        mapper.call!(state.set(mapper: mapper)) do |error|
-          return state.problem(error)
+      # @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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Map
+      using State::Extension
+
+      class Optional < Concrete
+        # Represents an optional mapping rule
+        # When the mapping fails, the value is ignored
+        #
+        # @param state [State]
+        #
+        # @return [State]
+        def call(state, &error)
+          unless error
+            raise ArgumentError, "map.call(state, &error) requires a block"
+          end
+
+          fatal(state) do
+            return ignore(state) do
+              return notice(state) do
+                return super
+              end
+            end
+          end
+        end
+
+        private
+
+        # Catches :ignore exceptions and re-package them as a state
+        #
+        # @param state [State]
+        #
+        # @return [State]
+        def ignore(state, &block)
+          state.set(notice: catch(:ignore, &block).traced(backtrace)).except(:value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Map
+      using State::Extension
+
+      class Required < Concrete
+        attribute :backtrace, Types::Backtrace
+
+        # Represents a required mapping rule
+        # When it fails, the entire mapping is marked as failed
+        #
+        # @param state [State]
+        #
+        # @return [State]
+        def call(state, &error)
+          unless block_given?
+            raise ArgumentError, "Required.call(state, &error) requires a block"
+          end
+
+          notice = catch :ignore do
+            return fatal(state) do
+              return notice(state) do
+                return super
+              end
+            end
+          end
+
+          error[state.failure(notice)]
+        end
+      end
+    end
+  end
+end