query_builder 0.0.1

data/spec/unit/core/clause_spec.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+describe QueryBuilder::Core::Clause do
+
+  let(:klass)   { Class.new(described_class) { attribute :foo, default: :BAR } }
+  let(:clause)  { klass.new(options) }
+  let(:options) { { foo: :FOO } }
+
+  shared_examples :comparable_by_kind_and_attributes do
+
+    context "of the same type and attributes" do
+      let(:other) { klass.new(options) }
+      it { is_expected.to eql true }
+    end # context
+
+    context "with other attributes" do
+      let(:other) { klass.new }
+      it { is_expected.to eql false }
+    end # context
+
+    context "of another kind" do
+      let(:other) { Class.new(klass).new(options) }
+      it { is_expected.to eql false }
+    end # context
+
+  end # end
+
+  shared_examples :comparable_by_kind do
+
+    context "of the same type and attributes" do
+      let(:other) { klass.new(options) }
+      it { is_expected.to eql true }
+    end # context
+
+    context "with other attributes" do
+      let(:other) { klass.new }
+      it { is_expected.to eql true }
+    end # context
+
+    context "of another kind" do
+      let(:other) { Class.new(klass).new(options) }
+      it { is_expected.to eql false }
+    end # context
+
+  end # end
+
+  describe ".type" do
+    subject { klass.type :foo }
+
+    it "sets the class type" do
+      expect { subject }
+        .to change { klass.type }
+        .from(nil)
+        .to :foo
+    end
+
+    it "sets the instance's type" do
+      expect { subject }
+        .to change { klass.new.type }
+        .from(nil)
+        .to :foo
+    end
+  end # describe .type
+
+  describe ".new" do
+    subject { clause }
+
+    it "is immutable" do
+      expect(subject).to be_frozen
+    end
+
+    it "is comparable" do
+      expect(subject).to be_kind_of QueryBuilder::Core::Base
+    end
+  end # describe .new
+
+  describe "#==" do
+    subject { clause == other }
+
+    it_behaves_like :comparable_by_kind_and_attributes
+  end # describe #==
+
+  describe "#eql?" do
+    subject { clause.eql? other }
+
+    it_behaves_like :comparable_by_kind_and_attributes
+  end # describe #eql?
+
+  describe ".unique" do
+    before { klass.unique }
+
+    it_behaves_like :comparable_by_kind do
+      subject { clause == other }
+    end
+
+    it_behaves_like :comparable_by_kind do
+      subject { clause.eql? other }
+    end
+  end # describe .unique
+
+end # describe QueryBuilder::Core::Clause

data/spec/unit/core/statement_spec.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+describe QueryBuilder::Core::Statement do
+
+  let(:klass)      { Class.new(described_class) { attribute :foo } }
+  let(:statement)  { klass.new(attributes) { [bar, baz] } }
+  let(:attributes) { { foo: :FOO } }
+
+  let(:clause) do
+    Class.new(QueryBuilder::Core::Clause) { def to_s; type.to_s; end }
+  end
+
+  let(:bar) { Class.new(clause) { type :bar }.new }
+  let(:baz) { Class.new(clause) { type :baz }.new }
+  let(:qux) { Class.new(clause) { type :qux }.new }
+
+  describe ".new" do
+    subject { statement }
+
+    it "is a node" do
+      expect(subject).to be_kind_of(QueryBuilder::Core::Base)
+    end
+
+    it "is immutable" do
+      expect(subject).to be_frozen
+    end
+  end # describe .new
+
+  describe "#context" do
+    subject { statement.context }
+
+    context "by default" do
+      it { is_expected.to be_nil }
+    end # context
+
+    context "when assigned" do
+      let(:statement) { described_class.new(context: :foo) }
+
+      it { is_expected.to eq(:foo) }
+    end
+  end # describe #context
+
+  describe "#clauses" do
+    subject { statement.clauses }
+
+    context "by default" do
+      let(:statement) { klass.new(attributes) }
+
+      it "returns the empty array" do
+        expect(subject).to eql %w()
+      end
+    end # context
+
+    context "without attributes" do
+      it "is initialized from the block" do
+        expect(subject).to eql %w(bar baz)
+      end
+    end
+
+    context "with an argument" do
+      subject { statement.clauses(:baz) }
+
+      it "selects clauses by type" do
+        expect(subject).to eql %w(baz)
+      end
+    end # context
+  end # describe #clauses
+
+  describe "#<<" do
+
+    context "new clause" do
+      subject { statement << qux }
+
+      it "adds the clause" do
+        expect(subject.clauses).to eql %w(bar baz qux)
+      end
+    end # context
+
+    context "existing clause" do
+      subject { statement << bar }
+
+      it "rewrites the clause" do
+        expect(subject.clauses).to eql %w(baz bar)
+      end
+    end
+  end # describe #<<
+
+end # describe QueryBuilder::Core::Statement

data/spec/unit/cql/operators/cql_composite_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_composite" do
+
+  let(:arguments) { [:cql_composite] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { [:foo, :bar, :baz] }
+    let(:output) { "(foo, bar, baz)" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_composite

data/spec/unit/cql/operators/cql_dec_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_dec" do
+
+  let(:arguments) { [:cql_dec, 4] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :foo }
+    let(:output) { "foo = foo - 4" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_dec

data/spec/unit/cql/operators/cql_element_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_element" do
+
+  let(:arguments) { [:cql_element, :bar] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :foo }
+    let(:output) { "foo['bar']" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_element

data/spec/unit/cql/operators/cql_entries_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_entries" do
+
+  let(:arguments) { [:cql_entries] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :foo }
+    let(:output) { "ENTRIES(foo)" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_entries

data/spec/unit/cql/operators/cql_frozen_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_frozen" do
+
+  let(:arguments) { [:cql_frozen] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :foo }
+    let(:output) { "FROZEN <foo>" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_frozen

data/spec/unit/cql/operators/cql_full_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_full" do
+
+  let(:arguments) { [:cql_full] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :foo }
+    let(:output) { "FULL(foo)" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_full

data/spec/unit/cql/operators/cql_gt_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_gt" do
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:cql_gt, 4] }
+
+    let(:input)  { :foo }
+    let(:output) { "foo > 4" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:cql_gt, :bar] }
+
+    let(:input)  { :foo }
+    let(:output) { "foo > 'bar'" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_gt

data/spec/unit/cql/operators/cql_gte_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_gte" do
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:cql_gte, 4] }
+
+    let(:input)  { :foo }
+    let(:output) { "foo >= 4" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:cql_gte, :bar] }
+
+    let(:input)  { :foo }
+    let(:output) { "foo >= 'bar'" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_gte

data/spec/unit/cql/operators/cql_in_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_in" do
+
+  let(:arguments) { [:cql_in, :bar, :baz] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :foo }
+    let(:output) { "foo IN ('bar', 'baz')" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_in

data/spec/unit/cql/operators/cql_inc_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_inc" do
+
+  let(:arguments) { [:cql_inc, 4] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :foo }
+    let(:output) { "foo = foo + 4" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_inc

data/spec/unit/cql/operators/cql_keys_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_keys" do
+
+  let(:arguments) { [:cql_keys] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :foo }
+    let(:output) { "KEYS(foo)" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_keys

data/spec/unit/cql/operators/cql_list_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe QueryBuilder::CQL::Operators, ".cql_list" do
+
+  let(:arguments) { [:cql_list] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :int }
+    let(:output) { "LIST<int>" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_list

data/spec/unit/cql/operators/cql_literal_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+require "securerandom"
+
+describe QueryBuilder::CQL::Operators, ".cql_literal" do
+
+  let(:arguments) { [:cql_literal] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { nil }
+    let(:output) { "NaN" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :NaN }
+    let(:output) { "NaN" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { "NaN" }
+    let(:output) { "NaN" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :Infinity }
+    let(:output) { "Infinity" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { "Infinity" }
+    let(:output) { "Infinity" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { SecureRandom.uuid }
+    let(:output) { input }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { "0x03" }
+    let(:output) { input }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { 10.1 }
+    let(:output) { "10.1" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { true }
+    let(:output) { "true" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { false }
+    let(:output) { "false" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { :true }
+    let(:output) { "'true'" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { "true" }
+    let(:output) { "'true'" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { "d'oh!" }
+    let(:output) { "'d''oh!'" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { { foo: :bar, baz: "0x03", qux: { quxx: true } } }
+    let(:output) { "{'foo': 'bar', 'baz': 0x03, 'qux': {'quxx': true}}" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { [:foo, :bar, baz: "0x03"] }
+    let(:output) { "['foo', 'bar', {'baz': 0x03}]" }
+  end
+
+end # describe QueryBuilder::CQL::Operators.cql_literal