ducktrap 0.0.1

data/lib/ducktrap/error.rb

@@ -0,0 +1,48 @@
+module Ducktrap
+
+  # Error returned for invalid inputs
+  class Error 
+    include PrettyDump, Adamantium::Flat, Concord::Public.new(:context, :input)
+
+  private
+
+    # Dump state to output
+    #
+    # @param [Formatter] formatter
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dump(output)
+      output.name(self)
+      output.attribute(:input, input)
+      output.nest(:context, context)
+    end
+
+    # Error caused by exception
+    class Exception < self
+      include Concord::Public.new(:context, :input, :exception)
+
+    private
+
+      # Dump state to output
+      #
+      # @param [Formatter] formatter
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        excpt = exception
+        output.name(self)
+        output.attribute(:input, input)
+        output.attribute(:exception, excpt.class)
+        output.attribute(:exception_message, excpt.message)
+        output.nest(:context, context)
+      end
+    end
+
+  end
+end

data/lib/ducktrap/evaluator.rb

@@ -0,0 +1,127 @@
+module Ducktrap
+
+  # Abstract base class for transform evaluator
+  class Evaluator
+    include AbstractType, Adamantium::Flat, PrettyDump, Concord::Public.new(:context, :input)
+
+    # Test if conversion was successful
+    #
+    # @return [true]
+    #   if conversion was successful
+    #
+    # @return [false]
+    #   otherwise
+    #
+    # @api private
+    #
+    def successful?
+      !output.kind_of?(Error)
+    end
+    memoize :successful?
+
+    alias_method :success?, :successful?
+
+    # Assert evaluator is successful
+    #
+    # @return [self]
+    #   if successful
+    #
+    # @raise [FailedTransformationError]
+    #   otherwise
+    #
+    # @api private
+    #
+    def assert_successful
+      unless successful?
+        raise FailedTransformationError.new(self)
+      end
+      self
+    end
+
+    # Return output
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    attr_reader :output
+
+    # Return output
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    def output
+      process
+    end
+    memoize :output
+
+  private
+
+    # Calculate result
+    #
+    # @return [Object]
+    #   if successful
+    #
+    # @return [Error]
+    #   otherwise
+    #
+    # @api private
+    #
+    abstract_method :process
+    private :process
+
+    # Return error
+    #
+    # @return [Error]
+    #
+    # @api private
+    #
+    def error
+      Error.new(context, input)
+    end
+
+    # Return error with message
+    #
+    # @param [Error::Message]
+    #
+    # @return [Error]
+    #
+    # @api private
+    #
+    def exception(exception)
+      Error::Exception.new(context, input, exception)
+    end
+
+    # Return nested error
+    #
+    # @return [Error::Nested]
+    #
+    # @api private
+    #
+    def nested_error(error)
+      Error.new(error, input)
+    end
+
+    # Dump object
+    #
+    # @param [Formatter] formatter
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dump(formatter)
+      formatter.name(self)
+      formatter.attribute(:input, input)
+      if successful?
+        formatter.attribute(:output, output)
+      else
+        formatter.nest(:error, output)
+      end
+      formatter.nest(:context, context)
+    end
+
+  end
+end

data/lib/ducktrap/evaluator/invalid.rb

@@ -0,0 +1,30 @@
+module Ducktrap
+  class Evaluator
+    # Evaluator that always returns errors
+    class Invalid < self
+
+      # Return output
+      #
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      attr_reader :output
+
+      # Initialize object
+      #
+      # @param [Ducktra] context
+      # @param [Object] input
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(_context, _input)
+        super
+        @output = error
+      end
+
+    end # Invalid
+  end # Evaluator
+end # Ducktrap

data/lib/ducktrap/evaluator/static.rb

@@ -0,0 +1,25 @@
+module Ducktrap
+  class Evaluator
+
+    # Static evaluator with input as output
+    class Noop < self
+
+      # Return output
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      def output
+        input
+      end
+
+    end # Noop
+
+    # Static evaluator with static output
+    class Static < Noop
+      include Concord::Public.new(:context, :input, :output)
+    end # Static
+
+  end # Evaluator
+end # Ducktrap

data/lib/ducktrap/formatter.rb

@@ -0,0 +1,138 @@
+module Ducktrap
+  # Printer for ducktrap trees
+  class Formatter
+    include Adamantium::Flat, Equalizer.new(:output, :level)
+
+    # Return output
+    #
+    # @return [IO]
+    #
+    # @api private
+    #
+    attr_reader :output
+    protected :output
+
+    # Return indent
+    #
+    # @return [Fixnum]
+    #
+    # @api private
+    #
+    attr_reader :level
+    protected :level
+
+    # Initialize formatter
+    #
+    # @param [IO] output
+    # @param [Fixnum] indent
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(output = $stderr, level = 0)
+      @output, @level = output, level
+    end
+
+    # Write name of class of object
+    #
+    # @param [Object] object
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def name(object)
+      puts(object.class.name)
+    end
+
+    # Write nest with label
+    #
+    # @param [String] label
+    # @param [#pretty_dump] nested
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def nest(label, nested)
+      indented = indent
+      indented.puts("#{label}:")
+      nested.pretty_dump(indented.indent)
+      self
+    end
+
+    # Write labeled value
+    #
+    # @param [#to_str] name
+    # @param [#inspect] value
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def attribute(name, value)
+      indent.puts("#{name}: #{value.inspect}")
+      self
+    end
+
+    # Write body
+    #
+    # @param [Enumerable<#pretty_dump>] body
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def body(body)
+      indented = indent
+      indented.puts('body:')
+      body.each do |member|
+        member.pretty_dump(indented.indent)
+      end
+      self
+    end
+    
+    # Write string with indentation
+    #
+    # @param [String] string
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def puts(string)
+      util = output
+      util.write(prefix)
+      util.puts(string)
+      self
+    end
+
+    # Return formatter with deeper indentation indent
+    #
+    # @return [Formatter]
+    #
+    # @api private
+    #
+    def indent
+      self.class.new(output, level+1)
+    end
+    memoize :indent
+
+  private
+
+    INDENT = '  '.freeze
+
+    # Return prefix at current indentation
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def prefix
+      INDENT * level
+    end
+    memoize :prefix
+
+  end
+end

data/lib/ducktrap/mapper.rb

@@ -0,0 +1,59 @@
+module Ducktrap
+  # An object holding references to two inverse ducktraps
+  class Mapper
+    include Concord::Public.new(:loader, :dumper)
+
+    # Build mapper
+    #
+    # @return [Mapper]
+    #
+    # @api private
+    #
+    def self.build(&block)
+      Builder.new(self, &block).object
+    end
+
+    # Builder for mapper
+    class Builder < Ducktrap::Builder
+
+      # Capture loader block
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def loader(&block)
+        @loader = Ducktrap.build(&block)
+        @dumper ||= @loader.inverse
+        self
+      end
+
+      # Capture dumper block
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def dumper(&block)
+        @dumper = Ducktrap.build(&block)
+        @loader ||= @dumper.inverse
+        self
+      end
+
+      # Return mapper
+      #
+      # @return [Mapper]
+      #
+      # @api private
+      #
+      def object
+        unless @loader or @dumper
+          raise 'Did not specify loader or dumper or both'
+        end
+
+        klass.new(@loader, @dumper)
+      end
+
+    end # Builder
+  end # Mapper
+end # Ducktrap

data/lib/ducktrap/nary.rb

@@ -0,0 +1,148 @@
+module Ducktrap
+  # Mixin for Nary ducktraps
+  module Nary 
+
+    # Builder for nary ducktraps
+    class Builder < Ducktrap::Builder
+      
+      # Add ducktrap argument
+      #
+      # @param [Ducktrap] ducktrap
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def add(ducktrap)
+        body << ducktrap
+        self
+      end
+
+      # Hook called when method is missing
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      def method_missing(name, *arguments, &block)
+        builder = DSL.lookup(name) { super }
+        add(builder.build(*arguments, &block))
+      end
+
+      # Return build instance
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      def object
+        @klass.new(body)
+      end
+      memoize :object
+
+      # Return body
+      #
+      # @return [Enumerable<Ducktrap>]
+      #
+      # @api private
+      #
+      attr_reader :body
+
+      # Initialize object
+      #
+      # @param [Class] klass
+      #   the klass to build
+      #
+      # @param [Enumerable<Ducktrap>] body
+      #   the body of nary ducktrap
+      #
+      # @api private
+      #
+      def initialize(klass, body = [])
+        @body = body
+        super(klass)
+      end
+
+    end # Builder
+
+    module ClassMethods
+
+      # Build ducktrap
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def build(*arguments, &block)
+        Builder.new(self, *arguments, &block).object
+      end
+
+    end # ClassMethods
+
+    module InstanceMethods
+
+    private
+
+      # Return inverse body
+      #
+      # @return [Enumerable<Ducktrap>]
+      #
+      # @api private
+      #
+      def inverse_body
+        body.map(&:inverse).reverse
+      end
+
+      # Dump instance
+      #
+      # @param [Formatter] output
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        output.name(self)
+        output.body(body)
+      end
+
+    end # InstanceMethods
+
+    CONCORD = Concord::Public.new(:body)
+
+    # Hook called when module was included
+    #
+    # @param [Class,Module] scope
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.included(scope)
+      scope.extend(ClassMethods)
+      scope.module_eval do
+        include InstanceMethods
+        include CONCORD
+      end
+    end
+    private_class_method :included
+
+    # Base class for nary evaluators
+    class Evaluator < Ducktrap::Evaluator
+
+    private
+
+      # Return body
+      #
+      # @return [Enumerable<Ducktrap>]
+      #
+      # @api private
+      #
+      def body
+        context.body
+      end
+
+    end # Evaluator
+
+  end # Nary
+end # Ducktrap