remap 2.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e5df1ff079e3e2d14f9f35541efed74d87bbebe54deb39e8571998a2bdb11850
+  data.tar.gz: ad295f5b2967f8bff292a662fc2cb7db222c724567edd52657f7e88b83560f33
+SHA512:
+  metadata.gz: 57b267a4b302721f874ca93ffbf924ec3b1a90ee8d33d7728091bc9bb2f0a4e14b84ca60f037319030f4c9a4e0945d25217a70e772edac161f49f8f5a66797fd
+  data.tar.gz: 4e664e07f2edb8865836265d5e36484887b1b206410e45f92d73ed4cfdbd5c0b8201cae1156478ac8503163fe0c65b16a36776138797d7b5682c295c626cb0fb

data/lib/remap/base.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "dry/monads/all"
+
+module Remap
+  class Base < Mapper
+    include Dry::Core::Memoizable
+    include Dry::Core::Constants
+    extend Dry::Monads[:result]
+
+    extend Dry::Configurable
+    extend Forwardable
+
+    using State::Extension
+    extend State
+
+    CONTRACT = Dry::Schema.JSON do
+      # NOP
+    end
+
+    setting :constructor, default: IDENTITY
+    setting :options, default: EMPTY_ARRAY
+    setting :rules, default: EMPTY_ARRAY
+    setting :contract, default: CONTRACT
+    setting :context, default: IDENTITY
+
+    delegate [:config] => self
+
+    schema schema.strict(false)
+
+    # Holds the current context
+    # @private
+    def self.contract(&context)
+      config.contract = Dry::Schema.JSON(&context)
+    end
+
+    # @see Dry::Validation::Contract.rule
+    def self.rule(...)
+      config.rules << ->(*) { rule(...) }
+    end
+
+    # Defines a a constructor argument for the mapper
+    #
+    # @param name [Symbol]
+    # @param type [#call]
+    def self.option(field, type: Types::Any)
+      attribute(field, type)
+
+      unless (key = schema.keys.find { _1.name == field })
+        raise ArgumentError, "Could not locate [#{field}] in [#{self}]"
+      end
+
+      config.options << ->(*) { option(field, type: key) }
+    end
+
+    # Pretty print the mapper
+    #
+    # @return [String]
+    def self.inspect
+      "<#{self.class} #{rule}, #{self}>"
+    end
+
+    # Defines a mapper with a constructor used to wrap the output
+    #
+    # @param constructor [#call]
+    #
+    # @example A mapper from path :a to path :b
+    #   class Mapper < Remap
+    #     define do
+    #       map :a, to: :b
+    #     end
+    #   end
+    #
+    #   Mapper.call(a: 1) # => { b: 1 }
+    def self.define(target = Nothing, method: :new, strategy: :argument, &context)
+      unless context
+        raise ArgumentError, "Missing block"
+      end
+
+      config.context = Compiler.call(&context)
+      config.constructor = Constructor.call(method: method, strategy: strategy, target: target)
+    rescue Dry::Struct::Error => e
+      raise ArgumentError, e.message
+    end
+
+    # Creates a new mapper
+    #
+    # @param input [Any]
+    # @param params [Hash]
+
+    # @return [Context]
+
+    extend Operation
+
+    def self.call!(state, &error)
+      new(state.options).call(state._.set(mapper: self), &error)
+    rescue Dry::Struct::Error => e
+      raise ArgumentError, "Option missing to mapper [#{self}]: #{e}"
+    end
+
+    # Creates a mapper tree using {#context} and uses {#state} as argument
+    #
+    # @return [State]
+    #
+    # @see .call!
+    #
+    # @private
+    def call(state, &error)
+      unless error
+        raise ArgumentError, "Missing block"
+      end
+
+      state.tap do |input|
+        contract.call(input, state.options).tap do |result|
+          unless result.success?
+            return error[state.failure(result.errors.to_h)]
+          end
+        end
+      end
+
+      state.then(&config.context).then(&config.constructor)
+    end
+
+    private
+
+    def contract(scope: self)
+      Class.new(Dry::Validation::Contract) do |klass|
+        config = scope.class.config
+
+        config.rules.each do |rule|
+          klass.class_eval(&rule)
+        end
+
+        config.options.each do |option|
+          klass.class_eval(&option)
+        end
+
+        schema(config.contract)
+      end.new(**attributes)
+    end
+
+    def config
+      self.class.config
+    end
+  end
+end

data/lib/remap/compiler.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Remap
+  class Compiler
+    include Dry::Core::Constants
+    extend Dry::Initializer
+    extend Forwardable
+
+    param :rules, default: -> { EMPTY_ARRAY.dup }
+
+    # @return [Rule]
+    delegate call: self
+
+    # Constructs a rule tree given {block}
+    #
+    # @return [Rule]
+    def self.call(&block)
+      unless block
+        return Rule::Void.new
+      end
+
+      new.tap { _1.instance_eval(&block) }.rule
+    end
+
+    # Maps {path} to {to} with {block} inbetween
+    #
+    # @param path ([]) [Array<Segment>, Segment]
+    # @param to ([]) [Array<Symbol>, Symbol]
+    #
+    # @return [Rule::Map]
+    def map(*path, to: EMPTY_ARRAY, &block)
+      add Rule::Map.new(
+        path: {
+          map: path.flatten,
+          to: [to].flatten
+        },
+        rule: call(&block)
+      )
+    end
+
+    # Maps using {mapper}
+    #
+    # @param mapper [Remap]
+    #
+    # @return [Rule::Embed]
+    def embed(mapper)
+      add Rule::Embed.new(mapper: mapper)
+    rescue Dry::Struct::Error
+      raise ArgumentError, "Embeded mapper must be [Remap::Mapper], got [#{mapper}]"
+    end
+
+    # @param *path ([]) [Symbol, Array<Symbol>]
+    # @option to [Remap::Static]
+    #
+    # @return [Rule::Set]
+    # @raise [ArgumentError]
+    #   if no path given
+    #   if path is not a Symbol or Array<Symbol>
+    def set(*path, to:)
+      add Rule::Set.new(path: { to: path.flatten, map: EMPTY_ARRAY }, value: to)
+    rescue Dry::Struct::Error => e
+      raise ArgumentError, e.message
+    end
+
+    # Maps to {path} from {map} with {block} inbetween
+    #
+    # @param path [Array<Symbol>, Symbol]
+    # @param map [Array<Segment>, Segment]
+    #
+    # @return [Rule::Map]
+    def to(*path, map: EMPTY_ARRAY, &block)
+      map(*map, to: path, &block)
+    end
+
+    # Iterates over the input value, passes each value
+    # to its block and merges the result back together
+    #
+    # @return [Rule::Each]]
+    # @raise [ArgumentError] if no block given
+    def each(&block)
+      unless block
+        raise ArgumentError, "no block given"
+      end
+
+      add Rule::Each.new(rule: call(&block))
+    end
+
+    # Wraps output in {type}
+    #
+    # @param type [:array]
+    #
+    # @yieldreturn [Rule]
+    #
+    # @return [Rule::Wrap]
+    # @raise [ArgumentError] if type is not :array
+    def wrap(type, &block)
+      unless block
+        raise ArgumentError, "no block given"
+      end
+
+      add Rule::Wrap.new(type: type, rule: call(&block))
+    rescue Dry::Struct::Error => e
+      raise ArgumentError, e.message
+    end
+
+    # Selects all elements
+    #
+    # @return [Rule::Path::Segment::Quantifier::All]
+    def all
+      Selector::All.new(EMPTY_HASH)
+    end
+
+    # Static value to be selected
+    #
+    # @param value [Any]
+    #
+    # @return [Rule::Static::Fixed]
+    def value(value)
+      Static::Fixed.new(value: value)
+    end
+
+    # Static option to be selected
+    #
+    # @param id [Symbol]
+    #
+    # @return [Rule::Static::Option]
+    def option(id)
+      Static::Option.new(name: id)
+    end
+
+    # Selects {index} element in input
+    #
+    # @param index [Integer]
+    #
+    # @return [Path::Segment::Key]
+    # @raise [ArgumentError] if index is not an Integer
+    def at(index)
+      Selector::Index.new(index: index)
+    rescue Dry::Struct::Error
+      raise ArgumentError, "Selector at(index) requires an integer argument, got [#{index}] (#{index.class})"
+    end
+
+    # Selects first element in input
+    #
+    # @return [Path::Segment::Key]]
+    def first
+      at(0)
+    end
+    alias any first
+
+    # Selects last element in input
+    #
+    # @return [Path::Segment::Key]
+    def last
+      at(-1)
+    end
+
+    # The final rule
+    #
+    # @return [Rule]
+    def rule
+      Rule::Collection.call(rules: rules)
+    end
+
+    private
+
+    def add(rule)
+      rule.tap { rules << rule }
+    end
+  end
+end

data/lib/remap/constructor/argument.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Remap
+  class Constructor
+    class Argument < Concrete
+      using State::Extension
+
+      attribute :strategy, Value(:argument), default: :argument
+
+      # Uses the {#method} method to initialize {#target} with {state}
+      # Target is only called if {state} is defined
+      #
+      # Fails if {#target} does not respond to {#method}
+      # Fails if {#target} cannot be called with {state}
+      #
+      # @param state [State]
+      #
+      # @return [State]
+      def call(state)
+        super.fmap do |input|
+          target.public_send(id, input)
+        rescue ArgumentError => e
+          raise e.exception("Could not load target [#{target}] using the argument strategy with [#{input}] (#{input.class})")
+        end
+      end
+    end
+  end
+end

data/lib/remap/constructor/keyword.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Remap
+  class Constructor
+    class Keyword < Concrete
+      using State::Extension
+
+      attribute :strategy, Value(:keyword)
+
+      # Calls {#target} as with keyword arguments
+      #
+      # Fails if {#target} does not respond to {#method}
+      # Fails if {#target} cannot be called with {state}
+      #
+      # @param state [State]
+      #
+      # @return [State]
+      def call(state)
+        super.fmap do |input, &error|
+          unless input.is_a?(Hash)
+            return error["Input is not a hash"]
+          end
+
+          target.public_send(id, **input)
+        rescue ArgumentError => e
+          raise e.exception("Could not load target [#{target}] using the keyword strategy using [#{input}] (#{input.class})")
+        end
+      end
+    end
+  end
+end

data/lib/remap/constructor/none.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Remap
+  class Constructor
+    class None < Concrete
+      attribute :target, Types::Nothing
+      attribute :strategy, Types::Any
+      attribute :method, Types::Any
+
+      # Just returns the input state
+      #
+      # Fails if {#target} does not respond to {#method}
+      # Fails if {#target} cannot be called with {state}
+      #
+      # @param state [State]
+      #
+      # @return [State]
+      def call(state)
+        state
+      end
+    end
+  end
+end

data/lib/remap/constructor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Remap
+  class Constructor < Dry::Interface
+    attribute :method, Symbol, default: :new
+    attribute :target, Types::Any.constrained(not_eql: Nothing)
+
+    # Ensures {#target} responds to {#method}
+    # Returns an error state unless above is true
+    #
+    # @param state [State]
+    #
+    # @return [State]
+    def call(state)
+      state.tap do
+        unless target.respond_to?(id)
+          raise ArgumentError, "Target [#{target}] does not respond to [#{id}]"
+        end
+      end
+    end
+
+    def id
+      attributes.fetch(:method)
+    end
+
+    def to_proc
+      method(:call).to_proc
+    end
+  end
+end

data/lib/remap/error.rb

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

data/lib/remap/failure.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Remap
+  class Failure < Result
+    attribute :reasons, Types::Hash
+
+    def inspect
+      format("Failure<[%<result>s]>", result: JSON.pretty_generate(to_h))
+    end
+
+    def to_hash
+      { failure: reasons, problems: problems }
+    end
+
+    def failure?(*)
+      true
+    end
+
+    def success?(*)
+      false
+    end
+
+    def fmap
+      self
+    end
+  end
+end

data/lib/remap/iteration/array.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Remap
+  class Iteration
+    class Array < Concrete
+      using State::Extension
+
+      attribute :value, Types::Array
+      attribute :state, Types::State
+
+      def map(&block)
+        value.each_with_index.reduce(init) do |input_state, (value, index)|
+          block[value, index: index]._.then do |new_state|
+            new_state.fmap { [_1] }
+          end.then do |new_array_state|
+            input_state.merged(new_array_state)
+          end
+        end._
+      end
+      alias call map
+
+      private
+
+      def init
+        state.set(EMPTY_ARRAY)
+      end
+    end
+  end
+end

data/lib/remap/iteration/hash.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Remap
+  class Iteration
+    class Hash < Concrete
+      attribute :value, Types::Hash
+      attribute :state, Types::State
+
+      using State::Extension
+
+      # @see Base#map
+      def map(&block)
+        value.reduce(init) do |input_state, (key, value)|
+          block[value, key: key]._.then do |new_state|
+            new_state.fmap { { key => _1 } }
+          end.then do |new_hash_state|
+            input_state.merged(new_hash_state)
+          end
+        end._
+      end
+      alias call map
+
+      private
+
+      def init
+        state.set(EMPTY_HASH)
+      end
+    end
+  end
+end

data/lib/remap/iteration/other.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Remap
+  class Iteration
+    class Other < Concrete
+      attribute :state, Types::State
+      attribute :value, Types::Any
+
+      using State::Extension
+
+      # @see Base#map
+      def map(&block)
+        block[value]._
+      end
+      alias call map
+    end
+  end
+end

data/lib/remap/iteration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Remap
+  class Iteration < Dry::Interface
+    attribute :value, Types::Value
+    attribute :state, Types::State
+
+    # Maps every element in {#value} to {#block}
+    #
+    # @abstract
+    #
+    # @yieldparam element [V]
+    # @yieldparam key [K, Integer]
+    # @yieldreturn [Array<V>, Hash<V, K>]
+    #
+    # @return [Array<V>, Hash<V, K>]
+
+    order :Hash, :Array, :Other
+  end
+end

data/lib/remap/mapper/and.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Remap
+  class Mapper
+    class And < Binary
+      using State::Extension
+
+      def call!(state, &error)
+        unless error
+          return call!(state, &exception)
+        end
+
+        state1 = left.call!(state) do |failure1|
+          right.call!(state) do |failure2|
+            return error[failure1.merge(failure2)]
+          end
+
+          return error[failure1]
+        end
+
+        state2 = right.call!(state) do |failure|
+          return error[failure]
+        end
+
+        state1.merged(state2)
+      end
+    end
+  end
+end

data/lib/remap/mapper/binary.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Remap
+  class Mapper
+    class Binary < self
+      attribute :left, Types::Mapper
+      attribute :right, Types::Mapper
+
+      def exception
+        ->(error) { raise error }
+      end
+
+      include Operation
+    end
+  end
+end

data/lib/remap/mapper/or.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Remap
+  class Mapper
+    class Or < Binary
+      using State::Extension
+
+      def call!(state, &error)
+        unless error
+          return call!(state, &exception)
+        end
+
+        left.call!(state) do |failure1|
+          return right.call!(state) do |failure2|
+            return error[failure1.merge(failure2)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/remap/mapper/xor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Remap
+  class Mapper
+    class Xor < Binary
+      using State::Extension
+
+      def call!(state, &error)
+        unless error
+          return call!(state, &exception)
+        end
+
+        state1 = left.call!(state) do |failure1|
+          return right.call!(state) do |failure2|
+            return error[failure1.merge(failure2)]
+          end
+        end
+
+        state2 = right.call!(state) do
+          return state1
+        end
+
+        error[state1.merged(state2).failure("Both left and right passed in xor")]
+      end
+    end
+  end
+end