aql 0.0.1

data/spec/unit/aql/node/literal/composed/document/aql_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Composed::Document, '#aql' do
+  let(:object) { AQL::Node::Literal.build(input) }
+
+  if RUBY_VERSION < '1.9'
+    before do
+      pending 'Test for ordered hashes, ruby 1.8 has unordered ones'
+    end
+  end
+
+  examples = {
+    {}                    => '{}',
+    { 'name' => 'Peter' } => '{"name": "Peter"}',
+    { 
+      'name'     => 'John', 
+      'likes'    => %w(Swimming Skiing),
+      'address'  => {
+        'street' => 'Cucumber lane',
+        'zip'    => '94242'
+      }
+    } => '{"name": "John", "likes": ["Swimming", "Skiing"], "address": {"street": "Cucumber lane", "zip": "94242"}}'
+  }
+
+  examples.each do |input, expectation|
+    context "with #{input.inspect} as input" do
+      let(:input)        { input       }
+
+      expect_aql(expectation)
+    end
+  end
+end

data/spec/unit/aql/node/literal/composed/document/attribute/aql_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Composed::Document::Attribute, '#aql' do
+  class Node
+    include Concord.new(:token)
+
+    def visit(buffer)
+      buffer.append(token)
+    end
+  end
+
+  let(:object) { described_class.new(Node.new('foo'), Node.new('bar')) }
+
+  expect_aql('foo: bar')
+end

data/spec/unit/aql/node/literal/composed/document/class_methods/construct_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Composed::Document, '.construct' do
+  let(:object) { described_class }
+  let(:subject) { object.construct(input) }
+
+  context 'without attributes' do
+    let(:input) { {} }
+
+    it { should eql(described_class.new([])) }
+  end
+
+  context 'with attributes' do
+    let(:input) { { 1 => 2 } }
+
+    let(:attribute) do 
+      AQL::Node::Literal::Composed::Document::Attribute.new(
+        AQL::Node::Literal.build(1), AQL::Node::Literal.build(2)
+      )
+    end
+
+    it { should eql(described_class.new([attribute])) }
+  end
+end

data/spec/unit/aql/node/literal/composed/list/aql_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Composed::List, '#aql' do
+  let(:object) { AQL::Node::Literal.build(input) }
+
+  examples = {
+    []                                        => '[]',
+    [1, 2, 3]                                 => '[1, 2, 3]',
+    [-99, "yikes!", [ true, [ "no"], []], 1 ] => '[-99, "yikes!", [true, ["no"], []], 1]',
+    [["fox", "marshal"]]                      => '[["fox", "marshal"]]',
+    [nil]                                     => '[null]'
+  }
+
+  examples.each do |input, expectation|
+    context "with #{input.inspect} as input" do
+      let(:input) { input }
+      expect_aql(expectation)
+    end
+  end
+end

data/spec/unit/aql/node/literal/composed/list/class_methods/construct_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Composed::List, '.constant' do
+  let(:object) { described_class }
+
+  subject { object.construct(input) }
+
+  context 'with empty input' do
+    let(:input) { [] }
+
+    it { should eql(described_class.new([])) }
+  end
+
+  context 'with scalar values as input' do
+    let(:input) { [1, 2] }
+
+    it 'should return correct ast' do
+      should eql(described_class.new([
+        AQL::Node::Literal::Primitive::Number.new(1),
+        AQL::Node::Literal::Primitive::Number.new(2)
+      ]))
+    end
+
+  end
+
+  context 'with nested scalar values as input' do
+    let(:input) { [1, [2] ] }
+
+    it 'should return correct ast' do
+      should eql(described_class.new([
+        AQL::Node::Literal::Primitive::Number.new(1),
+        AQL::Node::Literal::Composed::List.construct([2])
+      ]))
+    end
+  end
+
+end

data/spec/unit/aql/node/literal/primitive/number/aql_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Primitive::Number, '#aql' do
+  let(:object) { described_class.new(number) }
+
+  examples = {
+    1          => '1',
+    42         => '42',
+    -1         => '-1',
+    -42        => '-42',
+    1.23       => '1.23',
+    -99.99     => '-99.99',
+    0.1        => '0.1',
+    -4.87e103  => '-4.87e+103'
+  }
+
+  examples.each do |number, expectation|
+    context "with #{number.inspect} as input" do
+      let(:number) { number }
+      expect_aql(expectation)
+    end
+  end
+end

data/spec/unit/aql/node/literal/primitive/string/aql_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Primitive::String, '#aql' do
+  let(:object) { described_class.new(string) }
+
+  examples = {
+    ''                                    => '""',
+    'yikes!'                              => '"yikes!"',
+    'this is a "quoted" word'             => '"this is a \"quoted\" word"',
+    'this is a longer string.'            => '"this is a longer string."',
+    'the path separator on Windows is \\' => '"the path separator on Windows is \\\\"',
+    "some newlines \n"                    => '"some newlines \n"'
+  }
+
+  examples.each do |string, expectation|
+    context "with #{string.inspect} as input" do
+      let(:string) { string }
+      expect_aql(expectation)
+    end
+  end
+end

data/spec/unit/aql/node/literal/singleton/aql_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Singleton do
+
+  let(:class_under_test) do
+    Class.new(described_class) do
+      public_class_method :new
+    end
+  end
+
+  let(:object) { class_under_test.new('content') }
+
+  expect_aql('content')
+end

data/spec/unit/aql/node/literal/singleton/class_methods/construct_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal::Singleton, '.construct' do
+  let(:object) { described_class }
+  subject { object.construct(input) }
+
+  context 'with false as input' do
+    let(:input) { false }
+    it { should be(AQL::Node::Literal::Singleton::FALSE) }
+  end
+
+  context 'with true as input' do
+    let(:input) { true }
+    it { should be(AQL::Node::Literal::Singleton::TRUE) }
+  end
+
+  context 'with nil as input' do
+    let(:input) { nil }
+    it { should be(AQL::Node::Literal::Singleton::NULL) }
+  end
+
+  context 'with anything else' do
+    let(:input) { :foo }
+
+    it 'should raise error' do
+      expected = RUBY_VERSION < '1.9' ? IndexError : KeyError
+      expect { subject }.to raise_error(expected)
+    end
+  end
+end

data/spec/unit/aql/node/name/aql_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe AQL::Node::Name, '#aql' do
+  let(:object) { described_class.new(name) }
+
+  context 'with non keyword name' do
+    context 'not containing whitespace' do
+      let(:name)         { 'foo' }
+      expect_aql('`foo`')
+    end
+
+    context 'not containing' do
+      let(:name)         { 'foo bar' }
+      expect_aql('`foo bar`')
+    end
+  end
+
+  context 'with keyword name' do
+    AQL::KEYWORDS.each do |keyword|
+      context keyword do
+        context 'uppercase' do
+          let(:name) { keyword }
+          expect_aql(%Q(`#{keyword}`))
+        end
+
+        context 'lowercased' do
+          let(:name) { keyword.downcase }
+          expect_aql(%Q(`#{keyword.downcase}`))
+        end
+      end
+    end
+  end
+end

data/spec/unit/aql/node/null/aql_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe AQL::Node::NULL, '#aql' do
+  let(:object) { described_class }
+
+  expect_aql('')
+end

data/spec/unit/aql/node/operation/binary/let/aql_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::Binary::Let, '#aql' do
+
+  let(:left)  { AQL::Node::Name.new('foo') }
+  let(:right) { AQL::Node::Literal.build('bar') }
+  let(:object) { described_class.new(left, right) }
+
+  expect_aql('LET `foo` = "bar"')
+end

data/spec/unit/aql/node/operation/for/aql_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::For, '#aql' do
+  let(:left)  { AQL::Node::Name.new('left')  }
+  let(:body)  { AQL::Node::Name.new('body')  }
+
+  let(:object) { described_class.new(left, right, body) }
+
+  context 'when right is a name' do
+    let(:right) { AQL::Node::Name.new('right') }
+    expect_aql('FOR `left` IN `right` `body`')
+  end
+
+  context 'when right is anything else' do
+    let(:right) { AQL::Node::Literal.build([1, 2, 3]) }
+    expect_aql('FOR `left` IN ([1, 2, 3]) `body`')
+  end
+end

data/spec/unit/aql/node/operation/keyword_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation, '#keyword' do
+  let(:class_under_test) do
+    Class.new(described_class) do
+      const_set(:KEYWORD, 'KEYWORD')
+      public :keyword
+    end
+  end
+
+  subject { object.keyword }
+
+  let(:object) { class_under_test.new  }
+
+  it { should eql('KEYWORD') }
+end

data/spec/unit/aql/node/operation/limit/aql_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::Limit, '#aql' do
+  let(:object) { described_class.new(count, offset) }
+
+  context 'without offset' do
+    let(:count)  { AQL::Node::Literal.build(10) }
+    let(:offset) { nil }
+
+    expect_aql('LIMIT 10')
+  end
+
+  context 'with offset' do
+    let(:count)  { AQL::Node::Literal.build(10) }
+    let(:offset) { AQL::Node::Literal.build(5) }
+
+    expect_aql('LIMIT 5, 10')
+  end
+end

data/spec/unit/aql/node/operation/nary/aql_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::Nary, '#aql' do
+  let(:class_under_test) do
+    Class.new(described_class) do
+      const_set(:KEYWORD, 'KEYWORD')
+    end
+  end
+
+  let(:foo)          { AQL::Node::Name.new('foo') }
+  let(:bar)          { AQL::Node::Name.new('bar') }
+
+  let(:object)       { class_under_test.new([foo, bar]) }
+
+  expect_aql('KEYWORD `foo`, `bar`')
+end

data/spec/unit/aql/node/operation/nary/collect/into/aql_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::Nary::Collect::Into, '#aql' do
+
+  let(:object) { described_class.new(body, name) }
+
+  let(:body) { [AQL.name_node('foo'), AQL.name_node('bar')] }
+  let(:name) { AQL.name_node('baz') }
+
+  expect_aql('COLLECT `foo`, `bar` INTO `baz`')
+end

data/spec/unit/aql/node/operation/nary/sort/aql_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::Nary::Sort, '#aql' do
+
+  let(:object) { described_class.new(directions) }
+
+  let(:foo) { AQL::Node::Name.new('foo') }
+  let(:bar) { AQL::Node::Name.new('bar') }
+
+  let(:direction_a) { AQL::Node::Operation::Unary::Direction::Ascending.new(foo) }
+  let(:direction_b) { AQL::Node::Operation::Unary::Direction::Descending.new(bar) }
+
+  context 'one direction' do
+    let(:directions) { [direction_a] }
+    expect_aql('SORT `foo` ASC')
+  end
+
+  context 'two directions' do
+    let(:directions) { [direction_a, direction_b] }
+    expect_aql('SORT `foo` ASC, `bar` DESC')
+  end
+end

data/spec/unit/aql/node/operation/unary/aql_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::Unary, '#aql' do
+  let(:class_under_test) do
+    Class.new(described_class) do
+      const_set('KEYWORD', 'KEYWORD')
+    end
+  end
+
+  let(:object) { class_under_test.new(AQL::Node::Literal.build(1)) }
+  expect_aql('KEYWORD 1')
+end

data/spec/unit/aql/node/operation/unary/direction/aql_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::Unary::Direction, '#aql' do
+  let(:class_under_test) do
+    Class.new(described_class) do
+      const_set(:KEYWORD, 'KEYWORD')
+    end
+  end
+
+  let(:foo)          { AQL::Node::Name.new('foo') }
+  let(:object)       { class_under_test.new(foo)  }
+
+  expect_aql('`foo` KEYWORD')
+end

data/spec/unit/aql/node/operation/unary/filter/aql_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe AQL::Node::Operation::Unary::Filter, '#aql' do
+  let(:object) { described_class.new(expression) }
+
+  context 'with constant binary expression' do
+    let(:expression)   { AQL::Node::Literal.build(true) }
+
+    expect_aql('FILTER true')
+  end
+
+  context 'with binary expression' do
+    let(:expression) do
+      foo = AQL::Node::Name.new('foo')
+      AQL::Node::Operator::Binary::LessThan.new(foo, AQL::Node::Literal.build(9))
+    end
+
+    expect_aql('FILTER (`foo` < 9)')
+  end
+end