aql 0.0.1

data/lib/aql/buffer.rb

@@ -0,0 +1,129 @@
+module AQL
+  # The emit buffer
+  class Buffer
+    include Equalizer.new(:contents)
+
+    # Initialize object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize
+      @buffer = []
+    end
+
+    # Emit wrapped delimited
+    #
+    # @param [String] open
+    # @param [Enumerable<Node>] nodes
+    # @param [String] close
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def wrap_delimited(open, nodes, close)
+      parentheses(open, close) do
+        delimited(nodes)
+      end
+    end
+
+    # Emit block in parentheses
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def parentheses(open = '(', close = ')')
+      append(open)
+      yield
+      append(close)
+    end
+
+    # Emit delimited nodes
+    #
+    # @param [Enumerable<Node>] nodes
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def delimited(nodes, delimiter = ', ')
+      max = nodes.length - 1
+      nodes.each_with_index do |element, index|
+        element.visit(self)
+        append(delimiter) if index < max
+      end
+      self
+    end
+
+    # Emit binary
+    #
+    # @param [Node] left
+    # @param [Symbol] operator
+    # @param [Node] right
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def binary(left, operator, right)
+      parentheses do
+        left.visit(self)
+        append(" #{operator} ")
+        right.visit(self)
+      end
+    end
+
+    # Append content to buffer
+    #
+    # @param [String] content
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def append(content)
+      @buffer << self.class.utf8_encode(content)
+      self
+    end
+
+    # Return content
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def content
+      @buffer.join.freeze
+    end
+
+    if defined?(Encoding)
+      # Encode string in UTF-8
+      #
+      # @param [String] string
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def self.utf8_encode(string)
+        string.encode(Encoding::UTF_8)
+      end
+    else
+      # Dummy encode string for rubies that do not support encoding hell
+      #
+      # @param [String] string
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def self.utf8_encode(string)
+        string
+      end
+    end
+
+  end
+end

data/lib/aql/constants.rb

@@ -0,0 +1,19 @@
+module AQL
+  # The list of AQL keywords from http://www.arangodb.org/manuals/current/Aql.html#AqlKeywords
+  KEYWORDS = IceNine.deep_freeze(%w(
+    FOR
+    RETURN
+    FILTER
+    SORT
+    LIMIT
+    LET
+    COLLECT
+    ASC
+    DESC
+    IN
+    INTO
+    NULL
+    TRUE
+    FALSE
+  ).to_set)
+end

data/lib/aql/node.rb

@@ -0,0 +1,45 @@
+module AQL
+  # Abstract base class for AQL nodes
+  class Node
+    include Adamantium, AbstractType
+
+    # Return source representation
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def aql
+      emitter = Buffer.new
+      emit(emitter)
+      emitter.content
+    end
+    memoize :aql
+
+    # Visit node
+    #
+    # @param [Buffer] buffer
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def visit(buffer)
+      emit(buffer)
+      self
+    end
+
+  private
+
+    # Emit AQL
+    #
+    # @param [Emitter] emitter
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    abstract_method :emit
+
+  end
+end

data/lib/aql/node/attribute.rb

@@ -0,0 +1,25 @@
+module AQL
+  class Node
+    # Attribute node
+    class Attribute < self
+      include Concord.new(:target, :name)
+
+    private
+
+      # Emit attribute
+      #
+      # @param [Buffer] buffer
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit(buffer)
+        target.visit(buffer)
+        buffer.append('.')
+        name.visit(buffer)
+      end
+
+    end
+  end
+end

data/lib/aql/node/block.rb

@@ -0,0 +1,28 @@
+module AQL
+  class Node
+    # Block of AQL statements
+    class Block < self
+      include Concord.new(:elements)
+
+    private
+
+      # Emit contents
+      #
+      # @param [Buffer] buffer
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit(buffer)
+        local = elements
+        max = local.length - 1
+        local.each_with_index do |element, index|
+          element.visit(buffer)
+          buffer.append(' ') if index < max
+        end
+      end
+
+    end
+  end
+end

data/lib/aql/node/call.rb

@@ -0,0 +1,83 @@
+module AQL
+  class Node
+    # AST node for function call
+    class Call < self
+      include Concord.new(:name, :arguments)
+
+    private
+
+      # Emit node
+      #
+      # @param [Buffer] buffer
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit(buffer)
+        buffer.append(name)
+        buffer.parentheses do
+          emit_arguments_with_for_check(buffer)
+        end
+      end
+
+      # Emit arguments with for check
+      #
+      # Handles edge case described in https://github.com/triAGENS/ArangoDB/issues/399
+      #
+      # @param [Buffer] buffer
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_arguments_with_for_check(buffer)
+        if for_argument?
+          emit_arguments_with_extra_parentheses(buffer)
+        else
+          emit_arguments(buffer)
+        end
+      end
+
+      # Emit arguments with parentheses
+      #
+      # @param [Buffer] buffer
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_arguments_with_extra_parentheses(buffer)
+        buffer.parentheses { emit_arguments(buffer) }
+      end
+
+      # Test for `for` body
+      #
+      # @return [true]
+      #   if an instance of Node::Operation::For is the only argument
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def for_argument?
+        local = arguments
+        local.length == 1 and local.first.kind_of?(Operation::For)
+      end
+
+      # Emit arguments
+      #
+      # @param [Buffer] buffer
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_arguments(buffer)
+        buffer.delimited(arguments)
+      end
+
+    end
+  end
+end

data/lib/aql/node/literal.rb

@@ -0,0 +1,48 @@
+module AQL
+  class Node
+    # Abstract base class for literal nodes
+    class Literal < self
+      REGISTRY = {}
+
+      # Register handler
+      #
+      # @param [Class] klass
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.handle(klass)
+        REGISTRY[klass]=self
+      end
+      private_class_method :handle
+
+      # Build literal handler
+      #
+      # @param [Object] object
+      #
+      # @return [Node::Literal]
+      #
+      # @api private
+      #
+      def self.build(object)
+        klass = object.class
+        handler = REGISTRY.fetch(klass) do
+          raise "No support for literal #{klass}"
+        end
+        handler.construct(object)
+      end
+
+      # Construct object
+      #
+      # @return [Node::Literal]
+      #
+      # @api private
+      #
+      def self.construct(*args)
+        new(*args)
+      end
+
+    end
+  end
+end

data/lib/aql/node/literal/composed.rb

@@ -0,0 +1,10 @@
+module AQL
+  class Node
+    class Literal
+      # Base class for composed literals
+      class Composed < self
+        include Concord.new(:body)
+      end
+    end
+  end
+end

data/lib/aql/node/literal/composed/document.rb

@@ -0,0 +1,59 @@
+module AQL
+  class Node
+    class Literal
+      class Composed
+        # Literal document
+        class Document < self
+          handle(Hash)
+
+          # Construct node from primitive
+          #
+          # @param [Hash] hash
+          #
+          # @return [Node::Literal::Document]
+          #
+          # @api private
+          #
+          def self.construct(hash)
+            attributes = hash.map do |key, value|
+              Attribute.new(Literal.build(key), Literal.build(value))
+            end
+            new(attributes)
+          end
+
+          # Literal document attribute
+          class Attribute < Literal
+            include Concord.new(:key, :value)
+
+          private
+
+            # Emit node
+            #
+            # @return [self]
+            #
+            # @api private
+            #
+            def emit(buffer)
+              key.visit(buffer)
+              buffer.append(': ')
+              value.visit(buffer)
+            end
+          end
+
+        private
+
+          # Emit node
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit(buffer)
+            buffer.wrap_delimited('{', body, '}')
+          end
+
+        end
+      end
+    end
+  end
+end