ducktrap 0.0.1

data/lib/ducktrap/node/guard_nil.rb

@@ -0,0 +1,42 @@
+module Ducktrap
+  class Node
+    # Transformation node to guard nil inputs as nil outputs
+    class GuardNil < self
+      include Unary, Equalizer.new(:operand)
+
+      register :guard_nil
+
+      # Return inverse transformation
+      #
+      # @return [Node]
+      #
+      # @api private
+      #
+      def inverse
+        self.class.new(operand.inverse)
+      end
+
+      # Evaluator for guard nil node
+      class Evaluator < Unary::Evaluator
+
+      private
+
+        # Return output
+        #
+        # @return [Object]
+        #   if successful
+        #
+        # @return [Error]
+        #   otherwise
+        #
+        # @api private
+        #
+        def process
+          return if input.nil?
+          operand_output
+        end
+
+      end # Evaluator
+    end # GuardNil
+  end # Node
+end # Ducktrap

data/lib/ducktrap/node/hash.rb

@@ -0,0 +1,7 @@
+module Ducktrap
+  class Node
+    # Base namespace class for hash operations
+    class Hash < self
+    end
+  end
+end

data/lib/ducktrap/node/hash/transform.rb

@@ -0,0 +1,53 @@
+module Ducktrap
+  class Node
+    class Hash
+      # Ducktrap that expects outputs to be hashes and merges them together 
+      #
+      # TODO: Find better primitive!
+      #
+      class Transform < self
+        include Nary
+
+        register :hash_transform
+
+        # Return inverse transformation
+        #
+        # @return [Node]
+        #
+        # @api privateo
+        #
+        def inverse
+          self.class.new(body.map(&:inverse))
+        end
+
+        # Evaluator of chained ducktraps
+        class Evaluator < Nary::Evaluator
+
+        private
+
+          # Calculate evaluator
+          #
+          # @return [Object]
+          #   if successful
+          #
+          # @return [Error]
+          #   otherwise
+          #
+          # @api private
+          #
+          def process
+            body.each_with_object({}) do |ducktrap, hash|
+              evaluator = ducktrap.call(input)
+
+              unless evaluator.successful?
+                return nested_error(evaluator)
+              end
+
+              hash.merge!(evaluator.output)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ducktrap/node/invalid.rb

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

data/lib/ducktrap/node/inverse.rb

@@ -0,0 +1,46 @@
+module Ducktrap
+  class Node
+    # Noop ducktrap with fixed inverse
+    class Inverse < self
+      include Concord::Public.new(:operand)
+
+      register :inverse
+
+      # Return inverse node
+      #
+      # @return [Forward]
+      #
+      # @api private
+      #
+      def inverse
+        Forward.new(operand)
+      end
+
+      # Return evaluator
+      #
+      # @param [Object] input
+      #
+      # @return [Evaluator]
+      #
+      # @api private
+      #
+      def call(input)
+        Evaluator::Noop.new(self, input)
+      end
+
+    private
+
+      # Perform pretty dump
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        output.name(self)
+        output.nest(:operand, operand)
+      end
+
+    end # Inverse
+  end # Node
+end # Ducktrap

data/lib/ducktrap/node/key.rb

@@ -0,0 +1,61 @@
+module Ducktrap
+  class Node
+    # Base class for ducktraps that manipulate keys
+    class Key < self
+      include Unary, Equalizer.new(:operand, :key)
+
+      # Return key
+      #
+      # @return [Object]
+      # 
+      # @api private
+      #
+      attr_reader :key
+
+      # Initiaize object
+      #
+      # @param [Ducktrap] operand
+      # @param [Object] key
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(operand, key)
+        @key = key
+        super(operand)
+      end
+
+    private
+
+      # Dump object
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dump(output)
+        output.name(self)
+        output.attribute(:key, key)
+        output.nest(:operand, operand)
+      end
+
+      # Base class for key evaluators
+      class Evaluator < Unary::Evaluator
+
+      private
+
+        # Return key to operate on
+        #
+        # @return [Object]
+        #
+        # @api private
+        #
+        def key
+          context.key
+        end
+
+      end
+    end
+  end
+end

data/lib/ducktrap/node/key/add.rb

@@ -0,0 +1,42 @@
+module Ducktrap
+  class Node
+    class Key
+      # Ducktrap to dump value to a specific key
+      class Add < self
+
+        register :add_key
+
+        # Return inverse ducktrap
+        #
+        # @return [Ducktrap]
+        #
+        # @api private
+        #
+        def inverse
+          Delete.new(operand, key)
+        end
+
+        # Evaluator for add key node
+        class Evaluator < Key::Evaluator
+
+        private
+
+          # Process input
+          #
+          # @return [Object]
+          #   if successful
+          #
+          # @return [Error]
+          #   otherwise
+          #
+          # @api private
+          #
+          def process_operand_output
+            input.merge(key => operand_output)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ducktrap/node/key/delete.rb

@@ -0,0 +1,44 @@
+module Ducktrap
+  class Node
+    class Key
+      # Ducktrap to dump value to a specific key
+      class Delete < self
+
+        register :delete_key
+
+        # Return inverse ducktrap
+        #
+        # @return [Ducktrap]
+        #
+        # @api private
+        #
+        def inverse
+          Add.new(operand, key)
+        end
+
+        # Evaluator for delete key node
+        class Evaluator < Key::Evaluator
+
+        private
+
+          # Process input
+          #
+          # @return [Object]
+          #   if successful
+          #
+          # @return [Error]
+          #   otherwise
+          #
+          # @api private
+          #
+          def process
+            dup = input.dup
+            dup.delete(key)
+            dup
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Ducktrap
+  class Node
+    class Key
+      # Ducktrap to dump value to a specific key
+      class Dump < self
+
+        register :dump_key
+
+        # Return inverse ducktrap
+        #
+        # @return [Ducktrap]
+        #
+        # @api private
+        #
+        def inverse
+          Fetch.new(operand.inverse, key)
+        end
+
+        # Evaluator for dump key node
+        class Evaluator < Key::Evaluator
+
+        private
+
+          # Process successful operand output
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def process_operand_output
+            { key => operand_output }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ducktrap/node/key/fetch.rb

@@ -0,0 +1,49 @@
+module Ducktrap
+  class Node
+    class Key
+      # Ducktrap to fetch and transform a specific key
+      class Fetch < self
+
+        register :fetch_key
+
+        # Return inverse ducktrap
+        #
+        # @return [Ducktrap]
+        #
+        # @api private
+        #
+        def inverse
+          Dump.new(operand.inverse, key)
+        end
+
+        # Evaluator for fetch key ducktrap
+        class Evaluator < Key::Evaluator
+
+        private
+
+          # Process input
+          #
+          # @return [Object]
+          #   if successful
+          #
+          # @return [Error]
+          #   otherwise
+          #
+          # @api private
+          #
+          def process
+            value = input.fetch(context.key) do
+              return error
+            end
+            evaluator = process_operand(value)
+            unless evaluator.successful?
+              return nested_error(evaluator)
+            end
+            evaluator.output
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ducktrap/node/map.rb

@@ -0,0 +1,42 @@
+module Ducktrap
+  class Node
+    # Ducktrap that performs map operation
+    class Map < self
+      include Unary
+
+      register :map
+
+      # Return inverse transformator
+      #
+      # @return [Ducktrap]
+      #
+      # @api private
+      #
+      def inverse
+        self.class.new(operand.inverse)
+      end
+
+      # Evaluator for collection ducktrap
+      class Evaluator < Unary::Evaluator
+
+      private
+
+        # Calculate evaluator
+        #
+        # @return [Object]
+        #
+        # @api private
+        #
+        def process
+          input.map do |element|
+            evaluator = operand.call(element)
+            unless evaluator.successful?
+              return nested_error(evaluator)
+            end
+            evaluator.output
+          end
+        end
+      end
+    end
+  end
+end