axiom-sql-generator 0.1.0 → 0.2.0

data/spec/unit/axiom/sql/generator/relation/class_methods/visit_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation, '.visit' do
   subject { object.visit(relation) }
 
-  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) { Relation::Base.new('users', header, body)        }
-  let(:object)        { described_class                                  }
+  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) { Relation::Base.new('users', header, body)     }
+  let(:object)        { described_class                               }
 
   context 'when the relation is an insertion operation' do
     let(:relation) { base_relation.insert(base_relation) }
@@ -34,7 +34,7 @@ describe SQL::Generator::Relation, '.visit' do
   end
 
   context 'when the relation is a binary operation' do
-    let(:relation) { base_relation.join(base_relation.project([ :id ])) }
+    let(:relation) { base_relation.join(base_relation.project([:id])) }
 
     it { should be_kind_of(SQL::Generator::Relation::Binary) }
 
@@ -44,7 +44,7 @@ describe SQL::Generator::Relation, '.visit' do
   end
 
   context 'when the relation is a unary operation' do
-    let(:relation) { base_relation.project([ :id ]) }
+    let(:relation) { base_relation.project([:id]) }
 
     it { should be_kind_of(SQL::Generator::Relation::Unary) }
 
@@ -64,7 +64,7 @@ describe SQL::Generator::Relation, '.visit' do
   end
 
   context 'when the relation is invalid' do
-    let(:relation) { mock('Invalid Relation') }
+    let(:relation) { double('Invalid Relation') }
 
     specify { expect { subject }.to raise_error(SQL::Generator::InvalidRelationError, "#{relation.class} is not a visitable relation") }
   end

data/spec/unit/axiom/sql/generator/relation/insertion/to_subquery_spec.rb

@@ -8,8 +8,8 @@ describe SQL::Generator::Relation::Insertion, '#to_subquery' do
   let(:object) { described_class.new }
 
   it 'delegates to #to_s' do
-    sql = stub('sql')
-    object.should_receive(:to_s).with(no_args).and_return(sql)
+    sql = double('sql')
+    expect(object).to receive(:to_s).with(no_args).and_return(sql)
     should equal(sql)
   end
 end

data/spec/unit/axiom/sql/generator/relation/insertion/visit_axiom_relation_operation_insertion_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_insertion' do
   subject { object.visit_axiom_relation_operation_insertion(insertion) }
 
-  let(:object)        { described_class.new                              }
-  let(:insertion)     { operand.insert(other)                            }
-  let(:operand)       { Relation::Base.new(relation_name, header, body)  }
-  let(:relation_name) { 'users'                                          }
-  let(:header)        { [ id, name, age ]                                }
-  let(:body)          { [].each                                          }
-  let(:id)            { Attribute::Integer.new(:id)                      }
-  let(:name)          { Attribute::String.new(:name)                     }
-  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:object)        { described_class.new                             }
+  let(:insertion)     { operand.insert(other)                           }
+  let(:operand)       { Relation::Base.new(relation_name, header, body) }
+  let(:relation_name) { 'users'                                         }
+  let(:header)        { [id, name, age]                                 }
+  let(:body)          { [].each                                         }
+  let(:id)            { Attribute::Integer.new(:id)                     }
+  let(:name)          { Attribute::String.new(:name)                    }
+  let(:age)           { Attribute::Integer.new(:age, required: false)   }
 
   context 'inserting a non-empty materialized relation' do
-    let(:other) { operand.materialize            }
-    let(:body)  { [ [ 1, 'Dan Kubb', 36 ] ].each }
+    let(:other) { operand.materialize        }
+    let(:body)  { [[1, 'Dan Kubb', 36]].each }
 
     it_should_behave_like 'a generated SQL expression'
 
@@ -44,8 +44,8 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
   end
 
   context 'inserting a projection' do
-    let(:header) { [ id, name ]                    }
-    let(:other)  { operand.project([ :id, :name ]) }
+    let(:header) { [id, name]                    }
+    let(:other)  { operand.project([:id, :name]) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -54,7 +54,7 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
   end
 
   context 'inserting an extension' do
-    let(:other) { Relation::Base.new('other', [ id, name ], body).extend { |r| r.add(age, 1) } }
+    let(:other) { Relation::Base.new('other', [id, name], body).extend { |r| r.add(age, 1) } }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -63,7 +63,7 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
   end
 
   context 'inserting a rename' do
-    let(:other) { Relation::Base.new('other', [ [ :other_id, Integer ], name, age ], body).rename(:other_id => :id) }
+    let(:other) { Relation::Base.new('other', [[:other_id, Integer], name, age], body).rename(other_id: :id) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -83,7 +83,7 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
   context 'inserting a summarization' do
     context 'summarize per table dee' do
       let(:summarize_per) { TABLE_DEE                                                      }
-      let(:operand)       { Relation::Base.new(relation_name, [ id ], body)                }
+      let(:operand)       { Relation::Base.new(relation_name, [id], body)                  }
       let(:other)         { operand.summarize(summarize_per) { |r| r.add(id, r.id.count) } }
 
       it_should_behave_like 'a generated SQL SELECT query'
@@ -94,7 +94,7 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
 
     context 'summarize per table dum' do
       let(:summarize_per) { TABLE_DUM                                                      }
-      let(:operand)       { Relation::Base.new(relation_name, [ id ], body)                }
+      let(:operand)       { Relation::Base.new(relation_name, [id], body)                  }
       let(:other)         { operand.summarize(summarize_per) { |r| r.add(id, r.id.count) } }
 
       it_should_behave_like 'a generated SQL SELECT query'
@@ -104,7 +104,7 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
     end
 
     context 'summarize by a subset of the operand header' do
-      let(:other) { operand.summarize([ :id, :name ]) { |r| r.add(age, r.age.count) } }
+      let(:other) { operand.summarize([:id, :name]) { |r| r.add(age, r.age.count) } }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -113,8 +113,8 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
     end
   end
 
-  context 'inserting an order' do
-    let(:other) { operand.sort_by { |r| [ r.id, r.name, r.age ] } }
+  context 'inserting a sorted relation' do
+    let(:other) { operand.sort_by { |r| [r.id, r.name, r.age] } }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -123,7 +123,7 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
   end
 
   context 'inserting a reverse' do
-    let(:other) { operand.sort_by { |r| [ r.id, r.name, r.age ] }.reverse }
+    let(:other) { operand.sort_by { |r| [r.id, r.name, r.age] }.reverse }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -132,7 +132,7 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
   end
 
   context 'inserting a limit' do
-    let(:other) { operand.sort_by { |r| [ r.id, r.name, r.age ] }.take(1) }
+    let(:other) { operand.sort_by { |r| [r.id, r.name, r.age] }.take(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -141,7 +141,7 @@ describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_i
   end
 
   context 'inserting an offset' do
-    let(:other) { operand.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1) }
+    let(:other) { operand.sort_by { |r| [r.id, r.name, r.age] }.drop(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 

data/spec/unit/axiom/sql/generator/relation/materialized/visit_axiom_relation_materialized_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Materialized, '#visit_axiom_relation_materialized' do
   subject { object.visit_axiom_relation_materialized(relation) }
 
-  let(:object) { described_class.new  }
-  let(:header) { [ [ :id, Integer ], [ :name, String ] ] }
+  let(:object) { described_class.new               }
+  let(:header) { [[:id, Integer], [:name, String]] }
 
   context 'with an non-empty relation' do
-    let(:relation) { Relation.new(header, [ [ 1, 'John Doe' ], [ 2, 'Jane Doe' ] ]) }
+    let(:relation) { Relation.new(header, [[1, 'John Doe'], [2, 'Jane Doe']]) }
 
     it_should_behave_like 'a generated SQL expression'
 

data/spec/unit/axiom/sql/generator/relation/materialized/visited_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Materialized, '#visited?' do
   subject { object.visited? }
 
-  let(:object)   { described_class.new                        }
-  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [] ]) }
+  let(:object)   { described_class.new                  }
+  let(:relation) { Relation.new([[:id, Integer]], [[]]) }
 
   context 'when the relation is visited' do
     before do

data/spec/unit/axiom/sql/generator/relation/set/class_methods/normalize_operand_headers_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Set, '.normalize_operand_headers' do
   subject { object.normalize_operand_headers(relation) }
 
-  let(:object)        { described_class                          }
-  let(:relation)      { left.union(right)                        }
-  let(:relation_name) { 'test'                                   }
-  let(:header)        { [ [ :id, Integer, ], [ :name, String ] ] }
-  let(:body)          { [].each                                  }
+  let(:object)        { described_class                   }
+  let(:relation)      { left.union(right)                 }
+  let(:relation_name) { 'test'                            }
+  let(:header)        { [[:id, Integer], [:name, String]] }
+  let(:body)          { [].each                           }
 
   context 'when the left and right headers are sorted in the same order' do
     let(:left)  { Relation::Base.new(relation_name, header, body) }

data/spec/unit/axiom/sql/generator/relation/set/to_s_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Set, '#to_s' do
   subject { object.to_s }
 
-  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) { Relation::Base.new('users', header, body)        }
-  let(:object)        { described_class.new                              }
+  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) { Relation::Base.new('users', header, body)     }
+  let(:object)        { described_class.new                           }
 
   context 'when no object visited' do
     it_should_behave_like 'an idempotent method'

data/spec/unit/axiom/sql/generator/relation/set/to_subquery_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Set, '#to_subquery' do
   subject { object.to_subquery }
 
-  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) { Relation::Base.new('users', header, body)        }
-  let(:object)        { described_class.new                              }
+  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) { Relation::Base.new('users', header, body)     }
+  let(:object)        { described_class.new                           }
 
   context 'when no object visited' do
     it_should_behave_like 'an idempotent method'

data/spec/unit/axiom/sql/generator/relation/set/visit_axiom_algebra_difference_spec.rb

@@ -5,17 +5,17 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
   subject { object.visit_axiom_algebra_difference(difference) }
 
-  let(:relation_name) { 'users'                                          }
-  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) { Relation::Base.new(relation_name, header, body)  }
-  let(:left)          { operand                                          }
-  let(:right)         { operand                                          }
-  let(:difference)    { left.difference(right)                           }
-  let(:object)        { described_class.new                              }
+  let(:relation_name) { 'users'                                         }
+  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) { Relation::Base.new(relation_name, header, body) }
+  let(:left)          { operand                                         }
+  let(:right)         { operand                                         }
+  let(:difference)    { left.difference(right)                          }
+  let(:object)        { described_class.new                             }
 
   context 'when the operands are base relations' do
     let(:operand) { base_relation }
@@ -27,7 +27,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
   end
 
   context 'when the operands are projections' do
-    let(:operand) { base_relation.project([ :id, :name ]) }
+    let(:operand) { base_relation.project([:id, :name]) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -45,7 +45,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
   end
 
   context 'when the operands are renames' do
-    let(:operand) { base_relation.rename(:id => :user_id) }
+    let(:operand) { base_relation.rename(id: :user_id) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -87,7 +87,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
     end
 
     context 'summarize by a subset of the operand header' do
-      let(:operand) { base_relation.summarize([ :id, :name ]) { |r| r.add(:count, r.age.count) } }
+      let(:operand) { base_relation.summarize([:id, :name]) { |r| r.add(:count, r.age.count) } }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -96,8 +96,8 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
     end
   end
 
-  context 'when the operand is ordered' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] } }
+  context 'when the operand is sorted' do
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] } }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -106,7 +106,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
   end
 
   context 'when the operand is reversed' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.reverse }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.reverse }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -115,7 +115,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
   end
 
   context 'when the operand is limited' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.take(1) }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.take(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -124,7 +124,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
   end
 
   context 'when the operands are offsets' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1) }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.drop(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 

data/spec/unit/axiom/sql/generator/relation/set/visit_axiom_algebra_intersection_spec.rb

@@ -5,17 +5,17 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_intersection' do
   subject { object.visit_axiom_algebra_intersection(intersection) }
 
-  let(:relation_name) { 'users'                                          }
-  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) { Relation::Base.new(relation_name, header, body)  }
-  let(:left)          { operand                                          }
-  let(:right)         { operand                                          }
-  let(:intersection)  { left.intersect(right)                            }
-  let(:object)        { described_class.new                              }
+  let(:relation_name) { 'users'                                         }
+  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) { Relation::Base.new(relation_name, header, body) }
+  let(:left)          { operand                                         }
+  let(:right)         { operand                                         }
+  let(:intersection)  { left.intersect(right)                           }
+  let(:object)        { described_class.new                             }
 
   context 'when the operands are base relations' do
     let(:operand) { base_relation }
@@ -27,7 +27,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_intersection' do
   end
 
   context 'when the operands are projections' do
-    let(:operand) { base_relation.project([ :id, :name ]) }
+    let(:operand) { base_relation.project([:id, :name]) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -45,7 +45,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_intersection' do
   end
 
   context 'when the operands are renames' do
-    let(:operand) { base_relation.rename(:id => :user_id) }
+    let(:operand) { base_relation.rename(id: :user_id) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -84,7 +84,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_intersection' do
     end
 
     context 'summarize by a subset of the operand header' do
-      let(:operand) { base_relation.summarize([ :id, :name ]) { |r| r.add(:count, r.age.count) } }
+      let(:operand) { base_relation.summarize([:id, :name]) { |r| r.add(:count, r.age.count) } }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -93,8 +93,8 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_intersection' do
     end
   end
 
-  context 'when the operand is ordered' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] } }
+  context 'when the operand is sorted' do
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] } }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -103,7 +103,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_intersection' do
   end
 
   context 'when the operand is reversed' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.reverse }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.reverse }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -112,7 +112,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_intersection' do
   end
 
   context 'when the operand is limited' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.take(1) }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.take(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -121,7 +121,7 @@ describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_intersection' do
   end
 
   context 'when the operands are offsets' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1) }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.drop(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'