morpher 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0eec4915e34accded2656d830113f0ae9af9ffb77d5aa09b76886886464eb02
+  data.tar.gz: cd0255f306246e12d521b749c1015b0c3f569df1be1ecd633aa5862524dfbcbc
+SHA512:
+  metadata.gz: 79dcc3f54caaa111991c5e2423319ed7a3f80a46c36fdb56331b0d26169c5050bb288b9ce315c9a5dcc9fcc364f6fe65509ac55c46a6cda596aee35301c43d8a
+  data.tar.gz: 2c2b9d6c716ff971baebc94825d13e20ed986d35413e40fa817e67f33a38fe86fca894e20d30d16ff5f238f81bac306bb1572ead8d3e325e7905e1590ffb6fe3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2021 Markus Schirp
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/morpher.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'abstract_type'
+require 'adamantium'
+require 'anima'
+require 'concord'
+require 'mprelude'
+
+module Morpher
+  Either = MPrelude::Either
+end
+
+require 'morpher/newtype'
+require 'morpher/record'
+require 'morpher/transform'

data/lib/morpher/newtype.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Morpher
+  # Generator for primitive wrappers
+  class Newtype < Module
+    include Concord.new(:transform)
+
+    # rubocop:disable Metrics/MethodLength
+    def included(host)
+      transform = transform()
+
+      host.class_eval do
+        include Adamantium::Flat, Concord::Public.new(:value)
+
+        const_set(
+          :TRANSFORM,
+          Transform::Sequence.new(
+            [
+              transform,
+              Transform::Success.new(public_method(:new))
+            ]
+          )
+        )
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/morpher/record.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Morpher
+  # Generator for struct a-like wrappers
+  class Record < Module
+    include Concord.new(:attributes)
+
+    # rubocop:disable Metrics/MethodLength
+    def included(host)
+      attributes     = attributes()
+      keys_transform = keys_transform()
+
+      host.class_eval do
+        include Adamantium::Flat, Anima.new(*attributes.keys)
+
+        const_set(
+          :TRANSFORM,
+          Transform::Sequence.new(
+            [
+              Transform::Primitive.new(Hash),
+              Transform::Hash::Symbolize.new,
+              Transform::Hash.new(required: keys_transform, optional: []),
+              Transform::Success.new(public_method(:new))
+            ]
+          )
+        )
+      end
+    end
+  # rubocop:enable Metrics/MethodLength
+
+  private
+
+    def keys_transform
+      attributes.map do |name, transform|
+        Transform::Hash::Key.new(name, transform)
+      end
+    end
+  end # Record
+end # Morpher

data/lib/morpher/transform.rb

@@ -0,0 +1,471 @@
+# frozen_string_literal: true
+
+module Morpher
+  # Composable transform declaration and execution
+  class Transform
+    include AbstractType
+    include Adamantium
+
+    # Default slug
+    #
+    # @return [String]
+    def slug
+      self.class.to_s
+    end
+
+    # Apply transformation to input
+    #
+    # @param [Object] input
+    #
+    # @return [Either<Error, Object>]
+    abstract_method :call
+
+    # Deep error data structure
+    class Error
+      include Anima.new(
+        :cause,
+        :input,
+        :message,
+        :transform
+      )
+      include Adamantium
+
+      COMPACT = '%<path>s: %<message>s'
+
+      private_constant(*constants(false))
+
+      # Compact error message
+      #
+      # @return [String]
+      def compact_message
+        COMPACT % { path: path, message: trace.last.message }
+      end
+      memoize :compact_message
+
+      # Error path trace
+      #
+      # @return [Array<Error>]
+      def trace
+        [self, *cause&.trace]
+      end
+      memoize :trace
+
+    private
+
+      def path
+        trace.map { |error| error.transform.slug }.reject(&:empty?).join('/')
+      end
+    end # Error
+
+    # Wrapper adding a name to a transformation
+    class Named < self
+      include Concord.new(:name, :transformer)
+
+      # Apply transformation to input
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        transformer.call(input).lmap(&method(:wrap_error))
+      end
+
+      # Named slug
+      #
+      # @return [String]
+      def slug
+        name
+      end
+    end # Named
+
+    # Transform based on a (captured) block with added name
+    class Block < self
+      include Anima.new(:block, :name)
+
+      def self.capture(name, &block)
+        new(block: block, name: name)
+      end
+
+      def call(input)
+        block
+          .call(input)
+          .lmap do |message|
+            Error.new(
+              cause:     nil,
+              input:     input,
+              message:   message,
+              transform: self
+            )
+          end
+      end
+
+      def slug
+        name
+      end
+    end
+
+  private
+
+    def error(input:, cause: nil, message: nil)
+      Error.new(
+        cause:     cause,
+        input:     input,
+        message:   message,
+        transform: self
+      )
+    end
+
+    def lift_error(error)
+      error.with(transform: self)
+    end
+
+    def wrap_error(error)
+      error(cause: error, input: error.input)
+    end
+
+    def failure(value)
+      Either::Left.new(value)
+    end
+
+    def success(value)
+      Either::Right.new(value)
+    end
+
+    # Index attached to a transform
+    class Index < self
+      include Anima.new(:index, :transform)
+
+      private(*anima.attribute_names) # rubocop:disable Style/AccessModifierDeclarations
+
+      # Create error at specified index
+      #
+      # @param [Error] cause
+      # @param [Integer] index
+      #
+      # @return [Error]
+      def self.wrap(cause, index)
+        Error.new(
+          cause:     cause,
+          input:     cause.input,
+          message:   nil,
+          transform: new(index: index, transform: cause.transform)
+        )
+      end
+
+      # Apply transformation to input
+      #
+      # @param [Object] input
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        transform.call(input).lmap(&method(:wrap_error))
+      end
+
+      # Rendering slug
+      #
+      # @return [Array<String>]
+      def slug
+        '%<index>d' % { index: index }
+      end
+      memoize :slug
+    end # Index
+
+    # Transform guarding a specific primitive
+    class Primitive < self
+      include Concord.new(:primitive)
+
+      MESSAGE = 'Expected: %<expected>s but got: %<actual>s'
+
+      private_constant(*constants(false))
+
+      # Apply transformation to input
+      #
+      # @param [Object] input
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        if input.instance_of?(primitive)
+          success(input)
+        else
+          failure(
+            error(
+              input:   input,
+              message: MESSAGE % { actual: input.class, expected: primitive }
+            )
+          )
+        end
+      end
+
+      # Rendering slug
+      #
+      # @return [String]
+      def slug
+        primitive.to_s
+      end
+      memoize :slug
+    end # Primitive
+
+    # Transform guarding boolean primitives
+    class Boolean < self
+      include Concord.new
+
+      MESSAGE = 'Expected: boolean but got: %<actual>s'
+
+      private_constant(*constants(false))
+
+      # Apply transformation to input
+      #
+      # @param [Object] input
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        if input.equal?(true) || input.equal?(false)
+          success(input)
+        else
+          failure(
+            error(
+              message: MESSAGE % { actual: input.inspect },
+              input:   input
+            )
+          )
+        end
+      end
+    end # Boolean
+
+    # Transform an array via mapping it over transform
+    class Array < self
+      include Concord.new(:transform)
+
+      MESSAGE   = 'Failed to coerce array at index: %<index>d'
+      PRIMITIVE = Primitive.new(::Array)
+
+      private_constant(*constants(false))
+
+      # Apply transformation to input
+      #
+      # @param [Object] input
+      #
+      # @return [Either<Error, Array<Object>>]
+      def call(input)
+        PRIMITIVE
+          .call(input)
+          .lmap(&method(:lift_error))
+          .bind(&method(:run))
+      end
+
+    private
+
+      # rubocop:disable Metrics/MethodLength
+      def run(input)
+        output = []
+
+        input.each_with_index do |value, index|
+          output << transform.call(value).lmap do |error|
+            return failure(
+              error(
+                cause:   Index.wrap(error, index),
+                message: MESSAGE % { index: index },
+                input:   input
+              )
+            )
+          end.from_right
+        end
+
+        success(output)
+      end
+      # rubocop:enable Metrics/MethodLength
+    end # Array
+
+    # Transform a hash via mapping it over key specific transforms
+    class Hash < self
+      include Anima.new(:optional, :required)
+
+      KEY_MESSAGE = 'Missing keys: %<missing>s, Unexpected keys: %<unexpected>s'
+      PRIMITIVE   = Primitive.new(::Hash)
+
+      private_constant(*constants(false))
+
+      # Transform to symbolize array keys
+      class Symbolize < Transform
+        include Equalizer.new
+
+        # Apply transformation to input
+        #
+        # @param [Hash{String => Object}]
+        #
+        # @return [Hash{Symbol => Object}]
+        def call(input)
+          unless input.keys.all? { |key| key.instance_of?(String) }
+            return failure(error(input: input, message: 'Found non string key in input'))
+          end
+
+          success(input.transform_keys(&:to_sym))
+        end
+      end # Symbolize
+
+      # Key specific transformation
+      class Key < Transform
+        include Concord::Public.new(:value, :transform)
+
+        # Rendering slug
+        #
+        # @return [String]
+        def slug
+          '[%<key>s]' % { key: value.inspect }
+        end
+        memoize :slug
+
+        # Apply transformation to input
+        #
+        # @param [Object]
+        #
+        # @return [Either<Error, Object>]
+        def call(input)
+          transform.call(input).lmap do |error|
+            error(cause: error, input: input)
+          end
+        end
+      end # Key
+
+      # Apply transformation to input
+      #
+      # @param [Object] input
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        PRIMITIVE
+          .call(input)
+          .lmap(&method(:lift_error))
+          .bind(&method(:reject_keys))
+          .bind(&method(:transform))
+      end
+
+    private
+
+      def transform(input)
+        transform_required(input).bind do |required|
+          transform_optional(input).fmap(&required.public_method(:merge))
+        end
+      end
+
+      def transform_required(input)
+        transform_keys(required, input)
+      end
+
+      def transform_optional(input)
+        transform_keys(
+          optional.select { |key| input.key?(key.value) },
+          input
+        )
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def transform_keys(keys, input)
+        success(
+          keys
+            .map do |key|
+              [
+                key.value,
+                coerce_key(key, input).from_right do |error|
+                  return failure(error)
+                end
+              ]
+            end
+            .to_h
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def coerce_key(key, input)
+        key.call(input.fetch(key.value)).lmap do |error|
+          error(input: input, cause: error)
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def reject_keys(input)
+        keys       = input.keys
+        unexpected = keys - allowed_keys
+        missing    = required_keys - keys
+
+        if unexpected.empty? && missing.empty?
+          success(input)
+        else
+          failure(
+            error(
+              input:   input,
+              message: KEY_MESSAGE % { missing: missing, unexpected: unexpected }
+            )
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def allowed_keys
+        required_keys + optional.map(&:value)
+      end
+      memoize :allowed_keys
+
+      def required_keys
+        required.map(&:value)
+      end
+      memoize :required_keys
+    end # Hash
+
+    # Sequence of transformations
+    class Sequence < self
+      include Concord.new(:steps)
+
+      # Apply transformation to input
+      #
+      # @param [Object]
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        current = input
+
+        steps.each_with_index do |step, index|
+          current = step.call(current).from_right do |error|
+            return failure(error(cause: Index.wrap(error, index), input: input))
+          end
+        end
+
+        success(current)
+      end
+    end # Sequence
+
+    # Generic exception transformer
+    class Exception < self
+      include Concord.new(:error_class, :block)
+
+      # Apply transformation to input
+      #
+      # @param [Object]
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        Either
+          .wrap_error(error_class) { block.call(input) }
+          .lmap { |exception| error(input: input, message: exception.to_s) }
+      end
+    end # Exception
+
+    # Transform sucessfully
+    class Success < self
+      include Concord.new(:block)
+
+      # Apply transformation to input
+      #
+      # @param [Object]
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        success(block.call(input))
+      end
+    end # Success
+
+    BOOLEAN      = Transform::Boolean.new
+    FLOAT        = Transform::Primitive.new(Float)
+    INTEGER      = Transform::Primitive.new(Integer)
+    STRING       = Transform::Primitive.new(String)
+    STRING_ARRAY = Transform::Array.new(STRING)
+  end # Transform
+end # Morpher

metadata

@@ -0,0 +1,258 @@
+--- !ruby/object:Gem::Specification
+name: morpher
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Markus Schirp
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: abstract_type
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: adamantium
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: anima
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: concord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+- !ruby/object:Gem::Dependency
+  name: equalizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+- !ruby/object:Gem::Dependency
+  name: ice_nine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: mprelude
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: procto
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: mutant
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: mutant-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+description: Domain Transformation Algebra
+email: mbj@schirp-dso.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+files:
+- LICENSE
+- lib/morpher.rb
+- lib/morpher/newtype.rb
+- lib/morpher/record.rb
+- lib/morpher/transform.rb
+homepage: https://github.com/mbj/morpher
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Domain Transformation Algebra
+test_files: []