morpher 0.2.6

data/lib/morpher/evaluator/predicate/eql.rb

@@ -0,0 +1,50 @@
+module Morpher
+  class Evaluator
+    class Predicate
+      # Binary equal evaluator
+      class EQL < self
+        include Binary
+
+        register :eql
+
+        # Call evaluator
+        #
+        # @param [Object] input
+        #
+        # @return [true]
+        #   if input is semantically equivalent to expectation
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def call(input)
+          left.call(input).eql?(right.call(input))
+        end
+
+        # Return evaluation
+        #
+        # @param [Object] input
+        #
+        # @return [Evaluation]
+        #
+        # @api private
+        #
+        def evaluation(input)
+          left_evaluation  = left.evaluation(input)
+          right_evaluation = right.evaluation(input)
+
+          Evaluation::Binary.success(
+            evaluator: self,
+            input: input,
+            output: left_evaluation.output.eql?(right_evaluation.output),
+            left_evaluation: left_evaluation,
+            right_evaluation: right_evaluation
+          )
+        end
+
+      end # EQL
+    end # Predicate
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/predicate/negation.rb

@@ -0,0 +1,52 @@
+module Morpher
+  class Evaluator
+    class Predicate
+      # Predicate negation
+      class Negation < self
+        include Unary
+
+        register :negate
+
+        # Return evaluation for input
+        #
+        # @param [Object] input
+        #
+        # @return [Evaluation]
+        #
+        # @api private
+        #
+        def evaluation(input)
+          operand_output = operand.call(input)
+          evaluation_success(input, operand_output, !operand_output)
+        end
+
+        # Call evaluator
+        #
+        # @param [Object] input
+        #
+        # @return [true]
+        #   if input NOT evaluated to true under operand
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def call(input)
+          !operand.call(input)
+        end
+
+        # Return inverse evaluator
+        #
+        # @return [Evaluator]
+        #
+        # @api private
+        #
+        def inverse
+          operand
+        end
+
+      end # Negation
+    end # Predicate
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/predicate/primitive.rb

@@ -0,0 +1,49 @@
+module Morpher
+  class Evaluator
+    class Predicate
+      # Abstract namespace class for predicate evaluators on primitives
+      class Primitive < self
+        include Nullary::Parameterized
+
+        # Evaluator for exact primitive match
+        class Exact < self
+
+          register :primitive
+
+          # Call evaluator
+          #
+          # @param [Object] object
+          #
+          # @return [true]
+          #   if object's type is #equal?
+          #
+          # @api private
+          #
+          def call(object)
+            object.class.equal?(param)
+          end
+
+        end # Exact
+
+        # Evaluator for permissive primtivie match
+        class Permissive < self
+          register :is_a
+
+          # Call evaluator
+          #
+          # @param [Object] object
+          #
+          # @return [true]
+          #   if objects type equals exactly
+          #
+          # @api private
+          #
+          def call(object)
+            object.kind_of?(param)
+          end
+
+        end # Permissive
+      end # Primitive
+    end # Predicate
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/predicate/tautology.rb

@@ -0,0 +1,36 @@
+module Morpher
+  class Evaluator
+    class Predicate
+
+      # Evaluator for trautology
+      class Tautology < self
+        include Nullary
+
+        register :true
+
+        # Call predicate evaluator
+        #
+        # @param [Object] _input
+        #
+        # @return [true]
+        #
+        # @api private
+        #
+        def call(_input)
+          true
+        end
+
+        # Return inverse evaluator
+        #
+        # @return [Evaluator]
+        #
+        # @api private
+        #
+        def inverse
+          Contradiction.new
+        end
+
+      end # Tautology
+    end # Predicate
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/transformer.rb

@@ -0,0 +1,75 @@
+module Morpher
+  class Evaluator
+    # Abstract namespace class for transforming evaluators
+    class Transformer < self
+      include AbstractType
+
+      # Error raised when transformation cannot continue
+      class TransformError < RuntimeError
+        include Concord.new(:transformer, :input)
+      end
+
+      # Test evaluator transformer is transitive
+      #
+      # A transitive evaluator allows to inverse an operation
+      # via its #inverse evaluator.
+      #
+      # @return [true]
+      #   if transformer is transitive
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      abstract_method :transitive?
+
+      # Mixin for evaluators that are transitive by definition
+      module Transitive
+
+        # Test if evaluator is transitive
+        #
+        # @return [false]
+        #
+        # @api private
+        #
+        def transitive?
+          true
+        end
+
+      end # Intransitive
+
+      # Mixin for evaluators that are intransitive by definition
+      module Intransitive
+
+        # Test if evaluator is transitive
+        #
+        # @return [false]
+        #
+        # @api private
+        #
+        def transitive?
+          false
+        end
+
+      end # Intransitive
+
+    private
+
+      # Raise transform error
+      #
+      # @param [Object] input
+      #
+      # @raise [TransformError]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def raise_transform_error(input)
+        fail TransformError.new(self, input)
+      end
+
+    end # Transform
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/transformer/attribute.rb

@@ -0,0 +1,25 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      # Transformer to return a specific attribute of input
+      class Attribute < self
+        include Nullary::Parameterized, Intransitive
+
+        register :attribute
+
+        # Call evaluator
+        #
+        # @param [Object] input
+        #
+        # @return [Object]
+        #
+        # @api private
+        #
+        def call(input)
+          input.public_send(param)
+        end
+
+      end # Attribute
+    end # Transformer
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/transformer/block.rb

@@ -0,0 +1,81 @@
+module Morpher
+  class Evaluator
+    class Transformer
+
+      # Evaluator to perform n transformations in a row
+      class Block < self
+        include Nary
+
+        register :block
+
+        # Test if evaluator is transitive
+        #
+        # @return [true]
+        #   if block is transitive
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def transitive?
+          body.all?(&:transitive?)
+        end
+
+        # Call transformer
+        #
+        # @param [Object] input
+        #
+        # @return [Object]
+        #
+        # @api private
+        #
+        def call(input)
+          body.reduce(input) do |state, evaluator|
+            evaluator.call(state)
+          end
+        end
+
+        # Return inverse evaluator
+        #
+        # @return [Evaluator]
+        #
+        # @api private
+        #
+        def inverse
+          self.class.new(body.reverse.map(&:inverse))
+        end
+
+        # Return evaluation for input
+        #
+        # @param [Object] input
+        #
+        # @return [Evaluation::Nary]
+        #
+        # @api private
+        #
+        # rubocop:disable MethodLength
+        #
+        def evaluation(input)
+          state = input
+
+          evaluations = body.each_with_object([]) do |evaluator, aggregate|
+            evaluation = evaluator.evaluation(state)
+            aggregate << evaluation
+            unless evaluation.success?
+              return evaluation_error(input, aggregate)
+            end
+            state = evaluation.output
+          end
+
+          Evaluation::Nary.success(
+            evaluator:   self,
+            input:       input,
+            output:      state,
+            evaluations: evaluations
+          )
+        end
+      end # Block
+    end # Transformer
+  end # Evaluato
+end # Morpher

data/lib/morpher/evaluator/transformer/coerce.rb

@@ -0,0 +1,166 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      # Abstract namespace class for coercing transformers
+      class Coerce < self
+        include AbstractType, Nullary::Parameterized, Transitive
+
+        # Parse mixin for cases the parsing possibly results
+        # in Argument and Type errors.
+        module Parse
+
+          # Call evaluator
+          #
+          # @param [Object] input
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def call(input)
+            invoke(input)
+          rescue ArgumentError, TypeError
+            raise_transform_error(input)
+          end
+
+          # Return evaluation
+          #
+          # @param [Object] input
+          #
+          # @return [Evaluation]
+          #
+          # @api private
+          #
+          def evaluation(input)
+            evaluation_success(input, invoke(input))
+          rescue ArgumentError, TypeError
+            evaluation_error(input)
+          end
+        end # Parse
+
+        # Evaluator for parsing an integer
+        class ParseInt < self
+
+          include Parse
+
+          register :parse_int
+
+          # Return inverse evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def inverse
+            IntToString.new(param)
+          end
+
+        private
+
+          # Invoke coercion
+          #
+          # @return [Integer]
+          #
+          # @raise [ArgumentError, TypeError]
+          #   if coercion does not succeed
+          #
+          # @api private
+          #
+          def invoke(input)
+            Integer(input, param)
+          end
+
+        end # ParseInt
+
+        # Evaluator for dumping fixnums to strings
+        class IntToString < self
+
+          register :int_to_string
+
+          # Call evaluator
+          #
+          # @param [Object] input
+          #
+          # @return [Hash<Symbol, Object>]
+          #
+          # @api private
+          #
+          def call(input)
+            input.to_s(param)
+          end
+
+          # Return inverse evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def inverse
+            ParseInt.new(param)
+          end
+
+        end # IntToString
+
+        # Evaluator for parsing an ISO8601 String into a DateTime
+        class ParseIso8601DateTime < self
+
+          include Parse
+
+          register :parse_iso8601_date_time
+
+          # Return inverse evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def inverse
+            DateTimeToIso8601String.new(param)
+          end
+
+        private
+
+          # Invoke coercion
+          #
+          # @return [DateTime]
+          #
+          # @raise [ArgumentError, TypeError]
+          #   if coercion does not succeed
+          #
+          # @api private
+          #
+          def invoke(input)
+            DateTime.iso8601(input)
+          end
+        end # ParseIso8601DateTime
+
+        # Evaluator for dumping a DateTime to an ISO8601 string
+        class DateTimeToIso8601String < self
+          register :date_time_to_iso8601_string
+
+          # Call evaluator
+          #
+          # @param [Object] input
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def call(input)
+            input.iso8601(param)
+          end
+
+          # Return inverse evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def inverse
+            ParseIso8601DateTime.new(param)
+          end
+        end # DateTimeToIso8601String
+      end # Fixnum
+    end # Transformer
+  end # Evaluator
+end # Morpher