ducktrap 0.0.1

data/lib/ducktrap/node/noop.rb

@@ -0,0 +1,30 @@
+module Ducktrap
+  class Node
+    # Noope node, returns input as output
+    class Noop < self
+      include Singleton
+
+      register :noop
+
+      # Run ducktrap
+      #
+      # @param [Object] input
+      # 
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      def call(input)
+        Evaluator::Noop.new(self, input)
+      end
+
+      # Return inverse ducktrap
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def inverse; self; end
+    end
+  end
+end

data/lib/ducktrap/node/primitive.rb

@@ -0,0 +1,61 @@
+module Ducktrap
+  class Node
+    # Primitive check
+    class Primitive < self
+      include Concord::Public.new(:primitive)
+
+      register :primitive
+
+      # Run ducktrap in input
+      #
+      # @param [Object] input
+      #
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      def call(input)
+        unless input.kind_of?(primitive)
+          return Evaluator::Invalid.new(self, input)
+        end
+
+        Evaluator::Noop.new(self, input)
+      end
+
+      # Return inverse ducktrap
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def inverse; self end
+
+    private
+
+      # Perfrom pretty dump
+      #
+      # @param [Formatter] output
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        output.name(self)
+        output.attribute(:primitive, primitive)
+      end
+      
+      class << self
+
+        # Build node
+        #
+        # @return [node]
+        #
+        # @api private
+        #
+        alias_method :build, :new
+      end
+
+    end # Primitive
+  end # node
+end # Ducktrap

data/lib/ducktrap/node/static.rb

@@ -0,0 +1,33 @@
+module Ducktrap
+  class Node
+    # Transformer with static output
+    class Static < self
+      include Nullary, Concord::Public.new(:value, :inverse_value)
+
+      register :static
+
+      # Run ducktrap on input
+      #
+      # @param [Object] input
+      #
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      def call(input)
+        Evaluator::Static.new(self, input, value)
+      end
+
+      # Return inverse ducktrap
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def inverse
+        Static.new(inverse_value, value)
+      end
+
+    end # Static
+  end # Node
+end # Ducktrap

data/lib/ducktrap/nullary.rb

@@ -0,0 +1,41 @@
+module Ducktrap
+  # Mixin for defining nullary ducktraps
+  module Nullary 
+    # Class method mixin
+    module ClassMethods
+
+      # Build ducktrap
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def build(*args)
+        if block_given?
+          raise "#{name}.build does not take a block"
+        end
+        new(*args)
+      end
+
+    end # ClassMethods
+
+    # Hook called when module is included
+    #
+    # @param [Module] scope
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.included(scope)
+      scope.extend(ClassMethods)
+    end
+    private_class_method :included
+
+    # Evaluator for nullary nodes
+    class Evaluator < Ducktrap::Evaluator
+
+    end # Evaluator
+
+  end # Nullary
+end # Ducktrap

data/lib/ducktrap/pretty_dump.rb

@@ -0,0 +1,31 @@
+module Ducktrap
+  # Mixin for pretty dumpable objects
+  module PrettyDump
+
+    # Perform pretty dump of ducktrap
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def pretty_dump(output=Formatter.new)
+      dump(output)
+      self
+    end
+
+    # Return pretty inspection
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def pretty_inspect
+      io = StringIO.new
+      formatter = Formatter.new(io)
+      pretty_dump(formatter)
+      io.rewind
+      io.read
+    end
+
+  end # PrettyDump
+end # Ducktrap

data/lib/ducktrap/registry.rb

@@ -0,0 +1,60 @@
+module Ducktrap
+
+  # Registry for ducktraps
+  class Registry
+
+    # Register ducktrap under name
+    #
+    # @param [Symbol] name
+    # @param [Ducktrap] ducktrap
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def register(name, ducktrap)
+      if @index.key?(name)
+        raise "name: #{name.inspect} does already exist" 
+      end
+
+      @index[name] = ducktrap
+
+      self
+    end
+
+    # Lookup ducktrap for name
+    #
+    # @param [Symbol] name
+    #
+    # @return [Ducktrap]
+    #   if found
+    #
+    # @return [self]
+    #   otherwise
+    #
+    # @yield 
+    #   if no ducktrap found for name
+    #
+    # @api private
+    #
+    def lookup(name)
+      @index.fetch(name) do
+        yield
+      end
+    end
+
+  private
+
+    # Initialize object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize
+      @index = {}
+    end
+  end
+
+  DSL = Registry.new
+end

data/lib/ducktrap/singleton.rb

@@ -0,0 +1,55 @@
+module Ducktrap
+  # Mixin to define nullary ducktraps
+  module Singleton 
+    module InstanceMethods
+      include Adamantium::Flat
+
+      # Return inspect string
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def inspect
+        "<#{self.class.name}>"
+      end
+      memoize :inspect
+
+    private
+
+    end # InstanceMethods
+
+    module ClassMethods
+
+      # Return instance
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def instance
+        @instance ||= new
+      end
+
+      alias_method :build, :instance
+
+    end # ClassMethods
+
+    # Hook called when module is included
+    #
+    # @param [Module] scope
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.included(scope)
+      scope.module_eval do
+        extend ClassMethods
+        include InstanceMethods
+        private_class_method :new
+      end
+    end
+
+  end # Singleton
+end # Ducktrap

data/lib/ducktrap/unary.rb

@@ -0,0 +1,153 @@
+module Ducktrap
+  # Mixin for defining unary ducktraps
+  module Unary 
+    # Instance methods mixin for unary ducktraps
+    module InstanceMethods
+
+      # Return ducktrap
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      attr_reader :operand
+
+      # Initialize object
+      #
+      # @param [Ducktrap] operand
+      #
+      # @api private
+      #
+      def initialize(operand)
+        @operand = operand
+      end
+
+    private
+
+      # Perform pretty dump
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        output.name(self)
+        output.nest(:operand, operand)
+      end
+
+    end
+
+    module ClassMethods
+
+      # Build ducktrap
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def build(*args, &block)
+        postprocessor = Node::Noop.instance
+        if block
+          postprocessor = Node::Block.build(&block)
+        end
+        new(postprocessor, *args)
+      end
+
+    end
+
+    # Hook called when module is included
+    #
+    # @param [Module] scope
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.included(scope)
+      scope.module_eval do
+        include InstanceMethods, Equalizer.new(:operand)
+        extend ClassMethods
+      end
+    end
+
+    private_class_method :included
+
+    # Evaluator for unary nodes
+    class Evaluator < Ducktrap::Evaluator
+
+    private
+
+      # Return operand
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def operand
+        context.operand
+      end
+
+      # Process operand
+      #
+      # @param [Object] input
+      #
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      def process_operand(input)
+        operand.call(input)
+      end
+
+      # Process input with operand
+      #
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      def operand_evaluator
+        process_operand(input)
+      end
+      memoize :operand_evaluator
+
+      # Return operand output
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      def operand_output
+        operand_evaluator.output
+      end
+
+      # Process input
+      #
+      # @param [Object]
+      #
+      # @return [Object]
+      #   if successful
+      #
+      # @return [Error]
+      #   otherwise
+      #
+      # @api private
+      #
+      def process
+        evaluator = operand_evaluator
+        unless evaluator.successful?
+          return nested_error(evaluator)
+        end
+        process_operand_output
+      end
+
+      # Process operand output
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      abstract_method :process_operand_output
+
+    end # Evaluator
+  end # Unary
+end # Ducktrap