morpher 0.2.6

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

@@ -0,0 +1,37 @@
+module Morpher
+  class Evaluator
+    class Transformer
+
+      # Identity transformer which always returns +input+
+      class Input < self
+        include Nullary, Transitive
+
+        register :input
+
+        # Call evaluator with input
+        #
+        # @param [Object] input
+        #
+        # @return [Object]
+        #   always returns input
+        #
+        # @api private
+        #
+        def call(input)
+          input
+        end
+
+        # Return inverse evaluator
+        #
+        # @return [Evaluator::Transformer]
+        #
+        # @api private
+        #
+        def inverse
+          self
+        end
+
+      end # Input
+    end # Transformer
+  end # Evaluator
+end # Morpher

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

@@ -0,0 +1,86 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      # Abstract namespace class for evaluators operating on hash keys
+      class Key < self
+        include AbstractType, Nullary::Parameterized, Intransitive
+
+        # Evaluator for dumping hash keys
+        class Dump < self
+
+          register :key_dump
+
+          # Call evaluator
+          #
+          # @param [Object] object
+          #
+          # @return [Array]
+          #
+          # @api private
+          #
+          def call(object)
+            [param, object]
+          end
+
+          # Return inverse evaluator
+          #
+          # @return [Fetch]
+          #
+          # @api private
+          #
+          def inverse
+            Fetch.new(param)
+          end
+
+        end # Dump
+
+        # Evaluator to fetch a specific hash key
+        class Fetch < self
+
+          register :key_fetch
+
+          # Call evaluator
+          #
+          # @param [Hash] object
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def call(object)
+            object.fetch(param) do
+              fail TransformError.new(self, object)
+            end
+          end
+
+          # Return evaluation
+          #
+          # @param [Object] input
+          #
+          # @return [Evaluation]
+          #
+          # @api private
+          #
+          def evaluation(input)
+            output = input.fetch(param) do
+              return evaluation_error(input)
+            end
+
+            evaluation_success(input, output)
+          end
+
+          # Return inverse evaluator
+          #
+          # @return [Dump]
+          #
+          # @api private
+          #
+          def inverse
+            Dump.new(param)
+          end
+
+        end # Fetch
+      end # Key
+    end # Transformer
+  end # Evaluator
+end # Morpher

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

@@ -0,0 +1,100 @@
+module Morpher
+  class Evaluator
+    class Transformer
+
+      # Transformer over each element in an enumerable
+      class Map < self
+        include Unary
+
+        register :map
+
+        # Test if evaluator is transitive
+        #
+        # @return [true]
+        #   if evaluator is transitive
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def transitive?
+          operand.transitive?
+        end
+
+        # Call evaluator
+        #
+        # @param [Enumerable#map] input
+        #
+        # @return [Enumerable]
+        #   if input evaluates true under predicate
+        #
+        # @raise [TransformError]
+        #   otherwise
+        #
+        # @api private
+        #
+        def call(input)
+          input.map(&operand.method(:call))
+        end
+
+        # Return evaluation
+        #
+        # @param [Enumerable#map] input
+        #
+        # @return [Evaluation]
+        #
+        # @api private
+        #
+        # rubocop:disable MethodLength
+        #
+        def evaluation(input)
+          evaluations = input.each_with_object([]) do |item, aggregate|
+            evaluation = operand.evaluation(item)
+            aggregate << evaluation
+            unless evaluation.success?
+              return evaluation_error(input, aggregate)
+            end
+          end
+
+          Evaluation::Nary.success(
+            evaluator:   self,
+            input:       input,
+            output:      evaluations.map(&:output),
+            evaluations: evaluations
+          )
+        end
+
+        # Return inverse evaluator
+        #
+        # @return [Evaluator::Transformer]
+        #
+        # @api private
+        #
+        def inverse
+          self.class.new(operand.inverse)
+        end
+
+      private
+
+        # 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
+
+      end # Guard
+    end # Transformer
+  end # Evaluator
+end # Morpher

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

@@ -0,0 +1,25 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      # Transformer to merge input into defaults
+      class Merge < self
+        include Intransitive, Nullary::Parameterized
+
+        register :merge
+
+        # Call evaluator for input
+        #
+        # @param [Object] input
+        #
+        # @return [Object] output
+        #
+        # @api private
+        #
+        def call(input)
+          param.merge(input)
+        end
+
+      end # Merge
+    end # Transformer
+  end # Evaluator
+end # Morpher

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

@@ -0,0 +1,27 @@
+module Morpher
+  class Evaluator
+    class Transformer
+
+      # Transformer that always returns the passed +param+
+      class Static < self
+        include Nullary::Parameterized, Intransitive
+
+        register :static
+
+        # Call evaluator with input
+        #
+        # @param [Object] _input
+        #
+        # @return [Object]
+        #   alwasys returns the param
+        #
+        # @api private
+        #
+        def call(_input)
+          param
+        end
+
+      end # Static
+    end # Transformer
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/unary.rb

@@ -0,0 +1,79 @@
+module Morpher
+  class Evaluator
+
+    # Mixin for unary evaluators
+    module Unary
+      CONCORD = Concord::Public.new(:operand)
+
+      PRINTER = lambda do |_|
+        name
+        indent do
+          visit(:operand)
+        end
+      end
+
+      # Return node
+      #
+      # @return [AST::Node]
+      #
+      # @api private
+      #
+      def node
+        s(type, operand.node)
+      end
+
+    private
+
+      # Return success evaluation for input
+      #
+      # @param [Object] input
+      #
+      # @return [Evalation::Unary]
+      #
+      # @api private
+      #
+      def evaluation_success(input, operand_evaluation, output)
+        Evaluation::Unary.success(
+          evaluator:          self,
+          input:              input,
+          operand_evaluation: operand_evaluation,
+          output:             output
+        )
+      end
+
+      # Return error evaluation for input
+      #
+      # @param [Object] input
+      #
+      # @return [Evalation::Unary]
+      #
+      # @api private
+      #
+      def evaluation_error(input, operand_evaluation)
+        Evaluation::Unary.error(
+          evaluator:          self,
+          input:              input,
+          operand_evaluation: operand_evaluation
+        )
+      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 # Unary
+
+  end # Evaluator
+end # Morpher

data/lib/morpher/node_helpers.rb

@@ -0,0 +1,19 @@
+module Morpher
+  # Node helpers
+  module NodeHelpers
+
+    # Build node
+    #
+    # @param [Symbol] type
+    #
+    # @return [Parser::AST::Node]
+    #
+    # @api private
+    #
+    def s(type, *children)
+      AST::Node.new(type, children)
+    end
+    module_function :s
+
+  end # NodeHelpers
+end # Morpher

data/lib/morpher/printer.rb

@@ -0,0 +1,233 @@
+module Morpher
+
+  # Evaluation and Evaluator pretty printer
+  class Printer
+    include Adamantium::Flat, Concord.new(:object, :output, :indent_level)
+
+    INDENT = '  '.freeze
+
+    REGISTRY = {}
+
+    # Run pretty printer on object
+    #
+    # @param [Object] object
+    #   the object to be pretty printed
+    # @param [IO] output
+    #   the output to write to
+    # @param [Fixnum] indent_level
+    #   the current indentation level
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def self.run(object, output, indent_level = 0)
+      printer = new(object, output, indent_level)
+      block = lookup(object)
+      printer.instance_eval(&block)
+    end
+
+    # Perform type lookup
+    #
+    # FIXME: Instanciate type lookup once and allow caching.
+    #
+    # @param [Evaluation, Evaluator] object
+    #
+    # @return [Proc]
+    #   if found
+    #
+    # @raise [PrinterMissingException]
+    #   otherwise
+    #
+    # @api private
+    #
+    def self.lookup(object)
+      TypeLookup.new(REGISTRY).call(object)
+    end
+
+  private
+
+    # Visit a child
+    #
+    # @param [Node] child
+    #
+    # @api private
+    #
+    # @return [undefined]
+    #
+    def visit_child(child)
+      self.class.run(child, output, indent_level.succ)
+    end
+
+    # Visit a child by name
+    #
+    # @param [Symbol] name
+    #   the attribute name of the child to visit
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def visit(name)
+      child = object.public_send(name)
+      child_label(name)
+      visit_child(child)
+    end
+
+    # Visit many children
+    #
+    # @param [Symbol] name
+    #   the name of the collection attribute with children to visit
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def visit_many(name)
+      children = object.public_send(name)
+      child_label(name)
+      children.each do |child|
+        visit_child(child)
+      end
+    end
+
+    # Print attribute class
+    #
+    # @param [Symbol] name
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def attribute_class(name)
+      label_value(name, object.public_send(name).class)
+    end
+
+    # Print inspected attribute value with label
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def attribute(name)
+      label_value(name, object.public_send(name))
+    end
+
+    # Print attributes of object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def attributes(*names)
+      names.each do |name|
+        attribute(name)
+      end
+    end
+
+    # Print name of object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def name
+      puts(object.class.name)
+    end
+
+    # Return string indented with current level
+    #
+    # @param [String] content
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def indented(content)
+      "#{indentation_prefix}#{content}"
+    end
+
+    # Return indentation prefix
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def indentation_prefix
+      INDENT * indent_level
+    end
+    memoize :indentation_prefix
+
+    # Add content to output at current indentation and close line
+    #
+    # @param [String] content
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def puts(string)
+      output.puts(indented(string))
+    end
+
+    # Write content to output at current indentation
+    #
+    # @param [String] content
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def write(string)
+      output.write(indented(string))
+    end
+
+    # Write child label to output at current indentation
+    #
+    # @param [String] label
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def child_label(string)
+      puts("#{string}:")
+    end
+
+    # Call block inside indented context
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def indent(&block)
+      printer = new(object, output, indent_level.succ)
+      printer.instance_eval(&block)
+    end
+
+    # Return new printer
+    #
+    # @return [Printer]
+    #
+    # @api private
+    #
+    def new(*arguments)
+      self.class.new(*arguments)
+    end
+
+    # Print label with value
+    #
+    # @param [String] label
+    # @param [Object] value
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def label_value(label, value)
+      write("#{label}: ")
+      output.puts(value.inspect)
+    end
+
+  end # Printer
+end # Morpher