veritas-sql-generator 0.0.3 → 0.0.4

data/spec/unit/veritas/base_relation/name_spec.rb

@@ -1,45 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe BaseRelation, '#name' do
-  subject { object.name }
-
-  let(:header) { [ [ :id, Integer ] ]                    }
-  let(:body)   { [ [ 1 ] ].each                          }
-  let(:object) { described_class.new(name, header, body) }
-
-  context 'when name is a frozen String' do
-    let(:name) { 'users'.freeze }
-
-    it_should_behave_like 'an idempotent method'
-
-    it { should equal(name) }
-
-    it { should be_frozen }
-  end
-
-  context 'when name is a String' do
-    let(:name) { 'users' }
-
-    it_should_behave_like 'an idempotent method'
-
-    it { should_not equal(name) }
-
-    it { should eql(name) }
-
-    it { should be_frozen }
-  end
-
-  context 'when name responds to #to_s' do
-    let(:name) { :users }
-
-    it_should_behave_like 'an idempotent method'
-
-    it { should_not equal(name) }
-
-    it { should eql(name.to_s) }
-
-    it { should be_frozen }
-  end
-end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_connective_conjunction_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe SQL::Generator::Logic, '#visit_veritas_logic_connective_conjunction' do
-  subject { object.visit_veritas_logic_connective_conjunction(conjunction) }
-
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:attribute)       { Attribute::Integer.new(:id)                                          }
-  let(:conjunction)     { attribute.eq(1).and(attribute.ne(2))                                 }
-  let(:object)          { described_class.new                                                  }
-
-  it_should_behave_like 'a generated SQL expression'
-
-  its(:to_s) { should eql('("id" = 1 AND "id" <> 2)') }
-end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_connective_disjunction_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe SQL::Generator::Logic, '#visit_veritas_logic_connective_disjunction' do
-  subject { object.visit_veritas_logic_connective_disjunction(disjunction) }
-
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:attribute)       { Attribute::Integer.new(:id)                                          }
-  let(:disjunction)     { attribute.eq(1).or(attribute.eq(2))                                  }
-  let(:object)          { described_class.new                                                  }
-
-  it_should_behave_like 'a generated SQL expression'
-
-  its(:to_s) { should eql('("id" = 1 OR "id" = 2)') }
-end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_connective_negation_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe SQL::Generator::Logic, '#visit_veritas_logic_connective_negation' do
-  subject { object.visit_veritas_logic_connective_negation(negation) }
-
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:attribute)       { Attribute::Integer.new(:id)                                          }
-  let(:negation)        { Logic::Connective::Negation.new(attribute.eq(1))                     }
-  let(:object)          { described_class.new                                                  }
-
-  it_should_behave_like 'a generated SQL expression'
-
-  its(:to_s) { should eql('NOT "id" = 1') }
-end

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_greater_than_or_equal_to_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_greater_than_or_equal_to' do
-  subject { object.visit_veritas_logic_predicate_greater_than_or_equal_to(greater_than_or_equal_to) }
-
-  let(:described_class)          { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  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/veritas/sql/generator/logic/visit_veritas_logic_predicate_less_than_or_equal_to_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_less_than_or_equal_to' do
-  subject { object.visit_veritas_logic_predicate_less_than_or_equal_to(less_than_or_equal_to) }
-
-  let(:described_class)       { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  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/veritas/sql/generator/logic/visit_veritas_logic_proposition_contradiction_spec.rb

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

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_proposition_tautology_spec.rb

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

data/spec/unit/veritas/sql/generator/relation/binary/class_methods/subquery_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe SQL::Generator::Relation::Binary, '.subquery' do
-  subject { object.subquery(generator) }
-
-  let(:id)            { Attribute::Integer.new(:id)                      }
-  let(:name)          { Attribute::String.new(:name)                     }
-  let(:age)           { Attribute::Integer.new(:age, :required => false) }
-  let(:header)        { [ id, name, age ]                                }
-  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { BaseRelation.new('users', header, body)          }
-  let(:object)        { described_class                                  }
-
-  context 'when generator is a base' do
-    let(:relation)  { base_relation                                              }
-    let(:generator) { SQL::Generator::Relation::Binary::Base.new.visit(relation) }
-
-    it_should_behave_like 'a generated SQL expression'
-
-    its(:to_s) { should == '"users"' }
-  end
-
-  context 'when generator is a unary' do
-    let(:relation)  { base_relation.project([ :id ])                      }
-    let(:generator) { SQL::Generator::Relation::Unary.new.visit(relation) }
-
-    it_should_behave_like 'a generated SQL expression'
-
-    its(:to_s) { should eql('(SELECT DISTINCT "id" FROM "users") AS "users"') }
-  end
-
-  context 'when generator is a binary' do
-    let(:relation)  { base_relation.join(base_relation)                    }
-    let(:generator) { SQL::Generator::Relation::Binary.new.visit(relation) }
-
-    it_should_behave_like 'a generated SQL expression'
-
-    its(:to_s) { should eql('(SELECT * FROM "users" NATURAL JOIN "users") AS "users"') }
-  end
-end

data/spec/unit/veritas/sql/generator/relation/class_methods/subquery_spec.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe SQL::Generator::Relation, '.subquery' do
-  subject { object.subquery(generator) }
-
-  let(:id)            { Attribute::Integer.new(:id)                      }
-  let(:name)          { Attribute::String.new(:name)                     }
-  let(:age)           { Attribute::Integer.new(:age, :required => false) }
-  let(:header)        { [ id, name, age ]                                }
-  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { BaseRelation.new('users', header, body)          }
-  let(:object)        { described_class                                  }
-
-  context 'when generator is a unary' do
-    let(:relation)  { base_relation.project([ :id ])                      }
-    let(:generator) { SQL::Generator::Relation::Unary.new.visit(relation) }
-
-    it_should_behave_like 'a generated SQL expression'
-
-    its(:to_s) { should eql('(SELECT DISTINCT "id" FROM "users") AS "users"') }
-  end
-
-  context 'when generator is a binary' do
-    let(:relation)  { base_relation.join(base_relation)                    }
-    let(:generator) { SQL::Generator::Relation::Binary.new.visit(relation) }
-
-    it_should_behave_like 'a generated SQL expression'
-
-    its(:to_s) { should eql('(SELECT * FROM "users" NATURAL JOIN "users") AS "users"') }
-  end
-end

data/tasks/quality/ci.rake

@@ -1,2 +0,0 @@
-desc 'Heckle and run metrics'
-task :ci => [ :verify_measurements, :heckle, :flog, :flay, :reek, :roodi, 'metrics:all' ]