remap 2.0.2

data/lib/remap/mapper.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/remap/nothing.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Remap
+  class Nothing
+    # NOP
+  end
+end

data/lib/remap/operation.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Remap
+  module Operation
+    using State::Extension
+    include State
+
+    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)
+      end
+
+      if error
+        return error[new_state]
+      end
+
+      value = new_state.fetch(:value) do
+        return Failure.new(reasons: new_state.failure("No mapped data"), problems: new_state.problems)
+      end
+
+      Success.new(problems: new_state.problems, result: value)
+    end
+  end
+end

data/lib/remap/result.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Remap
+  class Result < Dry::Struct
+    attribute :problems, Types::Hash
+
+    def has_problem?
+      !problems.blank?
+    end
+  end
+end

data/lib/remap/rule/each.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Each < Value
+      using State::Extension
+
+      attribute :rule, Types.Interface(:call)
+
+      # Iterates over {state} and passes each value to {rule}
+      # Restores {path} before returning state
+      #
+      #
+      # # @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)
+        end
+      end
+    end
+  end
+end

data/lib/remap/rule/embed.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Embed < Value
+      using State::Extension
+
+      attribute :mapper, Types::Mapper
+
+      # Evaluates {input} against {mapper} and returns the result
+      #
+      # @param state [State]
+      #
+      # @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)
+        end
+      end
+    end
+  end
+end

data/lib/remap/rule/map.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Map < self
+      using State::Extension
+
+      attribute :rule, Types.Interface(:call)
+      attribute :path, Path
+
+      # Maps {input} in 4 steps
+      #
+      # 1. Extract value from {input} using {path}
+      # 2. For each yielded value
+      #   2.1. Map value using {#rule}
+      #   2.2. Map value using {#fn}
+
+      # @example Map :a, to :b and add 5
+      #  map = Map.new({
+      #    path: { map: :a, to: :b },
+      #    rule: Void.new,
+      #  })
+      #
+      #  map.adjust do |value|
+      #    value + 5
+      #  end
+      #
+      #  map.call(a: 10) # => Success({ b: 15 })
+      #
+      # @param input [Any] Value to be mapped
+      # @param state [State] Current state
+      #
+      # @return [Monad::Result]
+      def call(state)
+        path.call(state) do |inner_state|
+          rule.call(inner_state).then do |init|
+            fn.reduce(init) do |inner, fn|
+              fn[inner]
+            end
+          end
+        end
+      end
+
+      # Post-processor for {#call}
+      #
+      # @example Add 5 to mapped value
+      #  class Mapper < Remap
+      #    define do
+      #      map.adjust do |value|
+      #        value + 5
+      #      end
+      #    end
+      #  end
+      #
+      #  Mapper.call(10) # => 15
+      #
+      # @yieldparam value [Any] Mapped value
+      # @yieldreturn [Monad::Result, Any]
+      #
+      # @return [void]
+      def adjust(&block)
+        add do |state|
+          state.execute(&block)
+        end
+      end
+      alias then adjust
+
+      def pending(reason = "Pending mapping")
+        add do |state|
+          state.problem(reason)
+        end
+      end
+
+      def enum(&block)
+        add do |state|
+          state.fmap do |id, &error|
+            Enum.call(&block).get(id, &error)
+          end
+        end
+      end
+
+      def if(&block)
+        add do |state|
+          state.execute(&block).fmap do |bool, &error|
+            bool ? state.value : error["#if returned false"]
+          end
+        end
+      end
+
+      def if_not(&block)
+        add do |state|
+          state.execute(&block).fmap do |bool, &error|
+            bool ? error["#if_not returned true"] : state.value
+          end
+        end
+      end
+
+      private
+
+      def add(&block)
+        tap { fn << block }
+      end
+
+      def fn
+        @fn ||= []
+      end
+    end
+  end
+end

data/lib/remap/rule/set.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Set < self
+      using State::Extension
+
+      attribute :value, Types.Interface(:call)
+      attribute :path, Path
+
+      # Returns {value} mapped to {path} regardless of input
+      #
+      # @param state [State]
+      #
+      # @example Given an option
+      #   class Mapper < Remap::Base
+      #     option :name
+      #
+      #     define do
+      #       set [:person, :name], to: option(:name)
+      #     end
+      #   end
+      #
+      #   Mapper.call(input, name: "John") # => { person: { name: "John" } }
+      #
+      # @example Given a value
+      #   class Mapper < Remap::Base
+      #     define do
+      #       set [:api_key], to: value("ABC-123")
+      #     end
+      #   end
+      #
+      #   Mapper.call(input) # => { api_key: "ABC-123" }
+      #
+      # @return [State]
+      def call(state)
+        path.call(state) do
+          value.call(state)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Collection
+      class Filled < Unit
+        using State::Extension
+
+        attribute :rules, [Types.Interface(:call)], min_size: 1
+
+        # Represents a non-empty define block with one or more rules
+        # Calls every {#rules} with {input} and merges the output
+        #
+        # @param state [State]
+        #
+        # @return [State]
+        def call(state)
+          rules.map do |rule|
+            Thread.new(rule, state) { _1.call(_2) }
+          end.map(&:value).reduce do |acc, inner_state|
+            acc.merged(inner_state)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Collection < Dry::Interface
+      def to_proc
+        method(:call).to_proc
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Enum
+      include Dry::Core::Constants
+      include Dry::Monads[:maybe]
+
+      extend Dry::Initializer
+
+      option :mappings, default: -> { Hash.new { default } }
+      option :default, default: -> { None() }
+
+      alias execute instance_eval
+
+      def self.call(&block)
+        unless block
+          raise ArgumentError, "no block given"
+        end
+
+        new.tap { _1.execute(&block) }
+      end
+
+      def [](key)
+        mappings[key]
+      end
+
+      def get(key, &error)
+        unless error
+          return get(key) { raise Error, _1 }
+        end
+
+        mappings[key].bind { return _1 }.or do
+          error["Enum key [#{key}] not found among [#{mappings.keys.inspect}]"]
+        end
+      end
+      alias call get
+
+      # Map all keys in {keys} to {to}
+      #
+      # @return [VOID]
+      def from(*keys, to:)
+        keys.each do |key|
+          mappings[key] = Some(to)
+        end
+      end
+
+      # Maps {var} to {var}
+      #
+      # @return [VOID]
+      def value(id)
+        from(id, to: id)
+      end
+
+      # Fallback value when {#call} fails
+      #
+      # @return [Void]
+      def otherwise(value)
+        mappings.default = Some(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Path < Struct
+      using State::Extension
+
+      # @example [:a, :b, :c]
+      attribute :to, Types.Array(Types::Key)
+
+      # @example [:a, 0, :b, ALL]
+      attribute :map, Types.Array(Selector)
+
+      # Maps {state} from {map} to {block} to {to}
+      #
+      # @param state [State]
+      #
+      # @yieldparam [State]
+      # @yieldreturn [State<T>]
+      #
+      # @return [State<T>]
+      def call(state, &block)
+        unless block
+          raise ArgumentError, "block required"
+        end
+
+        selector(state).then(&block).fmap do |value|
+          to.reverse.reduce(value) do |val, key|
+            { key => val }
+          end
+        end._
+      end
+
+      private
+
+      def selector(state)
+        stack = map.reverse.reduce(IDENTITY) do |fn, selector|
+          ->(st) { selector.call(st, &fn) }
+        end
+
+        stack.call(state)
+      end
+    end
+  end
+end

data/lib/remap/rule/void.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule
+    class Void < self
+      using State::Extension
+
+      # Returns its input
+      #
+      # @param state [State]
+      #
+      # @example An empty rule
+      #   class Mapper < Remap::Base
+      #     define do
+      #       map do
+      #         # Empty ...
+      #       end
+      #     end
+      #   end
+      #
+      #   Mapper.call(input) # => input
+      #
+      # @return [State]
+      def call(state)
+        state.bind { _2.set(_1) }
+      end
+    end
+  end
+end

data/lib/remap/rule/wrap.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
+
+module Remap
+  class Rule
+    class Wrap < self
+      using State::Extension
+
+      attribute :type, Value(:array)
+      attribute :rule, Types::Any
+
+      # Wraps the output from {#rule} in a {#type}
+      #
+      # @param state [State]
+      #
+      # @example mapps { car: "Volvo" } to { cars: ["Volvo"] }
+      #   to :cars do
+      #     wrap(:array) do
+      #       map :car
+      #     end
+      #   end
+      #
+      # @return [State]
+      def call(state)
+        rule.call(state).fmap { Array.wrap(_1) }
+      end
+    end
+  end
+end

data/lib/remap/rule.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Remap
+  class Rule < Dry::Concrete
+    defines :requirement
+    requirement Types::Any
+  end
+end

data/lib/remap/selector/all.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Remap
+  class Selector
+    class All < Concrete
+      using State::Extension
+
+      requirement Types::Enumerable
+
+      def call(state, &block)
+        state.bind(quantifier: "*") do |enumerable, inner_state, &error|
+          requirement[enumerable] do
+            return error["Expected an enumeration"]
+          end
+
+          inner_state.map(&block)
+        end
+      end
+    end
+  end
+end

data/lib/remap/selector/index.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Remap
+  class Selector
+    class Index < Unit
+      using State::Extension
+
+      attribute :index, Integer
+
+      requirement Types::Array
+
+      # Fetches {#input[value]} and passes it to {block}
+      #
+      # @param [State] state
+      #
+      # @yieldparam [State]
+      # @yieldreturn [State<T>]
+
+      # @return [State<T>]
+      def call(state, &block)
+        unless block
+          raise ArgumentError, "no block given"
+        end
+
+        state.bind(index: index) do |array, inner_state, &error|
+          requirement[array] do
+            return error["Expected an array"]
+          end
+
+          element = array.fetch(index) do
+            return error["No element on index at index #{index}"]
+          end
+
+          block[inner_state.set(element, index: index)]
+        end
+      end
+    end
+  end
+end

data/lib/remap/selector/key.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Remap
+  class Selector
+    class Key < Unit
+      using State::Extension
+
+      attribute :key, Types::Hash.not
+      requirement Types::Hash.constrained(min_size: 1)
+
+      # Fetches {#input[value]} and passes it to {block}
+      #
+      # @param [State] state
+      #
+      # @yieldparam [State]
+      # @yieldreturn [State<T>]
+
+      # @return [State<T>]
+      def call(state, &block)
+        unless block
+          return call(state, &:itself)
+        end
+
+        state.bind(key: key) do |hash, inner_state, &error|
+          requirement[hash] do
+            return error["Expected a hash"]
+          end
+
+          value = hash.fetch(key) do
+            return error["Key [#{key}] not found"]
+          end
+
+          block[inner_state.set(value, key: key)]
+        end
+      end
+    end
+  end
+end

data/lib/remap/selector.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Remap
+  class Selector < Dry::Interface
+    defines :requirement, type: Types::Any.constrained(type: Dry::Types::Type)
+    requirement Types::Any
+
+    private
+
+    def requirement
+      self.class.requirement
+    end
+  end
+end