aql 0.0.1

data/spec/unit/aql/buffer/class_methods/utf8_encode_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe AQL::Buffer, '.utf8_encode' do
+  let(:object) { described_class }
+
+  unless defined?(Encoding)
+    before do
+      pending "No support for encodings under #{Devtools.rvm}"
+    end
+  end
+
+  subject { object.utf8_encode(input) }
+
+  let(:input)  { mock('Input') }
+  let(:output) { mock('Output') }
+
+  it 'should modify input encoding' do
+    input.should_receive(:encode).with(Encoding::UTF_8).and_return(output)
+    should be(output)
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe AQL::Buffer, '#content' do
+  let(:object) { described_class.new }
+
+  subject { object.content }
+
+  context 'when empty' do
+
+    it { should eql('')   }
+
+    its(:frozen?) { should be(true) }
+
+  end
+
+  context 'when something was emitted' do
+    before do
+      object.append('foo').append('bar')
+    end
+
+    it { should eql('foobar')   }
+    its(:frozen?) { should be(true) }
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe AQL::Buffer, '#delimited' do
+  let(:object) { described_class.new }
+
+  subject { object.delimited(nodes) }
+
+  context 'with empty nodes' do
+    let(:nodes) { [] }
+
+    its(:content) { should eql('') }
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'with one argument' do
+    let(:nodes) { [AQL::Node::Literal.build(1)] }
+
+    its(:content) { should eql('1') }
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'with multiple argments' do
+    let(:nodes) { [AQL::Node::Literal.build(1), AQL::Node::Literal.build(2)] }
+
+    its(:content) { should eql('1, 2') }
+
+    it_should_behave_like 'a command method'
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe AQL::Buffer, '#parentheses' do
+  let(:object) { described_class.new }
+
+  subject { object.parentheses(*arguments, &block) }
+
+  let(:block) { proc { object.append('foo') } }
+
+  context 'without arguments' do
+    let(:arguments) { [] }
+
+    its(:content) { should eql('(foo)') }
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'with first argument' do
+    let(:arguments) { ['first '] }
+
+    its(:content) { should eql('first foo)') }
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'with first and second argument' do
+    let(:arguments) { ['first ', ' second'] }
+
+    its(:content) { should eql('first foo second') }
+
+    it_should_behave_like 'a command method'
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe AQL::Buffer, '.wrap_delimited' do
+  let(:object) { described_class.new }
+
+  subject { object.wrap_delimited(open, nodes, close) }
+
+  let(:open) { '[' }
+  let(:close) { ']' }
+
+  context 'without nodes' do
+    let(:nodes) { [] }
+
+    its(:content) { should eql('[]') }
+
+    it_should_behave_like 'a command method'
+  end
+
+  class Node
+    include Concord.new(:name)
+
+    def visit(buffer)
+      buffer.append(name)
+    end
+  end
+
+  context 'with one node' do
+    let(:nodes) { [Node.new('A')] }
+
+    its(:content) { should eql('[A]') }
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'with two nodes' do
+    let(:nodes) { [Node.new('A'), Node.new('B')] }
+
+    its(:content) { should eql('[A, B]') }
+
+    it_should_behave_like 'a command method'
+  end
+end

data/spec/unit/aql/class_methods/literal_node_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe AQL, '.literal_node' do
+  let(:object) { described_class }
+
+  subject { object.literal_node(value) }
+
+  let(:value)  { mock('Value') }
+  let(:result) { mock('Result') }
+
+  it 'should forward to AQL::Node::Literal.build' do
+    AQL::Node::Literal.should_receive(:build).with(value).and_return(result)
+    should be(result)
+  end
+end

data/spec/unit/aql/class_methods/name_node_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe AQL, '.name_ndoe' do
+  let(:object) { described_class }
+
+  subject { object.name_node(name) }
+
+  context 'when name is a symbol' do
+    let(:name) { :foo }
+
+    it { should eql(AQL::Node::Name.new('foo')) }
+  end
+
+  context 'when name is a string' do
+    let(:name) { 'foo' }
+
+    it { should eql(AQL::Node::Name.new('foo')) }
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe AQL::Node::Attribute, '#aql' do
+  let(:object) { described_class.new(target, name) }
+
+  let(:name)   { AQL::Node::Name.new(attribute_name) }
+  let(:target) { AQL::Node::Name.new(target_name)    }
+
+  context 'with regular names' do
+    let(:target_name) { 'foo' }
+    let(:attribute_name) { 'bar' }
+
+    expect_aql('`foo`.`bar`')
+  end
+
+  context 'with keyword names' do
+    let(:target_name) { 'sort' }
+    let(:attribute_name) { 'filter' }
+
+    expect_aql('`sort`.`filter`')
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe AQL::Node::Block, '#aql' do
+  let(:object) { described_class.new(elements) }
+
+  context 'with single element' do
+    let(:elements) do 
+      [AQL::Node::Operation::Unary::Filter.new(AQL::Node::Literal.build(true))]
+    end
+
+    let(:name)         { 'foo bar' }
+
+    expect_aql('FILTER true')
+  end
+
+  context 'with multiple elements' do
+    let(:elements) do 
+      [
+        AQL::Node::Operation::Unary::Filter.new(AQL::Node::Literal.build(true)),
+        AQL::Node::Operation::Unary::Return.new(AQL::Node::Literal.build(false))
+      ]
+    end
+
+    let(:name)         { 'foo bar' }
+
+    expect_aql('FILTER true RETURN false')
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe AQL::Node::Call, '#aql' do
+  let(:object) { described_class.new(name, arguments) }
+
+  let(:name) { 'FOO' }
+
+  context 'without arguments' do
+    let(:arguments) { [] }
+
+    expect_aql <<-AQL
+      FOO()
+    AQL
+  end
+
+  context 'with single argument' do
+    let(:arguments) { [AQL::Node::Literal.build(1)] }
+
+    expect_aql <<-AQL
+      FOO(1)
+    AQL
+  end
+
+  context 'with multiple arguments' do
+    let(:arguments) { [AQL::Node::Literal.build(1), AQL::Node::Literal.build(2)] }
+
+    expect_aql <<-AQL
+      FOO(1, 2)
+    AQL
+  end
+
+  context 'with FOR statement as argument' do
+    let(:arguments) { [AQL::Node::Operation::For.new(AQL::Node::Name.new('left'), AQL::Node::Name.new('right'), AQL::Node::Name.new('body'))] }
+
+    expect_aql <<-AQL
+      FOO((FOR `left` IN `right` `body`))
+    AQL
+  end
+end

data/spec/unit/aql/node/literal/class_methods/build_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal, '.build' do
+  let(:object) { described_class }
+
+  subject { object.build(input) }
+
+  context 'string' do
+    let(:input) { 'foo' }
+    it { should eql(AQL::Node::Literal::Primitive::String.new('foo')) }
+  end
+
+  context 'number' do
+
+    context 'fixnum' do
+      let(:input) { 1 }
+      it { should eql(AQL::Node::Literal::Primitive::Number.new(1)) }
+    end
+
+    context 'float' do
+      let(:input) { 1.0 }
+      it { should eql(AQL::Node::Literal::Primitive::Number.new(1.0)) }
+    end
+
+  end
+
+  context 'singleton' do
+
+    context 'nil' do
+      let(:input) { nil }
+      it { should be(AQL::Node::Literal::Singleton::NULL) }
+    end
+
+    context 'true' do
+      let(:input) { true }
+      it { should be(AQL::Node::Literal::Singleton::TRUE) }
+    end
+
+    context 'false' do
+      let(:input) { false }
+      it { should be(AQL::Node::Literal::Singleton::FALSE) }
+    end
+
+  end
+
+  context 'array' do
+
+    context 'empty' do
+      let(:input) { [] }
+      it { should eql(AQL::Node::Literal::Composed::List.new([])) }
+    end
+
+    context 'plain' do
+      context 'homogen' do
+        let(:input) { [1, 2] }
+        it do 
+          should eql(AQL::Node::Literal::Composed::List.new([
+            AQL::Node::Literal::Primitive::Number.new(1),
+            AQL::Node::Literal::Primitive::Number.new(2)
+          ]))
+        end
+      end
+
+      context 'heterogen' do
+        let(:input) { [1, false] }
+
+        specify do 
+          should eql(AQL::Node::Literal::Composed::List.new([
+            AQL::Node::Literal::Primitive::Number.new(1),
+            AQL::Node::Literal::Singleton::FALSE
+          ]))
+        end
+      end
+    end
+
+    context 'nested' do
+      let(:input) { [[1]] }
+
+      specify do
+        should eql(AQL::Node::Literal::Composed::List.new([
+          AQL::Node::Literal::Composed::List.new([
+            AQL::Node::Literal::Primitive::Number.new(1)
+          ])
+        ]))
+      end
+    end
+  end
+
+  context 'hash' do
+
+    context 'empty' do
+      let(:input) { {} }
+
+      it { should eql(AQL::Node::Literal::Composed::Document.new([])) }
+    end
+
+    context 'plain' do
+      let(:input) { { 1 => 2 } }
+
+      specify do 
+        should eql(AQL::Node::Literal::Composed::Document.new([
+          AQL::Node::Literal::Composed::Document::Attribute.new(
+            AQL::Node::Literal::Primitive::Number.new(1),
+            AQL::Node::Literal::Primitive::Number.new(2)
+          )
+        ]))
+      end
+    end
+
+    context 'nested' do
+      let(:input) { { 0 => { 1 => 2 } } }
+
+      specify do 
+        inner = AQL::Node::Literal::Composed::Document.new([
+          AQL::Node::Literal::Composed::Document::Attribute.new(
+            AQL::Node::Literal::Primitive::Number.new(1),
+            AQL::Node::Literal::Primitive::Number.new(2)
+          )
+        ])
+
+        should eql(AQL::Node::Literal::Composed::Document.new([
+          AQL::Node::Literal::Composed::Document::Attribute.new(
+            AQL::Node::Literal::Primitive::Number.new(0),
+            inner
+          )
+        ]))
+      end
+    end
+  end
+
+  context 'unhandled' do
+    let(:input) { :foo }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(RuntimeError, 'No support for literal Symbol')
+    end
+  end
+
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal, '.construct' do
+  let(:class_under_test) do
+    Class.new(described_class) do
+      include Concord.new(:input)
+    end
+  end
+
+  let(:input)  { mock('Input')    }
+  let(:object) { class_under_test }
+
+  subject { object.construct(input) }
+
+  it { should eql(class_under_test.new(input)) }
+end

data/spec/unit/aql/node/literal/class_methods/handle_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe AQL::Node::Literal, '#handle' do
+  Dummy = Class.new do
+    include Equalizer.new
+  end
+
+  let(:object) { described_class }
+
+  subject { object.build(Dummy.new) }
+
+  let(:input) { Dummy.new }
+
+  let(:class_under_test) do
+    Class.new(described_class) do
+      include Concord.new(:object)
+      handle(Dummy)
+    end
+  end
+
+  it { should eql(class_under_test.new(input)) }
+end