axiom-sql-generator 0.1.0 → 0.2.0

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

@@ -5,17 +5,17 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_union' do
   subject { object.visit_axiom_algebra_union(union) }
 
-  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(:union)         { left.union(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(:union)         { left.union(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_union' 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_union' 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_union' 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_union' 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_union' 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_union' 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_union' 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/to_s_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe SQL::Generator::Relation, '#to_s' do
   subject { object.to_s }
 
-  let(:described_class) { Class.new(SQL::Generator::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.new                              }
+  let(:described_class) { Class.new(SQL::Generator::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.new                           }
 
   context 'when no object visited' do
     it_should_behave_like 'an idempotent method'
@@ -25,7 +25,7 @@ describe SQL::Generator::Relation, '#to_s' do
   end
 
   context 'when an object is visited' do
-    let(:visitable) { mock('Visitable') }
+    let(:visitable) { double('Visitable') }
 
     before do
       described_class.class_eval do

data/spec/unit/axiom/sql/generator/relation/to_sql_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation, '#to_sql' do
   subject { object.to_sql }
 
-  let(:described_class) { Class.new(SQL::Generator::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(:object)          { described_class.new                              }
+  let(:described_class) { Class.new(SQL::Generator::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(:object)          { described_class.new                           }
 
   context 'when no object visited' do
     it_should_behave_like 'an idempotent method'
@@ -24,7 +24,7 @@ describe SQL::Generator::Relation, '#to_sql' do
   end
 
   context 'when an object is visited' do
-    let(:visitable) { mock('Visitable') }
+    let(:visitable) { double('Visitable') }
 
     before do
       described_class.class_eval do

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

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe SQL::Generator::Relation, '#to_subquery' do
   subject { object.to_subquery }
 
-  let(:described_class) { Class.new(SQL::Generator::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.new                              }
+  let(:described_class) { Class.new(SQL::Generator::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.new                           }
 
   context 'when no object visited' do
     it_should_behave_like 'an idempotent method'
@@ -25,7 +25,7 @@ describe SQL::Generator::Relation, '#to_subquery' do
   end
 
   context 'when an object is visited' do
-    let(:visitable) { mock('Visitable') }
+    let(:visitable) { double('Visitable') }
 
     before do
       described_class.class_eval do

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

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Unary, '#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'
@@ -35,7 +35,7 @@ describe SQL::Generator::Relation::Unary, '#to_s' do
 
   context 'when a limit is visited' do
     before do
-      object.visit(base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.take(1))
+      object.visit(base_relation.sort_by { |r| [r.id, r.name, r.age] }.take(1))
     end
 
     it_should_behave_like 'a generated SQL expression'
@@ -45,7 +45,7 @@ describe SQL::Generator::Relation::Unary, '#to_s' do
 
   context 'when an offset is visited' do
     before do
-      object.visit(base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1))
+      object.visit(base_relation.sort_by { |r| [r.id, r.name, r.age] }.drop(1))
     end
 
     it_should_behave_like 'a generated SQL expression'

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

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Unary, '#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'
@@ -25,7 +25,7 @@ describe SQL::Generator::Relation::Unary, '#to_subquery' do
 
   context 'when a projection is visited' do
     before do
-      object.visit(base_relation.project([ :id, :name ]))
+      object.visit(base_relation.project([:id, :name]))
     end
 
     it_should_behave_like 'a generated SQL expression'
@@ -35,7 +35,7 @@ describe SQL::Generator::Relation::Unary, '#to_subquery' do
 
   context 'when a rename is visited' do
     before do
-      object.visit(base_relation.rename(:id => :user_id))
+      object.visit(base_relation.rename(id: :user_id))
     end
 
     it_should_behave_like 'a generated SQL expression'
@@ -55,7 +55,7 @@ describe SQL::Generator::Relation::Unary, '#to_subquery' do
 
   context 'when a limit is visited' do
     before do
-      object.visit(base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.take(1))
+      object.visit(base_relation.sort_by { |r| [r.id, r.name, r.age] }.take(1))
     end
 
     it_should_behave_like 'a generated SQL expression'
@@ -65,7 +65,7 @@ describe SQL::Generator::Relation::Unary, '#to_subquery' do
 
   context 'when an offset is visited' do
     before do
-      object.visit(base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1))
+      object.visit(base_relation.sort_by { |r| [r.id, r.name, r.age] }.drop(1))
     end
 
     it_should_behave_like 'a generated SQL expression'

data/spec/unit/axiom/sql/generator/relation/unary/visit_axiom_algebra_extension_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_extension' do
   subject { object.visit_axiom_algebra_extension(extension) }
 
-  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(:extension)     { operand.extend { |r| r.add(:one, 1) }            }
-  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(:extension)     { operand.extend { |r| r.add(:one, 1) }           }
+  let(:object)        { described_class.new                             }
 
   context 'when the operand is a base relation' do
     let(:operand) { base_relation }
@@ -25,7 +25,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_extension' do
   end
 
   context 'when the operand is a projection' do
-    let(:operand) { base_relation.project([ :id, :name ]) }
+    let(:operand) { base_relation.project([:id, :name]) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -43,7 +43,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_extension' do
   end
 
   context 'when the operand is a rename' 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'
 
@@ -82,7 +82,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_extension' 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'
 
@@ -91,8 +91,8 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_extension' 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'
 
@@ -101,7 +101,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_extension' 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'
 
@@ -110,7 +110,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_extension' 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'
 
@@ -119,7 +119,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_extension' do
   end
 
   context 'when the operand is an offset' 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/unary/visit_axiom_algebra_projection_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
   subject { object.visit_axiom_algebra_projection(projection) }
 
-  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(:projection)    { operand.project([ :id, :name ])                  }
-  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(:projection)    { operand.project([:id, :name])                   }
+  let(:object)        { described_class.new                             }
 
   context 'when the operand is a base relation' do
     let(:operand) { base_relation }
@@ -25,7 +25,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
   end
 
   context 'when the operand is a projection' do
-    let(:operand) { base_relation.project([ :id, :name ]) }
+    let(:operand) { base_relation.project([:id, :name]) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -37,7 +37,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
     let(:operand) { base_relation.extend { |r| r.add(:one, 1) } }
 
     context 'when the projection includes the extended column' do
-      let(:projection) { operand.project([ :id, :name, :one ]) }
+      let(:projection) { operand.project([:id, :name, :one]) }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -46,7 +46,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
     end
 
     context 'when the projection does not include the extended column' do
-      let(:projection) { operand.project([ :id, :name ]) }
+      let(:projection) { operand.project([:id, :name]) }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -56,10 +56,10 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
   end
 
   context 'when the operand is a rename' do
-    let(:operand) { base_relation.rename(:id => :user_id) }
+    let(:operand) { base_relation.rename(id: :user_id) }
 
     context 'when the projection includes the renamed column' do
-      let(:projection) { operand.project([ :user_id, :name ]) }
+      let(:projection) { operand.project([:user_id, :name]) }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -68,7 +68,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
     end
 
     context 'when the projection does not include the renamed column' do
-      let(:projection) { operand.project([ :name, :age ]) }
+      let(:projection) { operand.project([:name, :age]) }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -90,7 +90,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
     context 'summarize per table dee' do
       let(:summarize_per) { TABLE_DEE                                                                }
       let(:operand)       { base_relation.summarize(summarize_per) { |r| r.add(:count, r.id.count) } }
-      let(:projection)    { operand.project([ :count ])                                              }
+      let(:projection)    { operand.project([:count])                                                }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -101,7 +101,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
     context 'summarize per table dum' do
       let(:summarize_per) { TABLE_DUM                                                                }
       let(:operand)       { base_relation.summarize(summarize_per) { |r| r.add(:count, r.id.count) } }
-      let(:projection)    { operand.project([ :count ])                                              }
+      let(:projection)    { operand.project([:count])                                                }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -110,7 +110,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' 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'
 
@@ -119,8 +119,8 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' 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'
 
@@ -129,7 +129,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' 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'
 
@@ -138,7 +138,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' 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'
 
@@ -147,7 +147,7 @@ describe SQL::Generator::Relation::Unary, '#visit_axiom_algebra_projection' do
   end
 
   context 'when the operand is an offset' 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'