aql 0.0.1

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

@@ -0,0 +1,42 @@
+module AQL
+  class Node
+    class Literal
+      class Composed
+        # Literal list node
+        class List < self
+          handle(Array)
+
+        private
+
+          # Emit node
+          #
+          # @param [Buffer] buffer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit(buffer)
+            buffer.wrap_delimited('[', body, ']')
+          end
+
+          # Construct object
+          #
+          # @param [#each] object
+          #
+          # @return [Node::Literal::List]
+          #
+          # @api private
+          #
+          def self.construct(object)
+            body = object.map do |item|
+              Literal.build(item)
+            end
+            new(body)
+          end
+
+        end
+      end
+    end
+  end
+end

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

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

data/lib/aql/node/literal/primitive/number.rb

@@ -0,0 +1,28 @@
+module AQL
+  class Node
+    class Literal
+      class Primitive
+        # Literal number node
+        class Number < self
+          handle(Float)
+          handle(Fixnum)
+
+        private
+
+          # Emit AQL
+          #
+          # @param [Buffer] buffer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit(buffer)
+            buffer.append(value.to_s)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aql/node/literal/primitive/string.rb

@@ -0,0 +1,27 @@
+module AQL
+  class Node
+    class Literal
+      class Primitive
+        # Literal string node
+        class String < self
+          handle(::String)
+
+        private
+
+          # Emit AQL
+          #
+          # @param [Buffer] buffer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit(buffer)
+            buffer.append(value.inspect)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module AQL
+  class Node
+    class Literal
+      # Singleton literal
+      class Singleton < self
+        include Concord.new(:token)
+
+        handle(NilClass)
+        handle(TrueClass)
+        handle(FalseClass)
+
+        private_class_method :new
+
+        # Construct object
+        #
+        # @param [Object] object
+        #
+        # @return [Node::Literal::Singleton]
+        #
+        # @api private
+        #
+        def self.construct(object)
+          MAPPING.fetch(object)
+        end
+
+      private
+
+        # Emit node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          buffer.append(token)
+        end
+
+        NULL  = new('null')
+        FALSE = new('false')
+        TRUE  = new('true')
+
+        MAPPING = {
+          nil   => NULL,
+          false => FALSE,
+          true  => TRUE
+        }
+
+      end
+    end
+  end
+end

data/lib/aql/node/name.rb

@@ -0,0 +1,31 @@
+module AQL
+  class Node
+    # Generic AQL object name
+    class Name < self
+      include Concord.new(:name)
+
+    private
+
+      # Emit node
+      #
+      # @param [Buffer] buffer
+      #
+      # @return [undefined]
+      #
+      def emit(buffer)
+        buffer.append(quoted_name)
+      end
+
+      # Return quoted name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def quoted_name
+        %Q(`#{name}`)
+      end
+
+    end
+  end
+end

data/lib/aql/node/null.rb

@@ -0,0 +1,21 @@
+module AQL
+  class Node
+    # Null node that does not emit anything
+    NULL = Class.new(self) do
+
+    private
+
+      # Perform emit on buffer
+      #
+      # @param [Buffer] buffer
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit(_buffer)
+      end
+
+    end.new
+  end
+end

data/lib/aql/node/operation.rb

@@ -0,0 +1,20 @@
+module AQL
+  class Node
+    # Base class for operations
+    class Operation < self
+
+    private
+
+      # Return keyword
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def keyword
+        self.class::KEYWORD
+      end
+
+    end
+  end
+end

data/lib/aql/node/operation/binary.rb

@@ -0,0 +1,33 @@
+module AQL
+  class Node
+    class Operation
+      # Base class for binary operations
+      class Binary < self
+        include Concord.new(:left, :right)
+
+        # Binary let operation
+        class Let < self
+
+          KEYWORD = :LET
+
+        private
+
+          # Emit node
+          #
+          # @param [Buffer] buffer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit(buffer)
+            buffer.append("#{keyword} ")
+            left.visit(buffer)
+            buffer.append(' = ')
+            right.visit(buffer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aql/node/operation/for.rb

@@ -0,0 +1,77 @@
+module AQL
+  class Node
+    class Operation
+      # For operation
+      class For < self
+        include Concord.new(:local, :source, :body)
+
+      private
+
+        # Emit node
+        #
+        # @param [Buffer] buffer
+        #
+        # @return [self]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          buffer.append('FOR ')
+          emit_local(buffer)
+          emit_source(buffer)
+          emit_body(buffer)
+        end
+
+        # Emit body
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_body(buffer)
+          body.visit(buffer)
+        end
+
+        # Emit local
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_local(buffer)
+          local.visit(buffer)
+          buffer.append(' IN ')
+        end
+
+        # Emit source
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_source(buffer)
+          local = source
+          if local.kind_of?(Name)
+            local.visit(buffer)
+          else
+            emit_source_parentheses(buffer)
+          end
+          buffer.append(' ')
+        end
+
+        # Emit source in parentheses
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_source_parentheses(buffer)
+          buffer.parentheses do
+            source.visit(buffer)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aql/node/operation/limit.rb

@@ -0,0 +1,42 @@
+module AQL
+  class Node
+    class Operation
+      # Limit operation
+      class Limit < self
+        KEYWORD = :LIMIT
+
+        include Concord.new(:count, :offset)
+
+      private
+
+        # Emit node
+        #
+        # @param [Buffer] buffer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          buffer.append("#{keyword} ")
+          emit_offset(buffer)
+          count.visit(buffer)
+        end
+
+        # Emit offset
+        #
+        # @param [Buffer] buffer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_offset(buffer)
+          local = offset || return
+          local.visit(buffer)
+          buffer.append(', ')
+        end
+      end
+    end
+  end
+end

data/lib/aql/node/operation/nary.rb

@@ -0,0 +1,57 @@
+module AQL
+  class Node
+    class Operation
+      # Base class for nary operations
+      class Nary < self
+        include Concord.new(:body)
+
+      private
+
+        # Emit node
+        #
+        # @param [Buffer] buffer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          buffer.append("#{keyword} ")
+          buffer.delimited(body)
+        end
+
+        # FILTER operation
+        class Sort < self
+          KEYWORD = :SORT
+        end
+
+        # COLLECT operation
+        class Collect < self
+          KEYWORD = :COLLECT
+
+          # COLLECT INTO operation
+          class Into < self
+            include Concord.new(:body, :name)
+
+          private
+
+            # Emit node
+            #
+            # @param [Buffer] buffer
+            #
+            # @return [undefined]
+            #
+            # @api private
+            #
+            def emit(buffer)
+              super
+              buffer.append(' INTO ')
+              name.visit(buffer)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end