axiom-sql-generator 0.1.0

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_absolute_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_absolute' do
+  subject { object.visit_axiom_function_numeric_absolute(absolute) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:absolute)        { Attribute::Integer.new(:number).abs                                              }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('ABS ("number")') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_addition_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_addition' do
+  subject { object.visit_axiom_function_numeric_addition(addition) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:addition)        { Attribute::Integer.new(:number).add(1)                                           }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("number" + 1)') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_division_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_division' do
+  subject { object.visit_axiom_function_numeric_division(division) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:division)        { Attribute::Integer.new(:number).divide(1)                                        }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("number" / 1)') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_exponentiation_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_exponentiation' do
+  subject { object.visit_axiom_function_numeric_exponentiation(exponentiation) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:exponentiation)  { Attribute::Integer.new(:number).exponent(1)                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('POWER ("number", 1)') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_modulo_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_modulo' do
+  subject { object.visit_axiom_function_numeric_modulo(modulo) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:modulo)          { Attribute::Integer.new(:number).modulo(1)                                        }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('MOD ("number", 1)') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_multiplication_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_multiplication' do
+  subject { object.visit_axiom_function_numeric_multiplication(multiplication) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:multiplication)  { Attribute::Integer.new(:number).multiply(1)                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("number" * 1)') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_square_root_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_square_root' do
+  subject { object.visit_axiom_function_numeric_square_root(square_root) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:square_root)     { Attribute::Integer.new(:number).square_root                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('SQRT ("number")') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_subtraction_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_subtraction' do
+  subject { object.visit_axiom_function_numeric_subtraction(subtraction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:subtraction)     { Attribute::Integer.new(:number).subtract(1)                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('("number" - 1)') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_unary_minus_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_unary_minus' do
+  subject { object.visit_axiom_function_numeric_unary_minus(unary_minus) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:unary_minus)     { Attribute::Integer.new(:number).unary_minus                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('- ("number")') }
+end

data/spec/unit/axiom/sql/generator/function/numeric/visit_axiom_function_numeric_unary_plus_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_axiom_function_numeric_unary_plus' do
+  subject { object.visit_axiom_function_numeric_unary_plus(unary_plus) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:unary_plus)      { Attribute::Integer.new(:number).unary_plus                                       }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('+ ("number")') }
+end

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_equality_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_equality' do
+  subject { object.visit_axiom_function_predicate_equality(equality) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:object)          { described_class.new                                                                }
+
+  context 'when the right operand is not nil' do
+    let(:equality) { attribute.eq(1) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" = 1') }
+  end
+
+  context 'when the right operand is nil' do
+    let(:equality) { attribute.eq(nil) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" IS NULL') }
+  end
+end

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_exclusion_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_exclusion' do
+  subject { object.visit_axiom_function_predicate_exclusion(exclusion) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:object)          { described_class.new                                                                }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Connective }
+  end
+
+  context 'when right operand is an inclusive Range' do
+    let(:exclusion) { attribute.exclude(1..10) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" NOT BETWEEN 1 AND 10') }
+  end
+
+  context 'when right operand is an exclusive Range' do
+    let(:exclusion) { attribute.exclude(1...10) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('("id" < 1 OR "id" >= 10)') }
+  end
+
+  context 'when right operand is an Array' do
+    let(:exclusion) { attribute.exclude([ 1, 2 ]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" NOT IN (1, 2)') }
+  end
+
+  context 'when right operand is an empty Array' do
+    let(:exclusion) { attribute.exclude([]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('TRUE') }
+  end
+end

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_greater_than_or_equal_to_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_greater_than_or_equal_to' do
+  subject { object.visit_axiom_function_predicate_greater_than_or_equal_to(greater_than_or_equal_to) }
+
+  let(:described_class)          { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:greater_than_or_equal_to) { Attribute::Integer.new(:id).gte(1)                                                 }
+  let(:object)                   { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" >= 1') }
+end

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_greater_than_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_greater_than' do
+  subject { object.visit_axiom_function_predicate_greater_than(greater_than) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:greater_than)    { Attribute::Integer.new(:id).gt(1)                                                  }
+  let(:object)          { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" > 1') }
+end

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_inclusion_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_inclusion' do
+  subject { object.visit_axiom_function_predicate_inclusion(inclusion) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:object)          { described_class.new                                                                }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Connective }
+  end
+
+  context 'when right operand is an inclusive Range' do
+    let(:inclusion) { attribute.include(1..10) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" BETWEEN 1 AND 10') }
+  end
+
+  context 'when right operand is an exclusive Range' do
+    let(:inclusion) { attribute.include(1...10) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('("id" >= 1 AND "id" < 10)') }
+  end
+
+  context 'when right operand is an Array' do
+    let(:inclusion) { attribute.include([ 1, 2 ]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" IN (1, 2)') }
+  end
+
+  context 'when right operand is an empty Array' do
+    let(:inclusion) { attribute.include([]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('FALSE') }
+  end
+end

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_inequality_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_inequality' do
+  subject { object.visit_axiom_function_predicate_inequality(inequality) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:object)          { described_class.new                                                                }
+
+  context 'and the left attribute is optional' do
+    let(:attribute)  { Attribute::Integer.new(:age, :required => false) }
+    let(:inequality) { attribute.ne(1)                                  }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('("age" <> 1 OR "age" IS NULL)') }
+  end
+
+  context 'and the right attribute is optional' do
+    let(:attribute)  { Attribute::Integer.new(:age, :required => false)  }
+    let(:inequality) { Function::Predicate::Inequality.new(1, attribute) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('(1 <> "age" OR "age" IS NULL)') }
+  end
+
+  context 'and the left is a value' do
+    let(:attribute)  { Attribute::Integer.new(:id)                       }
+    let(:inequality) { Function::Predicate::Inequality.new(1, attribute) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('1 <> "id"') }
+  end
+
+  context 'and the right is a value' do
+    let(:attribute)  { Attribute::Integer.new(:id) }
+    let(:inequality) { attribute.ne(1)             }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" <> 1') }
+  end
+
+  context 'and the right is a nil value' do
+    let(:attribute)  { Attribute::Integer.new(:id) }
+    let(:inequality) { attribute.ne(nil)           }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"id" IS NOT NULL') }
+  end
+end

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_less_than_or_equal_to_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_less_than_or_equal_to' do
+  subject { object.visit_axiom_function_predicate_less_than_or_equal_to(less_than_or_equal_to) }
+
+  let(:described_class)       { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:less_than_or_equal_to) { Attribute::Integer.new(:id).lte(1)                                                 }
+  let(:object)                { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" <= 1') }
+end

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_less_than_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_less_than' do
+  subject { object.visit_axiom_function_predicate_less_than(less_than) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:less_than)       { Attribute::Integer.new(:id).lt(1)                                                  }
+  let(:object)          { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" < 1') }
+end

data/spec/unit/axiom/sql/generator/function/proposition/visit_axiom_function_proposition_contradiction_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Proposition, '#visit_axiom_function_proposition_contradiction' do
+  subject { object.visit_axiom_function_proposition_contradiction(contradiction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Proposition } }
+  let(:contradiction)   { Function::Proposition::Contradiction.instance                                        }
+  let(:object)          { described_class.new                                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('FALSE') }
+end

data/spec/unit/axiom/sql/generator/function/proposition/visit_axiom_function_proposition_tautology_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Proposition, '#visit_axiom_function_proposition_tautology' do
+  subject { object.visit_axiom_function_proposition_tautology(tautology) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Proposition } }
+  let(:tautology)       { Function::Proposition::Tautology.instance                                            }
+  let(:object)          { described_class.new                                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('TRUE') }
+end