ducktrap 0.0.1

data/lib/ducktrap/node.rb

@@ -0,0 +1,94 @@
+module Ducktrap
+  # Abstract base class for transformation nodes
+  class Node
+    include AbstractType, PrettyDump, Adamantium::Flat
+
+    # Return inversed ducktrap
+    #
+    # @param [Object] input
+    #
+    # @return [Evaluator]
+    #
+    # @api private
+    #
+    abstract_method :inverse
+
+    # Run ducktrap on input
+    #
+    # @param [Object] input
+    #
+    # @return [Evaluator]
+    #
+    # @api private
+    #
+    def call(input)
+      evaluator_klass.new(self, input)
+    end
+
+    # Process input and raise exception on error
+    #
+    # @param [Object] input
+    #
+    # @return [Object]
+    #   if successful
+    #
+    # @raise [RuntimeError]
+    #   otherwise
+    #
+    # @api private
+    #
+    def run(input)
+      evaluator = call(input)
+      evaluator.assert_successful
+      evaluator.output
+    end
+
+    # Register dsl name
+    #
+    # @param [Symbol] name
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def self.register(name)
+      DSL.register(name, self)
+    end
+    private_class_method :register
+
+    # Build ducktrap
+    #
+    # @return [Ducktrap]
+    #
+    # @api private
+    #
+    def self.build(&block)
+      self::Block.build(&block)
+    end
+
+  private
+
+    # Dump object
+    #
+    # @param [Formatter] output
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dump(output)
+      output.name(self)
+    end
+
+    # Return evaluator class
+    #
+    # @return [Class:Evaluator]
+    #
+    # @api private
+    #
+    def evaluator_klass
+      self.class::Evaluator
+    end
+
+  end # Node
+end # Ducktrap

data/lib/ducktrap/node/anima.rb

@@ -0,0 +1,40 @@
+module Ducktrap
+  class Node
+    # Base class for anima nodes
+    class Anima < self
+      include Nullary, Concord::Public.new(:model)
+
+    private
+
+      # Perform pretty dump
+      #
+      # @param [Formatter] output
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        output.name(self)
+        output.attribute(:model, model)
+      end
+
+      # Evaluator base class for anima nodes
+      class Evaluator < Nullary::Evaluator
+
+      private
+
+        # Return model
+        #
+        # @return [Class:Anima]
+        #
+        # @api private
+        #
+        def model
+          context.model
+        end
+
+      end
+    end
+  end
+end

data/lib/ducktrap/node/anima/dump.rb

@@ -0,0 +1,39 @@
+module Ducktrap
+  class Node
+    class Anima
+
+      # Dumper for anima
+      class Dump < self
+        register :anima_dump
+
+        # Return inverse ducktrap
+        #
+        # @return [Ducktrap]
+        #
+        # @api private
+        #
+        def inverse
+          Load.new(model)
+        end
+
+        # Evaluator for anima dump nodes
+        class Evaluator < Anima::Evaluator
+
+        private
+
+          # Process input
+          #
+          # @return [Hash]
+          #   if successful
+          #
+          # @api private
+          #
+          def process
+            model.attributes_hash(input)
+          end
+
+        end
+      end 
+    end
+  end
+end

data/lib/ducktrap/node/anima/load.rb

@@ -0,0 +1,39 @@
+module Ducktrap
+  class Node
+    class Anima
+      # Load attributes hash
+      class Load < self
+        register :anima_load
+
+        # Return inverse ducktrap
+        #
+        # @return [Ducktrap]
+        #
+        # @api private
+        #
+        def inverse
+          Dump.new(model)
+        end
+
+        # Evaluator of anima load ducktrap
+        class Evaluator < Anima::Evaluator
+
+        private
+
+          # Process input
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def process
+            model.new(input)
+          rescue ::Anima::Error => exception
+            exception(exception)
+          end
+
+        end # Evaluator
+      end # Load
+    end
+  end
+end

data/lib/ducktrap/node/block.rb

@@ -0,0 +1,44 @@
+module Ducktrap
+  class Node
+    # Ducktrap that returns last evaluator output of a chain and stops on first failure.
+    # Acts like AND with multiple inputs.
+    class Block < self
+      include Nary
+
+      # Return inverse ducktrap
+      #
+      # @return [Node]
+      #
+      # @api private
+      #
+      def inverse
+        self.class.new(inverse_body)
+      end
+
+      # Evaluator of chained ducktraps
+      class Evaluator < Nary::Evaluator
+
+      private
+
+        # Calculate evaluator
+        #
+        # @return [Object]
+        #   if successful
+        #
+        # @return [Error]
+        #   otherwise
+        #
+        # @api private
+        #
+        def process
+          body.inject(input) do |input, ducktrap|
+            evaluator = ducktrap.call(input)
+            return nested_error(evaluator) unless evaluator.successful?
+            evaluator.output
+          end
+        end
+
+      end # Evaluator
+    end # Block
+  end # Node
+end # Ducktrap

data/lib/ducktrap/node/coercion.rb

@@ -0,0 +1,7 @@
+module Ducktrap
+  class Node
+    # Transformatio node for primitive coercion
+    class Coercion
+    end
+  end
+end

data/lib/ducktrap/node/custom.rb

@@ -0,0 +1,121 @@
+module Ducktrap
+  class Node
+    # Custom, user defined node
+    class Custom < self
+      include Concord::Public.new(:forward_block, :inverse_block)
+
+      register :custom
+
+      # FIXME: Remove this after a while
+      register :extern
+
+      # Return inverse
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def inverse
+        self.class.new(inverse_block, forward_block)
+      end
+
+      # Run with input
+      #
+      # @param [Object] input
+      #
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      def call(input)
+        Evaluator::Static.new(self, input, forward_block.call(input))
+      end
+
+    private
+
+      # Dump object
+      #
+      # @param [Formatter] output
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        output.name(self)
+        output.attribute(:forward, forward_block)
+        output.attribute(:inverse, inverse_block)
+      end
+
+      # Build external ducktrap
+      #
+      # @return [External]
+      #
+      # @api private
+      #
+      def self.build(&block)
+        Builder.new(self, &block).object
+      end
+
+      # Builder for external ducktrap
+      class Builder < Ducktrap::Builder
+
+        # Capture forward block
+        #
+        # @return [self]
+        #
+        # @api private
+        #
+        def forward(&block)
+          @forward_block = block
+          self
+        end
+
+        # Capture inverse block
+        #
+        # @return [self]
+        #
+        # @api private
+        #
+        def inverse(&block)
+          @inverse_block = block
+          self
+        end
+
+        # Return ducktrap
+        #
+        # @return [Ducktrap]
+        #
+        # @api private
+        #
+        def object
+          klass.new(forward_block, inverse_block)
+        end
+
+      private
+
+        # Return block
+        #
+        # @return [Proc]
+        #
+        # @api private
+        #
+        def forward_block
+          @forward_block || raise('No forward block specified!')
+        end
+
+        # Return inverse block
+        #
+        # @return [Proc]
+        #
+        # @api private
+        #
+        def inverse_block
+          @inverse_block || raise('No inverse block specified!')
+        end
+
+      end # Builder
+
+    end # Custom
+  end # Node
+end # Ducktrap

data/lib/ducktrap/node/disjunction.rb

@@ -0,0 +1,8 @@
+module Ducktrap
+  class Node
+    # Node for disjunct input processing
+    class Disjunction < self
+      include Nary
+    end
+  end
+end

data/lib/ducktrap/node/forward.rb

@@ -0,0 +1,55 @@
+module Ducktrap
+  class Node
+    # Ducktrap with noop inverse
+    class Forward < self
+      include Unary, Concord::Public.new(:operand)
+
+      register :forward
+
+      # Return inverse node
+      #
+      # @return [Inverse]
+      #
+      # @api private
+      #
+      def inverse
+        Inverse.new(operand)
+      end
+
+    private
+
+      # Perform pretty dump
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        output.name(self)
+        output.nest(:operand, operand)
+      end
+
+      # Evaluator for forward nodes
+      class Evaluator < Unary::Evaluator
+
+      private
+
+        # Return output
+        #
+        # @return [Object]
+        #   if successful
+        #
+        # @return [Error]
+        #   otherwise
+        #
+        # @api private
+        #
+        def process
+          operand_output
+        end
+
+      end # Evaluator
+
+    end # Forward
+  end # Node
+end # Ducktrap