aql 0.0.1

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

@@ -0,0 +1,75 @@
+module AQL
+  class Node
+    class Operation
+      # Base class for unary operations
+      class Unary < self
+        include Concord.new(:expression)
+
+      private
+
+        # Emit node
+        #
+        # @param [Buffer] buffer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          buffer.append("#{keyword} ")
+          expression.visit(buffer)
+        end
+
+        # Return keyword
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        #
+        def keyword
+          self.class::KEYWORD
+        end
+
+        # Filter operation
+        class Filter < self
+          KEYWORD = :FILTER
+        end
+
+        # Return operation
+        class Return < self
+          KEYWORD = :RETURN
+        end
+
+        # Abstract base class for sort orders
+        class Direction < self
+
+        private
+
+          # Emit node
+          #
+          # @param [Buffer] buffer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit(buffer)
+            expression.visit(buffer)
+            buffer.append(" #{keyword}")
+          end
+
+          # Asecnding sort direction
+          class Ascending < self
+            KEYWORD = :ASC
+          end
+
+          # Descending sort direction
+          class Descending < self
+            KEYWORD = :DESC
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aql/node/operator.rb

@@ -0,0 +1,20 @@
+module AQL
+  class Node
+    # Base class for operators
+    class Operator < self
+
+    private
+
+      # Return operator symbol
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def operator
+        self.class::SYMBOL
+      end
+
+    end
+  end
+end

data/lib/aql/node/operator/assignment.rb

@@ -0,0 +1,28 @@
+module AQL
+  class Node
+    class Operator
+      # Assignment operator
+      class Assignment < self
+        include Concord.new(:name, :value)
+        SYMBOL = :'='
+
+      private
+
+        # Emit into buffer
+        #
+        # @param [Buffer] buffer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          name.visit(buffer)
+          buffer.append(" #{SYMBOL} ")
+          value.visit(buffer)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,92 @@
+module AQL
+  class Node
+    class Operator
+      # Base class for binary operators
+      class Binary < self
+        include Concord.new(:left, :right)
+
+      private
+
+        # Emit node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          buffer.binary(left, operator, right)
+        end
+
+        # Binary equality operator
+        class Equality < self
+          SYMBOL = :==
+        end
+
+        # Binary inequality operator
+        class Inequality < self
+          SYMBOL = :'!='
+        end
+
+        # Binary or operator
+        class Or < self
+          SYMBOL = :'||'
+        end
+
+        # Binary and operator
+        class And < self
+          SYMBOL = :'&&'
+        end
+
+        # Binary in operator
+        class In < self
+          SYMBOL = :'IN'
+        end
+
+        # Binary less than operator
+        class LessThan < self
+          SYMBOL = :'<'
+        end
+
+        # Binary less than or equal to operator
+        class LessThanOrEqualTo < self
+          SYMBOL = :'<='
+        end
+
+        # Binary greater than operator
+        class GreaterThan < self
+          SYMBOL = :'>'
+        end
+
+        # Binary greater than or equal to operator
+        class GreaterThanOrEqualTo < self
+          SYMBOL = :'>='
+        end
+
+        # Binary addition operator
+        class Addition < self
+          SYMBOL = :+
+        end
+
+        # Binary subtraction operator
+        class Subtraction < self
+          SYMBOL = :-
+        end
+
+        # Binary multiplication operator
+        class Multiplication < self
+          SYMBOL = :*
+        end
+
+        # Binary division operator
+        class Division < self
+          SYMBOL = :/
+        end
+
+        # Binary modulo operator
+        class Modulo < self
+          SYMBOL = :%
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module AQL
+  class Node
+    class Operator
+      # Base class for n-ary operators
+      class Nary < self
+        include Concord.new(:body)
+
+      private
+
+        # Emit node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          local = body
+          if local.length == 1
+            local.first.visit(buffer)
+            return
+          end
+          emit_body(buffer)
+        end
+
+        # Emit body
+        #
+        # @rteturn [undefined]
+        #
+        # @api private
+        #
+        def emit_body(buffer)
+          buffer.parentheses do
+            buffer.delimited(body, " #{self.class::SYMBOL} ")
+          end
+        end
+
+        # Nary and operator
+        #
+        # Only present to ease generation of join filters.
+        #
+        class And < self
+          SYMBOL = :'&&'
+        end
+
+      end
+    end
+  end
+end

data/lib/aql/node/operator/ternary.rb

@@ -0,0 +1,30 @@
+module AQL
+  class Node
+    class Operator
+      # Ternary operator
+      class Ternary < self
+        include Concord.new(:condition, :left, :right)
+
+        SYMBOL = :'?'
+
+      private
+
+        # Emit node
+        #
+        # @param [Buffer] buffer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          condition.visit(buffer)
+          buffer.append(" #{operator} ")
+          left.visit(buffer)
+          buffer.append(' : ')
+          right.visit(buffer)
+        end
+      end
+    end
+  end
+end

data/lib/aql/node/operator/unary.rb

@@ -0,0 +1,39 @@
+module AQL
+  class Node
+    class Operator
+      # Base class for unary operators
+      class Unary < self
+        include Concord.new(:target)
+
+      private
+
+        # Emit node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit(buffer)
+          buffer.append(operator)
+          target.visit(buffer)
+        end
+
+        # Unary negation operator
+        class Negation < self
+          SYMBOL = :'!'
+        end
+
+        # Unary plus operator
+        class Plus < self
+          SYMBOL = :+
+        end
+
+        # Unary minus operator
+        class Minus < self
+          SYMBOL = :-
+        end
+
+      end
+    end
+  end
+end

data/spec/shared/aql_behavior.rb

@@ -0,0 +1,7 @@
+shared_examples_for 'Node#aql' do
+  subject { object.aql }
+
+  it { should eql(expected_aql) }
+  its(:frozen?) { should be(true) }
+  it_should_behave_like 'an idempotent method'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'devtools'
+require 'aql'
+require 'rspec'
+
+Devtools.init_spec_helper
+
+RSpec.configure do |config|
+  config.extend(AQLHelper)
+end

data/spec/support/aql_helper.rb

@@ -0,0 +1,12 @@
+module AQLHelper
+  def compress_aql(string)
+    string.gsub(/^[ ]*/, '').split("\n").join(' ')
+  end
+
+  def expect_aql(string)
+    expected_aql = compress_aql(string)
+    subject { object.aql }
+    it_should_behave_like 'an idempotent method'
+    it { should eql(expected_aql) }
+  end
+end

data/spec/unit/aql/buffer/append_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe AQL::Buffer, '#append' do
+  unless defined?(Encoding)
+    before do
+      pending "No support for encodings under #{Devtools.rvm}"
+    end
+  end
+
+  let(:object) { described_class.new    }
+  subject      { object.append(content) }
+  let(:utf8)   { Encoding::UTF_8        }
+
+  this_spec = 'AQL::Bufffer#append'
+
+  shared_examples_for this_spec do
+    it 'should append content to buffer' do
+      expect { subject }.to change { object.content }.from('').to(expected_content)
+    end
+
+    it 'should return utf-8 encoded content' do
+      subject.content.encoding.should be(utf8)
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'ascii encoded content' do
+    let(:content)          { 'foo' }
+    let(:expected_content) { 'foo'.encode('utf-8') }
+
+    it_should_behave_like this_spec
+  end
+
+  context 'utf-8 encoded content' do
+    let(:content)          { "\xC3\xBC".force_encoding(utf8) }
+    let(:expected_content) { content.dup                     }
+
+    it_should_behave_like this_spec
+  end
+
+  context 'with non utf-8 encodable content' do
+    let(:content)          { "\xC3\x28".force_encoding('binary') }
+
+    let(:expected_message) do
+      case Devtools.rvm_name
+      when 'rbx'
+        '"\xC3" to UTF-8 in conversion from ASCII-8BIT to UTF-8'
+      else
+        '"\xC3" from ASCII-8BIT to UTF-8'
+      end
+    end
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(Encoding::UndefinedConversionError, expected_message)
+    end
+  end
+
+end

data/spec/unit/aql/buffer/binary_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe AQL::Buffer, '#binary' do
+  subject { object.binary(left, operator, right) }
+
+  let(:object)   { described_class.new }
+  let(:left)     { Node.new('left')  }
+  let(:right)    { Node.new('right') }
+  let(:operator) { :operator           }
+
+  class Node
+    include Concord.new(:name)
+
+    def visit(buffer)
+      buffer.append(name)
+    end
+  end
+
+  its(:content) { should eql('(left operator right)') }
+
+  it_should_behave_like 'a command method'
+end