axiom-arango-adapter 0.0.1

data/spec/unit/axiom/adapter/arango/visitor/class_methods/run_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor, '.run' do
+  let(:object) { described_class }
+
+  let(:relation) { mock('Axiom Node')               }
+  let(:aql_node) { mock('AQL Node')                   }
+  let(:visitor)  { mock('Visitor', :root => aql_node) }
+
+  class Dummy
+  end
+
+  let!(:test_visitor) do
+    aql_node = self.aql_node
+    Class.new(described_class) do
+      handle(Dummy)
+      define_method :root do
+        aql_node
+      end
+    end
+  end
+
+  subject { object.run(Dummy.new) }
+
+  it { should be(aql_node) }
+end

data/spec/unit/axiom/adapter/arango/visitor/for/base/root_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Base, '#root' do
+  subject { object.root }
+
+  let(:relation) { base                                   }
+  let(:object)   { described_class.new(relation, context) }
+
+  expect_aql <<-AQL
+    FOR `base` IN `name`
+      RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/join/local_name_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Join, '#local_name' do
+  let(:object) { described_class.new(node, context) }
+  let(:node)   { mock('Node') }
+  subject { object.local_name }
+
+
+  context 'as root' do
+    let(:context) { nil }
+    it { should eql(AQL.name_node(:local_0)) }
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'as non root' do
+    let(:context) { mock('Context', :depth => 0) }
+    it { should eql(AQL.name_node(:local_1)) }
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/join/right/root_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Join, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.join(base_c) }
+
+  expect_aql <<-AQL
+    FOR `local_0` IN (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      FOR `right` IN (FOR `base` IN `name_c` RETURN {"baz": `base`.`baz`, "bar": `base`.`bar`})
+        FILTER (`local_0`.`bar` == `right`.`bar`)
+        RETURN {"foo": `local_0`.`foo`, "bar": `local_0`.`bar`, "baz": `right`.`baz`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/join/root_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Join, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.join(base_c) }
+
+  expect_aql <<-AQL
+    FOR `local_0` IN (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      FOR `right` IN (FOR `base` IN `name_c` RETURN {"baz": `base`.`baz`, "bar": `base`.`bar`})
+        FILTER (`local_0`.`bar` == `right`.`bar`)
+        RETURN {"foo": `local_0`.`foo`, "bar": `local_0`.`bar`, "baz": `right`.`baz`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/join_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Join, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.join(base_c) }
+
+  expect_aql <<-AQL
+    FOR `local_0` IN (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      FOR `right` IN (FOR `base` IN `name_c` RETURN {"baz": `base`.`baz`, "bar": `base`.`bar`})
+        FILTER (`local_0`.`bar` == `right`.`bar`)
+        RETURN {"foo": `local_0`.`foo`, "bar": `local_0`.`bar`, "baz": `right`.`baz`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/local_name_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary, '#local_name' do
+  subject { object.local_name }
+
+  let(:object) { described_class.new(relation, context) }
+
+  let(:relation) { mock('Relation') }
+  let(:context)  { mock('Context')  }
+
+  it { should eql(AQL.name_node('left')) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/product/right/root_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Product, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.product(base_b) }
+
+  expect_aql <<-AQL
+    FOR `left` IN (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      FOR `right` IN (FOR `base` IN `name_b` RETURN {"baz": `base`.`baz`})
+        RETURN {"foo": `left`.`foo`, "bar": `left`.`bar`, "baz": `right`.`baz`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/product/root_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Product, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.product(base_b) }
+
+  expect_aql <<-AQL
+    FOR `left` IN (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      FOR `right` IN (FOR `base` IN `name_b` RETURN {"baz": `base`.`baz`})
+        RETURN {"foo": `left`.`foo`, "bar": `left`.`bar`, "baz": `right`.`baz`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/product_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Product, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.product(base_b) }
+
+  expect_aql <<-AQL
+    FOR `left` IN (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      FOR `right` IN (FOR `base` IN `name_b` RETURN {"baz": `base`.`baz`})
+        RETURN {"foo": `left`.`foo`, "bar": `left`.`bar`, "baz": `right`.`baz`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/right/join_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Join, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.join(base_c) }
+
+  expect_aql <<-AQL
+    FOR `local_0` IN (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      FOR `right` IN (FOR `base` IN `name_c` RETURN {"baz": `base`.`baz`, "bar": `base`.`bar`})
+        FILTER (`local_0`.`bar` == `right`.`bar`)
+        RETURN {"foo": `local_0`.`foo`, "bar": `local_0`.`bar`, "baz": `right`.`baz`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/right/local_name_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Right, '#local_name' do
+  subject { object.local_name }
+
+  let(:object)   { described_class.new(relation, context) }
+  let(:relation) { mock('Relation') }
+  let(:context)  { mock('Context') }
+
+  it { should eql(AQL.name_node('right')) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/axiom/adapter/arango/visitor/for/binary/right/product_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Binary::Product, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.product(base_b) }
+
+  expect_aql <<-AQL
+    FOR `left` IN (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      FOR `right` IN (FOR `base` IN `name_b` RETURN {"baz": `base`.`baz`})
+        RETURN {"foo": `left`.`foo`, "bar": `left`.`bar`, "baz": `right`.`baz`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/local_name_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For, '#local_name' do
+  subject { object.local_name }
+  let(:object) { class_under_test.new(relation, context) }
+  let(:relation) { mock('Relation') }
+  let(:context)  { mock('Context') }
+
+  let(:local_name) { mock('Local Name') }
+
+  let(:class_under_test) do
+    local_name = self.local_name
+    Class.new(described_class) do
+      const_set('LOCAL_NAME', local_name)
+    end
+  end
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(local_name) }
+end

data/spec/unit/axiom/adapter/arango/visitor/for/root_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For, '#root' do
+  subject { object.root.aql }
+
+  let(:object) { class_under_test.new(relation, context) }
+
+  let(:context) { mock('Context') }
+
+  let(:class_under_test) do
+    local = self.local
+    Class.new(described_class) do
+      define_method :local_name do
+        local
+      end
+    end
+  end
+
+  let(:header)   { Axiom::Relation::Header.coerce([[:id, Integer]]) }
+  let(:operand)  { Axiom::Relation::Base.new(:name_a, header)       }
+  let(:relation) { operand.restrict { |r| r.id.eq(1) }                }
+  let(:local)    { AQL.name_node('local')                             }
+  let(:source)   { Axiom::Adapter::Arango::Visitor.run(operand)     }
+  let(:body)     { AQL.name_node('foo')  }
+
+  it { should eql('FOR `local` IN (FOR `base` IN `name_a` RETURN {"id": `base`.`id`}) RETURN {"id": `local`.`id`}') }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/axiom/adapter/arango/visitor/for/summarization/root_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Summarization, '#root' do
+
+  let(:object) { described_class.new(relation, context) }
+  let(:context) { mock('Context') }
+
+  subject { object.root }
+
+  context 'max' do
+    let(:relation) { base.summarize([:foo]) { |r| r.add(:count, r.bar.max) } }
+
+    expect_aql <<-AQL
+      FOR `summarization` IN
+        (FOR `base` IN `name` RETURN {\"foo\": `base`.`foo`, \"bar\": `base`.`bar`})
+        COLLECT `foo` = `summarization`.`foo` INTO `collect`
+        RETURN {"foo": `foo`, "count": MAX((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`bar` != null) RETURN `aggregate`.`summarization`.`bar`))}
+    AQL
+  end
+
+  context 'min' do
+    let(:relation) { base.summarize([:foo]) { |r| r.add(:count, r.bar.min) } }
+
+    expect_aql <<-AQL
+      FOR `summarization` IN
+        (FOR `base` IN `name` RETURN {\"foo\": `base`.`foo`, \"bar\": `base`.`bar`})
+        COLLECT `foo` = `summarization`.`foo` INTO `collect`
+        RETURN {"foo": `foo`, "count": MIN((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`bar` != null) RETURN `aggregate`.`summarization`.`bar`))}
+    AQL
+  end
+
+  context 'sum' do
+    let(:relation) { base.summarize([:foo]) { |r| r.add(:count, r.bar.sum) } }
+
+    expect_aql <<-AQL
+      FOR `summarization` IN
+        (FOR `base` IN `name` RETURN {\"foo\": `base`.`foo`, \"bar\": `base`.`bar`})
+        COLLECT `foo` = `summarization`.`foo` INTO `collect`
+        RETURN {"foo": `foo`, "count": SUM((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`bar` != null) RETURN `aggregate`.`summarization`.`bar`))}
+    AQL
+  end
+
+  context 'count' do
+    let(:relation) { base.summarize([:bar]) { |r| r.add(:count, r.foo.count) } }
+
+    expect_aql <<-AQL
+      FOR `summarization` IN
+        (FOR `base` IN `name` RETURN {\"foo\": `base`.`foo`, \"bar\": `base`.`bar`})
+        COLLECT `bar` = `summarization`.`bar` INTO `collect`
+        RETURN {"bar": `bar`, "count": LENGTH((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`foo` != null) RETURN `aggregate`.`summarization`.`foo`))}
+    AQL
+  end
+end

data/spec/unit/axiom/adapter/arango/visitor/for/unary/extension/root_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Unary::Extension, '#root' do
+  let(:relation) { base.extend { |r| r.add(:baz, r.bar * 2) }                  }
+
+  subject { object.root }
+
+  expect_aql <<-AQL
+    FOR `extension` IN
+      (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      RETURN MERGE(`extension`, {"baz": (`extension`.`bar` * 2)})
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/unary/extension_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Unary::Extension, '#root' do
+  let(:relation) { base.extend { |r| r.add(:baz, r.bar * 2) }                  }
+
+  subject { object.root }
+
+  expect_aql <<-AQL
+    FOR `extension` IN
+      (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      RETURN MERGE(`extension`, {"baz": (`extension`.`bar` * 2)})
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/unary/limit/root_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Unary::Limit, '#root' do
+  subject { object.root }
+
+  let(:relation)    { base.sort_by { |r| [r.foo.asc, r.bar.asc] }.take(5) }
+
+  expect_aql <<-AQL
+    FOR `limit` IN
+      (FOR `order` IN
+        (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+        SORT `order`.`foo` ASC, `order`.`bar` ASC
+        RETURN {"foo": `order`.`foo`, "bar": `order`.`bar`})
+      LIMIT 0, 5
+      RETURN {"foo": `limit`.`foo`, "bar": `limit`.`bar`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/unary/limit_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Unary::Limit, '#root' do
+  subject { object.root }
+
+  let(:relation)    { base.sort_by { |r| [r.foo.asc, r.bar.asc] }.take(5) }
+
+  expect_aql <<-AQL
+    FOR `limit` IN
+      (FOR `order` IN
+        (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+        SORT `order`.`foo` ASC, `order`.`bar` ASC
+        RETURN {"foo": `order`.`foo`, "bar": `order`.`bar`})
+      LIMIT 0, 5
+      RETURN {"foo": `limit`.`foo`, "bar": `limit`.`bar`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/unary/offset/root_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Unary::Offset, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.sort_by { |r| [r.foo.asc, r.bar.asc] }.drop(5) }
+
+  expect_aql <<-AQL
+    FOR `offset` IN
+      (FOR `order` IN
+        (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+        SORT `order`.`foo` ASC, `order`.`bar` ASC
+        RETURN {"foo": `order`.`foo`, "bar": `order`.`bar`})
+      LIMIT 5, 2147483647
+      RETURN {"foo": `offset`.`foo`, "bar": `offset`.`bar`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/unary/offset_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Unary::Offset, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.sort_by { |r| [r.foo.asc, r.bar.asc] }.drop(5) }
+
+  expect_aql <<-AQL
+    FOR `offset` IN
+      (FOR `order` IN
+        (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+        SORT `order`.`foo` ASC, `order`.`bar` ASC
+        RETURN {"foo": `order`.`foo`, "bar": `order`.`bar`})
+      LIMIT 5, 2147483647
+      RETURN {"foo": `offset`.`foo`, "bar": `offset`.`bar`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/unary/order/root_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Unary::Order, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.sort_by { |r| [r.foo.asc, r.bar.asc] } }
+
+  expect_aql <<-AQL
+    FOR `order` IN
+      (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      SORT `order`.`foo` ASC, `order`.`bar` ASC
+      RETURN {"foo": `order`.`foo`, "bar": `order`.`bar`}
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/for/unary/order_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::For::Unary::Order, '#root' do
+  subject { object.root }
+
+  let(:relation) { base.sort_by { |r| [r.foo.asc, r.bar.asc] } }
+
+  expect_aql <<-AQL
+    FOR `order` IN
+      (FOR `base` IN `name` RETURN {"foo": `base`.`foo`, "bar": `base`.`bar`})
+      SORT `order`.`foo` ASC, `order`.`bar` ASC
+      RETURN {"foo": `order`.`foo`, "bar": `order`.`bar`}
+  AQL
+end