morpher 0.2.6

data/lib/morpher/evaluator.rb

@@ -0,0 +1,40 @@
+module Morpher
+
+  # Abstract namespace class for non tracking evaluators
+  class Evaluator
+    include Adamantium::Flat,
+            Registry,
+            AbstractType,
+            Printer::Mixin,
+            NodeHelpers
+
+    # Call evaluator in non tracking mode
+    #
+    # @param [Object] input
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    abstract_method :call
+
+    # Call evaluator in tracking mode
+    #
+    # @param [Object] input
+    #
+    # @return [Evaluation]
+    #
+    # @api private
+    #
+    abstract_method :evaluation
+
+    # Return inverse evaluator
+    #
+    # @return [Evaluator]
+    #
+    # @api private
+    #
+    abstract_method :inverse
+
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/binary.rb

@@ -0,0 +1,46 @@
+module Morpher
+
+  class Evaluator
+
+    # Mixin for binary evaluators
+    module Binary
+      CONCORD = Concord::Public.new(:left, :right)
+
+      PRINTER = lambda do |_|
+        name
+        indent do
+          visit(:left)
+          visit(:right)
+        end
+      end
+
+      # Return node
+      #
+      # @return [AST::Node]
+      #
+      # @api private
+      #
+      def node
+        s(type, left.node, right.node)
+      end
+
+    private
+
+      # Hook called when module gets included
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.included(descendant)
+        descendant.class_eval do
+          include CONCORD
+          printer(&PRINTER)
+        end
+      end
+      private_class_method :included
+
+    end # Nary
+
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/nary.rb

@@ -0,0 +1,97 @@
+module Morpher
+  class Evaluator
+
+    # Mixin for nary evaluators
+    module Nary
+      CONCORD = Concord::Public.new(:body)
+
+      PRINTER = lambda do |_|
+        name
+        indent do
+          visit_many(:body)
+        end
+      end
+
+      # Return AST
+      #
+      # @return [AST::Node]
+      #
+      # @api private
+      #
+      def node
+        s(type, *body.map(&:node))
+      end
+
+    private
+
+      # Return positive evaluation
+      #
+      # @param [Object] input
+      # @param [Array<Evaluation>] evaluations
+      #
+      # @return [Evaluation]
+      #
+      # @api private
+      #
+      def evaluation_positive(input, evaluations)
+        Evaluation::Nary.success(
+          evaluator:   self,
+          input:       input,
+          output:      true,
+          evaluations: evaluations
+        )
+      end
+
+      # Return negative evaluation
+      #
+      # @param [Object] input
+      # @param [Array<Evaluation>] evaluations
+      #
+      # @return [Evaluation]
+      #
+      # @api private
+      #
+      def evaluation_negative(input, evaluations)
+        Evaluation::Nary.success(
+          evaluator:   self,
+          input:       input,
+          output:      false,
+          evaluations: evaluations
+        )
+      end
+
+      # Return evaluation error
+      #
+      # @param [Object] input
+      # @param [Array<Evaluation>] evaluations
+      #
+      # @return [Evaluation]
+      #
+      # @api private
+      #
+      def evaluation_error(input, evaluations)
+        Evaluation::Nary.error(
+          evaluator:   self,
+          input:       input,
+          evaluations: evaluations
+        )
+      end
+
+      # Hook called when module gets included
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.included(descendant)
+        descendant.class_eval do
+          include CONCORD
+          printer(&PRINTER)
+        end
+      end
+      private_class_method :included
+
+    end # Nary
+
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/nullary.rb

@@ -0,0 +1,92 @@
+module Morpher
+  class Evaluator
+    # Mixin to define nullary evaluators
+    module Nullary
+
+      CONCORD = Concord::Public.new
+
+      PRINTER = lambda do |_|
+        name
+      end
+
+      # Instance methods for nullary evaluators
+      module InstanceMethods
+
+        # Return default successful evaluation
+        #
+        # @param [Object] input
+        #
+        # @return [Evaluation]
+        #
+        # @api private
+        #
+        def evaluation(input)
+          evaluation_success(input, call(input))
+        end
+
+        # Return node
+        #
+        # @return [AST::Node]
+        #
+        # @api private
+        #
+        def node
+          s(type)
+        end
+
+      private
+
+        # Return evaluation error for input
+        #
+        # @param [Object] input
+        #
+        # @return [Evaluation]
+        #
+        # @api private
+        #
+        def evaluation_error(input)
+          Evaluation::Nullary.new(
+            evaluator: self,
+            input:     input,
+            output:    Undefined,
+            success:   false
+          )
+        end
+
+        # Return evaluation success for input and output
+        #
+        # @param [Object] input
+        # @param [Object] output
+        #
+        # @return [Evaluation]
+        #
+        # @api private
+        #
+        def evaluation_success(input, output)
+          Evaluation::Nullary.new(
+            evaluator: self,
+            input:     input,
+            output:    output,
+            success:   true
+          )
+        end
+
+      end # InstanceMethods
+
+      # Hook called when module gets included
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.included(descendant)
+        descendant.class_eval do
+          include InstanceMethods, CONCORD
+          printer(&PRINTER)
+        end
+      end
+      private_class_method :included
+
+    end # Nullary
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/nullary/parameterized.rb

@@ -0,0 +1,48 @@
+module Morpher
+  class Evaluator
+    module Nullary
+      # Mixin to define parameterized nullary evaluators
+      module Parameterized
+
+        CONCORD = Concord::Public.new(:param)
+
+        PRINTER = lambda do |_|
+          name
+          indent do
+            attribute :param
+          end
+        end
+
+        # Mixin for nullary parameterized evaluators
+        module InstanceMethods
+
+          # Return node
+          #
+          # @return [AST::Node]
+          #
+          # @api private
+          #
+          def node
+            s(type, param)
+          end
+
+        end # InstanceMethods
+
+        # Hook called when module gets included
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def self.included(descendant)
+          descendant.class_eval do
+            include InstanceMethods, Nullary::InstanceMethods, CONCORD
+            printer(&PRINTER)
+          end
+        end
+        private_class_method :included
+
+      end # Nullary
+    end # Parameterized
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/predicate.rb

@@ -0,0 +1,22 @@
+module Morpher
+  class Evaluator
+    # Abstract namespace class for predicate evaluators
+    class Predicate < self
+      include Transformer::Intransitive
+
+      # Return inverse evaluator
+      #
+      # This is a very naive implementation.
+      # Subclasses can do a more elaborated choice.
+      #
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      def inverse
+        Negation.new(self)
+      end
+
+    end # Predicate
+  end # Evaluator
+end # Morpher

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

@@ -0,0 +1,76 @@
+module Morpher
+  class Evaluator
+    class Predicate
+      # Evaluator for nary boolean predicates
+      class Boolean < self
+        include Nary
+
+        # Call evaluator with input
+        #
+        # @param [Object] input
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        #
+        def call(input)
+          body .public_send(
+            self.class::ENUMERABLE_METHOD
+          ) { |evaluator| evaluator.call(input) }
+        end
+
+        # Return evaluation for input
+        #
+        # @param [Object] input
+        #
+        # @return [Evaluation::Nary]
+        #
+        # @api private
+        #
+        def evaluation(input)
+          klass = self.class
+
+          evaluations = body.each_with_object([]) do |evaluator, aggregate|
+            evaluation = evaluator.evaluation(input)
+            aggregate << evaluation
+            next if evaluation.output.equal?(klass::OUTPUT_EXPECTATION)
+            return send(klass::ERROR_METHOD, input, aggregate)
+          end
+
+          send(klass::SUCCESS_METHOD, input, evaluations)
+        end
+
+        # Evaluator for nary and predicates
+        class And < self
+          register :and
+
+          ENUMERABLE_METHOD  = :all?
+          OUTPUT_EXPECTATION = true
+          ERROR_METHOD       = :evaluation_negative
+          SUCCESS_METHOD     = :evaluation_positive
+        end # And
+
+        # Evaluator for nary or predicates
+        class Or < self
+          register :or
+
+          ENUMERABLE_METHOD  = :any?
+          OUTPUT_EXPECTATION = false
+          ERROR_METHOD       = :evaluation_positive
+          SUCCESS_METHOD     = :evaluation_negative
+        end # Or
+
+        # Evaluator for nary xor predicates
+        class Xor < self
+          register :xor
+
+          ENUMERABLE_METHOD  = :one?
+          OUTPUT_EXPECTATION = false
+          ERROR_METHOD       = :evaluation_positive
+          SUCCESS_METHOD     = :evaluation_negative
+        end # Xor
+
+      end # Boolean
+    end # Predicate
+  end # Evaluator
+end # Morpher

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

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