morpher 0.2.6

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

data/examples/README.md

@@ -0,0 +1,13 @@
+Morpher Examples
+================
+
+These are some random examples I captured on parings.
+At this early stage the examples are very "unimpressive" and only scratch the surface.
+
+The examples are used for parings to show API in action under IRB:
+
+```
+cd morpher
+bundle exec irb -I lib -r ./examples/your_example.rb
+# Now access the constants defined in example to play with the evaluators
+```

data/examples/a.rb

@@ -0,0 +1,25 @@
+require 'morpher'
+
+extend Morpher::NodeHelpers
+
+class Input
+  include Anima.new(:foo)
+end # Input
+
+node =
+  s(:block,
+    s(:guard, s(:primitive, Hash)),
+    s(:hash_transform,
+      s(:key_symbolize, :foo,
+        s(:guard,
+          s(:or,
+            s(:primitive, String),
+            s(:primitive, NilClass)
+          )
+        )
+      )
+    ),
+    s(:load_attribute_hash, s(:param, Input))
+  )
+
+EVALUATOR = Morpher.compile(node)

data/examples/b.rb

@@ -0,0 +1,35 @@
+require 'morpher'
+
+extend Morpher::NodeHelpers
+
+class Address
+  include Anima.new(:street)
+end
+
+class Person
+  include Anima.new(:address)
+end
+
+node = s(:block,
+  s(:guard, s(:primitive, Hash)),
+  s(:hash_transform,
+    s(:key_symbolize, 'street',
+      s(:guard, s(:primitive, String))
+    )
+  ),
+  s(:load_attribute_hash, s(:param, Address))
+)
+
+ADDRESS_EVALUATOR = Morpher.compile(node)
+
+node = s(:block,
+  s(:guard, s(:primitive, Hash)),
+  s(:hash_transform,
+    s(:key_symbolize, 'address',
+      ADDRESS_EVALUATOR.node
+    )
+  ),
+  s(:load_attribute_hash, s(:param, Person))
+)
+
+PERSON_EVALUATOR = Morpher.compile(node)

data/lib/morpher.rb

@@ -0,0 +1,111 @@
+require 'abstract_type'
+require 'concord'
+require 'anima'
+require 'ast'
+require 'procto'
+
+# Library namespace module
+module Morpher
+
+  Undefined = Module.new.freeze
+
+  # Return evaluator from node
+  #
+  # @param [Node]
+  #
+  # @return [Evaluator]
+  #
+  # @api private
+  #
+  def self.compile(node)
+    node = Compiler::Preprocessor::DEFAULT.call(node)
+    Compiler::Evaluator::DEFAULT.call(node)
+  end
+
+  # Return evaluate block to produce an AST node
+  #
+  # @return [AST::Node]
+  #
+  # @api private
+  #
+  def self.sexp(&block)
+    NodeHelpers.module_eval(&block)
+  end
+
+  # Build morpher from yielding sexp blog
+  #
+  # @return [Evaluator]
+  #
+  # @api private
+  #
+  def self.build(&block)
+    compile(sexp(&block))
+  end
+
+end # Morpher
+
+require 'morpher/node_helpers'
+require 'morpher/registry'
+require 'morpher/printer'
+require 'morpher/printer/mixin'
+require 'morpher/evaluator'
+require 'morpher/evaluator/nullary'
+require 'morpher/evaluator/nullary/parameterized'
+require 'morpher/evaluator/unary'
+require 'morpher/evaluator/binary'
+require 'morpher/evaluator/nary'
+require 'morpher/evaluator/transformer'
+require 'morpher/evaluator/transformer/block'
+require 'morpher/evaluator/transformer/key'
+require 'morpher/evaluator/transformer/guard'
+require 'morpher/evaluator/transformer/attribute'
+require 'morpher/evaluator/transformer/hash_transform'
+require 'morpher/evaluator/transformer/map'
+require 'morpher/evaluator/transformer/static'
+require 'morpher/evaluator/transformer/input'
+require 'morpher/evaluator/transformer/merge'
+require 'morpher/evaluator/transformer/coerce'
+require 'morpher/evaluator/transformer/custom'
+require 'morpher/evaluator/transformer/domain'
+require 'morpher/evaluator/transformer/domain/param'
+require 'morpher/evaluator/transformer/domain/attribute_hash'
+require 'morpher/evaluator/transformer/domain/instance_variables'
+require 'morpher/evaluator/transformer/domain/attribute_accessors'
+require 'morpher/evaluator/predicate'
+require 'morpher/evaluator/predicate/eql'
+require 'morpher/evaluator/predicate/primitive'
+require 'morpher/evaluator/predicate/negation'
+require 'morpher/evaluator/predicate/tautology'
+require 'morpher/evaluator/predicate/contradiction'
+require 'morpher/evaluator/predicate/boolean'
+require 'morpher/evaluation'
+require 'morpher/evaluation'
+require 'morpher/type_lookup'
+require 'morpher/compiler'
+require 'morpher/compiler/error'
+require 'morpher/compiler/emitter'
+require 'morpher/compiler/evaluator'
+require 'morpher/compiler/evaluator/emitter'
+require 'morpher/compiler/preprocessor'
+require 'morpher/compiler/preprocessor/emitter'
+require 'morpher/compiler/preprocessor/emitter/noop'
+require 'morpher/compiler/preprocessor/emitter/key'
+require 'morpher/compiler/preprocessor/emitter/param'
+require 'morpher/compiler/preprocessor/emitter/boolean'
+require 'morpher/compiler/preprocessor/emitter/anima'
+
+module Morpher
+  class Compiler
+
+    class Preprocessor
+      # Default preprocessor compiler
+      DEFAULT = new(Emitter::REGISTRY.freeze)
+    end # Preprocessor
+
+    class Evaluator
+      # Default evaluator compiler
+      DEFAULT = new(Morpher::Evaluator::REGISTRY, Emitter::REGISTRY.freeze)
+    end # Evaluator
+
+  end # Compiler
+end # Morpher

data/lib/morpher/compiler.rb

@@ -0,0 +1,17 @@
+module Morpher
+  # Abstract compiler base class
+  class Compiler
+    include AbstractType
+
+    # Call compiler
+    #
+    # @param [Node] node
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    abstract_method :call
+
+  end # Compiler
+end # Morpher

data/lib/morpher/compiler/emitter.rb

@@ -0,0 +1,82 @@
+module Morpher
+  class Compiler
+    # Abstract target indepentand emitter
+    class Emitter
+      include AbstractType, Adamantium::Flat, NodeHelpers, Procto.call(:output)
+      extend NodeHelpers
+
+      # Return output of emitter
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      abstract_method :output
+
+      # Return node
+      #
+      # @return [Node]
+      #
+      # @api private
+      #
+      abstract_method :node
+      private :node
+
+    private
+
+      # Return children
+      #
+      # @return [Array<AST::Node>]
+      #
+      # @api private
+      #
+      def children
+        node.children
+      end
+
+      # Assert number of child nodes
+      #
+      # @return [self]
+      #   if assertion is fullfilled
+      #
+      # @raise [NodeError]
+      #   otherwise
+      #
+      # @api private
+      #
+      def assert_children_amount(expected_amount)
+        actual_amount = children.length
+        fail Error::NodeChildren.new(node, expected_amount) unless actual_amount.equal?(expected_amount)
+      end
+
+      # Name children
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      # rubocop:disable MethodLength
+      #
+      def self.children(*names)
+        names.each_with_index do |name, index|
+          define_method(name) do
+            children.at(index)
+          end
+          private name
+        end
+
+        define_method(:named_children) do
+          names
+        end
+        private :named_children
+
+        define_method(:remaining_children) do
+          children.drop(names.length)
+        end
+        private :remaining_children
+      end
+      private_class_method :children
+
+    end # Emitter
+  end # Compiler
+end # Morpher

data/lib/morpher/compiler/error.rb

@@ -0,0 +1,84 @@
+module Morpher
+  class Compiler
+
+    # Abstract error class for compiler errors
+    class Error < RuntimeError
+      include AbstractType
+
+      # Error raised when node children have incorrect amount
+      class NodeChildren < self
+        include Concord.new(:node, :expected_amount)
+
+        # Return exception message
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def message
+          "Expected #{expected_amount} #{_children} for #{type}, got #{actual_amount}: #{children}"
+        end
+
+        private
+
+        # Return inspected type
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def type
+          node.type.inspect
+        end
+
+        # Return actual amount of children
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def actual_amount
+          children.length
+        end
+
+        # Return children
+        #
+        # @return [Array]
+        #
+        # @api private
+        #
+        def children
+          node.children
+        end
+
+        # Return user firendly children message
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def _children
+          expected_amount.equal?(1) ? 'child' : 'children'
+        end
+
+      end # NodeChildren
+
+      # Error raised on compiling unknown nodes
+      class UnknownNode < self
+        include Concord.new(:type)
+
+        # Return exception error message
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def message
+          "Node type: #{type.inspect} is unknown"
+        end
+
+      end # UnknownNode
+
+    end # Error
+  end # Compiler
+end # Morpher

data/lib/morpher/compiler/evaluator.rb

@@ -0,0 +1,63 @@
+module Morpher
+  class Compiler
+    # Compiler with evaluators as output
+    class Evaluator < self
+      include Concord.new(:evaluators, :emitters)
+
+      # Return evaluator tree for node
+      #
+      # @param [Node] node
+      #
+      # @return [Evalautor]
+      #   on success
+      #
+      # @raise [Compiler::Error]
+      #   on error
+      #
+      # @api private
+      #
+      def call(node)
+        evaluator = evaluator(node)
+        emitter = emitter(evaluator)
+        emitter.call(self, evaluator, node)
+      end
+
+    private
+
+      # Lookup evaluator for node
+      #
+      # @param [Node]
+      #
+      # @return [Class:Evaluator]
+      #   if found
+      #
+      # @raise [Error::UnknownNode]
+      #   otherwise
+      #
+      # @api private
+      #
+      def evaluator(node)
+        type = node.type
+        evaluators.fetch(type) do
+          fail Error::UnknownNode, type
+        end
+      end
+
+      # Return emitter for evaluator
+      #
+      # @param [Class:Evalautor]
+      #
+      # @return [#call]
+      #
+      # @api private
+      #
+      def emitter(evaluator)
+        emitters.each do |arity, emitter|
+          return emitter if evaluator.ancestors.include?(arity)
+        end
+        fail Error::UnknownNode, evaluator
+      end
+
+    end # Evaluator
+  end # Compiler
+end # Morpher

data/lib/morpher/compiler/evaluator/emitter.rb

@@ -0,0 +1,224 @@
+module Morpher
+  class Compiler
+    class Evaluator
+      # Emitter for evaluators
+      class Emitter < Compiler::Emitter
+        include Registry, Concord.new(:compiler, :evaluator_klass, :node)
+
+        # Return output
+        #
+        # @return [Evaluator]
+        #
+        # @api private
+        #
+        def output
+          validate_node
+          evaluator
+        end
+        memoize :output
+
+        # Validate node
+        #
+        # @return [undefined]
+        #   if successful
+        #
+        # @raise [Error]
+        #   otherwise
+        #
+        # @api private
+        #
+        abstract_method :validate_node
+        private :validate_node
+
+        # Return evaluator
+        #
+        # @return [Evaluator]
+        #
+        # @api private
+        #
+        abstract_method :evaluator
+        private :evaluator
+
+        # Emitter for nullary non parameterized evaluators
+        class Nullary < self
+          register Morpher::Evaluator::Nullary
+
+        private
+
+          # Return output
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def evaluator
+            evaluator_klass.new
+          end
+
+          # Validate node
+          #
+          # @return [undefined]
+          #   if successful
+          #
+          # @raise [Error]
+          #   otherwise
+          #
+          # @api private
+          #
+          def validate_node
+            assert_children_amount(0)
+          end
+
+          # Emitter for nullary parameterized evaluators
+          class Parameterized < self
+            register Morpher::Evaluator::Nullary::Parameterized
+
+            children :param
+
+          private
+
+            # Return output
+            #
+            # @return [Evaluator]
+            #
+            # @api private
+            #
+            def evaluator
+              evaluator_klass.new(effective_param)
+            end
+
+            # Return effective param
+            #
+            # @return [Object]
+            #
+            # @api private
+            #
+            def effective_param
+              if param.kind_of?(AST::Node) && param.type.equal?(:raw) && param.children.length.equal?(1)
+                param.children.first
+              else
+                param
+              end
+            end
+
+            # Validate node
+            #
+            # @return [undefined]
+            #   if successful
+            #
+            # @raise [Error]
+            #   otherwise
+            #
+            # @api private
+            #
+            def validate_node
+              assert_children_amount(1)
+            end
+
+          end # Paramterized
+        end # Nullary
+
+        # Emitter for unary evaluators
+        class Unary < self
+          register Morpher::Evaluator::Unary
+          children :operand
+
+        private
+
+          # Return evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def evaluator
+            evaluator_klass.new(compiler.call(operand))
+          end
+
+          # Validate node
+          #
+          # @return [undefined]
+          #   if successful
+          #
+          # @raise [Error]
+          #   otherwise
+          #
+          # @api private
+          #
+          def validate_node
+            assert_children_amount(1)
+          end
+
+        end # Unary
+
+        # Emitter for unary evaluators
+        class Binary < self
+          register Morpher::Evaluator::Binary
+          children :left, :right
+
+        private
+
+          # Return evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def evaluator
+            evaluator_klass.new(
+              compiler.call(left),
+              compiler.call(right)
+            )
+          end
+
+          # Validate node
+          #
+          # @return [undefined]
+          #   if successful
+          #
+          # @raise [Error]
+          #   otherwise
+          #
+          # @api private
+          #
+          def validate_node
+            assert_children_amount(2)
+          end
+
+        end # Unary
+
+        # Emitter for nary evaluators
+        class Nary < self
+          register Morpher::Evaluator::Nary
+
+        private
+
+          # Return evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def evaluator
+            evaluator_klass.new(children.map(&compiler.method(:call)))
+          end
+
+          # Validate node
+          #
+          # @return [undefined]
+          #   if successful
+          #
+          # @raise [Error]
+          #   otherwise
+          #
+          # @api private
+          #
+          def validate_node
+          end
+
+        end # Nary
+
+      end # Emitter
+    end # Evaluator
+  end # Compiler
+end # Morpher