morpher 0.2.6

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

@@ -0,0 +1,34 @@
+module Morpher
+  class Evaluator
+    class Transformer < self
+      # Custom transformer with external injected behavior
+      class Custom < self
+        include Nullary::Parameterized, Transitive
+        register :custom
+
+        # Call transformer with input
+        #
+        # @param [Object]
+        #
+        # @return [undefinedo]
+        #
+        # @api private
+        #
+        def call(input)
+          param.first.call(input)
+        end
+
+        # Return inverse transformer
+        #
+        # @return [Evaluator::Transformer]
+        #
+        # @api private
+        #
+        def inverse
+          self.class.new(param.reverse)
+        end
+
+      end # Custom
+    end # Transformer
+  end # Evaluator
+end # Morpher

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

@@ -0,0 +1,86 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      # Abstract namespace class for transformers from/to domain
+      class Domain < self
+        include AbstractType, Nullary::Parameterized, Transitive
+
+      private
+
+        # Call block with param attributes
+        #
+        # @param [Object] aggregate
+        #
+        # @return [Object]
+        #
+        # @api private
+        #
+        def transform(aggregate, &block)
+          param.attributes.each_with_object(aggregate, &block)
+        end
+
+        # Mixin for domain dumpers
+        module Dump
+
+          # Return inverse evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def inverse
+            self.class::Load.new(param)
+          end
+
+        private
+
+          # Dump object
+          #
+          # @param [Symbol] left
+          # @param [Symbol] right
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def dump(&block)
+            transform({}, &block)
+          end
+
+        end # Dump
+
+        # Mixin for domain loaders
+        module Load
+          include AbstractType
+
+          # Return inverse evaluator
+          #
+          # @return [Evaluator]
+          #
+          # @api private
+          #
+          def inverse
+            self.class::Dump.new(param)
+          end
+
+        private
+
+          # Load object
+          #
+          # @param [Symbol] left
+          # @param [Symbol] right
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def load(&block)
+            transform(param.model.allocate, &block)
+          end
+
+        end # Load
+
+      end # Domain
+    end # Transformer
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/transformer/domain/attribute_accessors.rb

@@ -0,0 +1,60 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      class Domain
+        # Abstract namespace class for domain objects via attribute accessors
+        class AttributeAccessors < self
+          include AbstractType
+
+          # Evaluator for dumping domain objects via instance variables
+          class Dump < self
+            include Domain::Dump
+
+            register :dump_attribute_accessors
+
+            # Call evaluator
+            #
+            # @param [Object] input
+            #
+            # @return [Hash<Symbol, Object>]
+            #
+            # @api private
+            #
+            def call(input)
+              dump do |attribute, attributes|
+                name = attribute.name
+                attributes[name] = input.public_send(name)
+              end
+            end
+
+          end # Dump
+
+          # Evaluator for loading domain objects via attributes hash
+          class Load < self
+            include Domain::Load
+
+            register :load_attribute_accessors
+
+            # Call evaluator
+            #
+            # @param [Object] input
+            #
+            # @return [Object]
+            #
+            # @api private
+            #
+            def call(input)
+              load do |attribute, object|
+                object.public_send(
+                  attribute.writer,
+                  input.fetch(attribute.name)
+                )
+              end
+            end
+
+          end # Load
+        end # Domain
+      end # Anima
+    end # Transformer
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/transformer/domain/attribute_hash.rb

@@ -0,0 +1,52 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      class Domain < self
+        # Abstract namespace class for domain objects on attributes hash
+        class AttributeHash < self
+          include AbstractType
+
+          # Evaluator for dumping domain objects via attributes hash
+          class Dump < self
+            include Domain::Dump
+
+            register :dump_attribute_hash
+
+            # Call evaluator
+            #
+            # @param [Object] input
+            #
+            # @return [Hash<Symbol, Object>]
+            #
+            # @api private
+            #
+            def call(input)
+              input.to_h
+            end
+
+          end # Dump
+
+          # Evaluator for loading domain objects via attributes hash
+          class Load < self
+            include Domain::Load
+
+            register :load_attribute_hash
+
+            # Call evaluator
+            #
+            # @param [Object] input
+            #
+            # @return [Object]
+            #
+            # @api private
+            #
+            def call(input)
+              param.model.new(input)
+            end
+
+          end # Load
+        end # Domain
+      end # Anima
+    end # Transformer
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/transformer/domain/instance_variables.rb

@@ -0,0 +1,60 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      class Domain < self
+        # Abstract namespace class for domain objects via instance variables
+        class InstanceVariables < self
+          include AbstractType
+
+          # Evaluator for dumping domain objects via instance variables
+          class Dump < self
+            include Domain::Dump
+
+            register :dump_instance_variables
+
+            # Call evaluator
+            #
+            # @param [Object] input
+            #
+            # @return [Hash<Symbol, Object>]
+            #
+            # @api private
+            #
+            def call(input)
+              dump do |attribute, attributes|
+                attributes[attribute.name] =
+                  input.instance_variable_get(attribute.ivar_name)
+              end
+            end
+
+          end # Dump
+
+          # Evaluator for loading domain objects via instance variables
+          class Load < self
+            include Domain::Load
+
+            register :load_instance_variables
+
+            # Call evaluator
+            #
+            # @param [Object] input
+            #
+            # @return [Object]
+            #
+            # @api private
+            #
+            def call(input)
+              load do |attribute, object|
+                object.instance_variable_set(
+                  attribute.ivar_name,
+                  input.fetch(attribute.name)
+                )
+              end
+            end
+
+          end # Load
+        end # Domain
+      end # Anima
+    end # Transformer
+  end # Evaluator
+end # Morpher

data/lib/morpher/evaluator/transformer/domain/param.rb

@@ -0,0 +1,54 @@
+module Morpher
+  class Evaluator
+    class Transformer
+      class Domain < self
+
+        # Domain specific transformer parameter
+        class Param
+          include Adamantium, Concord::Public.new(:model, :attribute_names)
+
+          # Return attributes
+          #
+          # @return [Enumerable<Attribute>]
+          #
+          # @api private
+          #
+          def attributes
+            attribute_names.map(&Attribute.method(:new))
+          end
+          memoize :attributes
+
+          # Attribute on a domain transformer param
+          class Attribute
+            include Adamantium, Concord::Public.new(:name)
+
+            # Return instance variable name
+            #
+            # @return [Symbol]
+            #
+            # @api private
+            #
+            def ivar_name
+              :"@#{name}"
+            end
+            memoize :ivar_name
+
+            # Return writer name
+            #
+            # @return [Symbol]
+            #
+            # @api private
+            #
+            def writer
+              :"#{name}="
+            end
+            memoize :writer
+
+          end # Attribute
+
+        end # Param
+
+      end # Domain
+    end # Transformer
+  end # Evaluator
+end # Morpher

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

@@ -0,0 +1,62 @@
+module Morpher
+  class Evaluator
+    class Transformer
+
+      # Transformer that allows to guard transformation process
+      # with a predicate on input
+      class Guard < self
+        include Unary, Transitive
+
+        register :guard
+
+        # Call evaluator
+        #
+        # @param [Object] input
+        #
+        # @return [Object]
+        #   if input evaluates true under predicate
+        #
+        # @raise [TransformError]
+        #   otherwise
+        #
+        # @api private
+        #
+        def call(input)
+          if operand.call(input)
+            input
+          else
+            fail TransformError.new(self, input)
+          end
+        end
+
+        # Return evaluation
+        #
+        # @param [Object] input
+        #
+        # @return [Evaluation::Guard]
+        #
+        # @api private
+        #
+        def evaluation(input)
+          operand_evaluation = operand.evaluation(input)
+          if operand_evaluation.output
+            evaluation_success(input, operand_evaluation, input)
+          else
+            evaluation_error(input, operand_evaluation)
+          end
+        end
+
+        # Return inverse evaluator
+        #
+        # @return [self]
+        #
+        # @api private
+        #
+        def inverse
+          self
+        end
+
+      end # Guard
+    end # Transformer
+  end # Evaluator
+end # Morpher

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

@@ -0,0 +1,149 @@
+module Morpher
+  class Evaluator
+    class Transformer
+
+      # Too complex hash transformation evaluator
+      #
+      # FIXME: Should be broken up in better
+      # primitives a decompose, compose pair
+      #
+      # @api private
+      #
+      class HashTransform < self
+        include Nary
+
+        register :hash_transform
+
+        # Test if evaluator is transitive
+        #
+        # FIXME: Needs to be calculated dynamically
+        #
+        # @return [true]
+        #   if evaluator is transitive
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def transitive?
+          body.all?(&self.class.method(:transitive_keypair?))
+        end
+
+        # Test if evaluator is a keypair
+        #
+        # FIXME: Refactor the need for this away.
+        #
+        #   This is a side effect from this class is
+        #   generally to big in sense of SRP.
+        #   Must be refactorable away. But dunno now.
+        #   Still exploring.
+        #
+        # @param [Evaluator]
+        #
+        # @api private
+        #
+        def self.transitive_keypair?(evaluator)
+          return false unless evaluator.kind_of?(Block)
+
+          body = evaluator.body
+
+          left, operator, right = body if body.length.equal?(3)
+
+          left.kind_of?(Key::Fetch) &&
+          right.kind_of?(Key::Dump) &&
+          operator.transitive?
+        end
+
+        # Call evaluator
+        #
+        # @param [Object] input
+        #
+        # @return [Object]
+        #
+        # @api private
+        #
+        def call(input)
+          content = body.map do |node|
+            node.call(input)
+          end
+          Hash[content]
+        end
+
+        # Return inverse evaluator
+        #
+        # @return [HashTransform]
+        #
+        # @api private
+        #
+        def inverse
+          self.class.new(body.map(&:inverse))
+        end
+
+        # Return evaluation
+        #
+        # @param [Input]
+        #
+        # @return [Evaluation::Nary]
+        #
+        # @api private
+        #
+        # rubocop:disable MethodLength
+        #
+        def evaluation(input)
+          evaluations = body.each_with_object([]) do |evaluator, aggregate|
+            evaluation = evaluator.evaluation(input)
+            aggregate << evaluation
+            unless evaluation.success?
+              return evaluation_error(input, aggregate)
+            end
+          end
+
+          output = Hash[evaluations.map(&:output)]
+
+          Evaluation::Nary.success(
+            evaluator:   self,
+            input:       input,
+            evaluations: evaluations,
+            output:      output
+          )
+        end
+
+      private
+
+        # Return evaluation error
+        #
+        # @return [Object] input
+        #
+        # @return [Array<Evaluations>] evaluations
+        #
+        # @api private
+        #
+        def evaluation_error(input, evaluations)
+          Evaluation::Nary.error(
+            evaluator:   self,
+            input:       input,
+            evaluations: evaluations
+          )
+        end
+
+        # Build evaluator from node
+        #
+        # @param [Compiler] compiler
+        # @param [Node] node
+        #
+        # @return [Evaluator]
+        #
+        # @api private
+        #
+        def self.build(compiler, node)
+          body = node.children.map do |child|
+            compiler.call(child)
+          end
+          new(body)
+        end
+
+      end # HashTransform
+    end # Transformer
+  end # Evaluator
+end # Morpher