mutant 0.8.24 → 0.9.0

data/lib/mutant/runner/sink.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Mutant
-  class Runner
+  module Runner
     class Sink
       include Concord.new(:env)
 

data/lib/mutant/selector/null.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Selector
+    # Selector that never returns tests
+    class Null < self
+      include Equalizer.new
+
+      # Tests for subject
+      #
+      # @param [Subject] subject
+      #
+      # @return [Enumerable<Test>]
+      def call(_subject)
+        EMPTY_ARRAY
+      end
+    end # Null
+  end # Selector
+end # Mutant

data/lib/mutant/subject.rb

@@ -4,7 +4,9 @@ module Mutant
   # Subject of a mutation
   class Subject
     include AbstractType, Adamantium::Flat, Enumerable
-    include Concord::Public.new(:context, :node)
+    include Anima.new(:context, :node, :warnings)
+
+    private :warnings
 
     # Mutations for this subject
     #

data/lib/mutant/subject/method/instance.rb

@@ -13,7 +13,9 @@ module Mutant
         #
         # @return [self]
         def prepare
-          scope.__send__(:undef_method, name)
+          warnings.call do
+            scope.public_send(:undef_method, name)
+          end
           self
         end
 

data/lib/mutant/transform.rb

@@ -0,0 +1,511 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Transform
+    include Adamantium, AbstractType
+
+    # Default slug
+    #
+    # @return [String]
+    def slug
+      self.class.to_s
+    end
+
+    # Apply transformation to input
+    #
+    # @param [Object] input
+    #
+    # @return [Either<Error, Object>]
+    abstract_method :apply
+
+    # Deep error data structure
+    class Error
+      include Adamantium, Anima.new(
+        :cause,
+        :input,
+        :message,
+        :transform
+      )
+
+      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
+
+      # Path representation to error
+      #
+      # @return [String]
+      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 apply(input)
+        transformer.apply(input).lmap(&method(:wrap_error))
+      end
+
+      # Named slug
+      #
+      # @return [String]
+      def slug
+        name
+      end
+    end # Named
+
+  private
+
+    # Make error from curent context
+    #
+    # @param [Error, nil] cause
+    #   original error, if any
+    #
+    # @param [Object] input
+    #   input that ran into the error
+    #
+    # @param [String] message
+    #   human readable error message
+    #
+    # @param [Transform, nil]
+    #   transform that generated the error from input
+    #
+    # @return [Error]
+    #
+    # ignore :reek:LongParameterList
+    def error(cause: nil, input:, message: nil)
+      Error.new(
+        cause:     cause,
+        input:     input,
+        message:   message,
+        transform: self
+      )
+    end
+
+    # Lift error
+    #
+    # @param [Error]
+    #
+    # @return [Error]
+    def lift_error(error)
+      error.with(transform: self)
+    end
+
+    # Wrap error
+    #
+    # @param [Error]
+    #
+    # @return [Error]
+    def wrap_error(error)
+      error(cause: error, input: error.input)
+    end
+
+    # Create failure
+    #
+    # @param [Object] value
+    #
+    # @return [Either::Left]
+    #
+    # ignore :reek:UtilityFunction
+    def failure(value)
+      Either::Left.new(value)
+    end
+
+    # Create success
+    #
+    # @param [Object] value
+    #
+    # @return [Either::Right]
+    #
+    # ignore :reek:UtilityFunction
+    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)
+
+      # 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 apply(input)
+        transform.apply(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 apply(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 apply(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 apply(input)
+        PRIMITIVE
+          .apply(input)
+          .lmap(&method(:lift_error))
+          .apply(&method(:run))
+      end
+
+    private
+
+      # Transform array
+      #
+      # @param [Array<Object>] input
+      #
+      # @return [Either<Error, Array<Object>]
+      #
+      # ignore :reek:NestedIterators
+      #
+      # rubocop:disable Metrics/MethodLength
+      def run(input)
+        output = []
+
+        input.each_with_index do |value, index|
+          output << transform.apply(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
+        # Apply transformation to input
+        #
+        # @param [Hash{String => Object}]
+        #
+        # @return [Hash{Symbol => Object}]
+        def apply(input)
+          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 apply(input)
+          transform.apply(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 apply(input)
+        PRIMITIVE
+          .apply(input)
+          .lmap(&method(:lift_error))
+          .apply(&method(:reject_keys))
+          .apply(&method(:transform))
+      end
+
+    private
+
+      # Transform hash
+      #
+      # @param [Hash] input
+      #
+      # @return [Either<Error, Hash>]
+      def transform(input)
+        transform_required(input).apply do |required|
+          transform_optional(input).fmap(&required.method(:merge))
+        end
+      end
+
+      # Transform required keys
+      #
+      # @param [Hash] input
+      #
+      # @return [Either<Error, Hash>]
+      def transform_required(input)
+        transform_keys(required, input)
+      end
+
+      # Transform optional keys
+      #
+      # @param [Hash] input
+      #
+      # @return [Either<Error, Hash>]
+      def transform_optional(input)
+        transform_keys(
+          optional.select { |key| input.key?(key.value) },
+          input
+        )
+      end
+
+      # Transform keys
+      #
+      # @param [Array<Transform::Hash::Key>] keys
+      # @param [Hash] input
+      #
+      # @return [Either<Error, Hash>]
+      #
+      # ignore :reek:NestedIterators
+      #
+      # 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
+
+      # Coerce key value under key specific transformer
+      #
+      # @param [Hash::Key] key
+      # @param [Hash] input
+      #
+      # @return [Either<Error, Object>]
+      def coerce_key(key, input)
+        key.apply(input.fetch(key.value)).lmap do |error|
+          error(input: input, cause: error)
+        end
+      end
+
+      # Reject unexpected keys
+      #
+      # @param [Hash]
+      #
+      # @return [Either<Error, Object>]
+      #
+      # 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
+
+      # Key values allowed to be present
+      #
+      # @return [Array<Object>]
+      def allowed_keys
+        required_keys + optional.map(&:value)
+      end
+      memoize :allowed_keys
+
+      # Key values required to be present
+      #
+      # @return [Array<Object>]
+      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]
+      #
+      # ignore :reek:NestedIterators
+      #
+      # @return [Either<Error, Object>]
+      def apply(input)
+        current = input
+
+        steps.each_with_index do |step, index|
+          current = step.apply(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 apply(input)
+        Either.wrap_error(error_class) { block.call(input) }
+          .lmap { |exception| error(input: input, message: exception.to_s) }
+      end
+    end # Exception
+  end # Transform
+end # Mutant