sequel 4.31.0 → 4.32.0

data/spec/integration/dataset_test.rb

@@ -1090,9 +1090,9 @@ describe "Sequel::Dataset main SQL methods" do
   
   it "#filter and #exclude should work with placeholder strings" do
     @ds.insert(20, 30)
-    @ds.filter("a > ?", 15).all.must_equal [{:a=>20, :b=>30}]
-    @ds.exclude("b < ?", 15).all.must_equal [{:a=>20, :b=>30}]
-    @ds.filter("b < ?", 15).invert.all.must_equal [{:a=>20, :b=>30}]
+    @ds.filter(Sequel.lit("a > ?", 15)).all.must_equal [{:a=>20, :b=>30}]
+    @ds.exclude(Sequel.lit("b < ?", 15)).all.must_equal [{:a=>20, :b=>30}]
+    @ds.filter(Sequel.lit("b < ?", 15)).invert.all.must_equal [{:a=>20, :b=>30}]
   end
   
   it "#and and #or should work correctly" do

data/spec/integration/plugin_test.rb

@@ -1302,6 +1302,11 @@ describe "AssociationPks plugin" do
     album.tag_pks.must_equal [@t1, @t2]
     album.save
     album_class.with_pk!(album.pk).tag_pks.sort.must_equal [@t1, @t2]
+
+    album.tag_pks = []
+    album.tag_pks.must_equal []
+    album.save
+    album_class.with_pk!(album.pk).tag_pks.sort.must_equal []
   end
 
   it "should handle :delay=>:all association option for existing instances" do
@@ -1313,6 +1318,11 @@ describe "AssociationPks plugin" do
     album.tag_pks.must_equal [@t1, @t2]
     album.save_changes
     album_class.with_pk!(album.pk).tag_pks.sort.must_equal [@t1, @t2]
+
+    album.tag_pks = []
+    album.tag_pks.must_equal []
+    album.save_changes
+    album_class.with_pk!(album.pk).tag_pks.sort.must_equal []
   end
 
   it "should set associated pks correctly for a one_to_many association" do
@@ -1330,6 +1340,9 @@ describe "AssociationPks plugin" do
     Artist[@ar1].album_pks = [@al1, @al2]
     Artist[@ar2].album_pks.must_equal [@al3]
     Album.order(:id).select_map(:artist_id).must_equal [@ar1, @ar1, @ar2]
+
+    Artist[@ar1].album_pks = []
+    Album.order(:id).select_map(:artist_id).must_equal [nil, nil, @ar2]
   end
 
   it "should set associated pks correctly for a many_to_many association" do
@@ -1369,6 +1382,9 @@ describe "AssociationPks plugin" do
     Album[@al1].vocalist_pks = [@v1, @v2]
     Album[@al2].vocalist_pks.must_equal [@v3]
     Vocalist.order(:first, :last).select_map(:album_id).must_equal [@al1, @al1, @al2]
+
+    Album[@al1].vocalist_pks = []
+    Vocalist.order(:first, :last).select_map(:album_id).must_equal [nil, nil, @al2]
   end
 
   it "should set associated right-side cpks correctly for a many_to_many association" do
@@ -1410,6 +1426,9 @@ describe "AssociationPks plugin" do
     Vocalist[@v1].instrument_pks = [@i1, @i2]
     Vocalist[@v2].instrument_pks.must_equal [@i3]
     Instrument.order(:id).select_map([:first, :last]).must_equal [@v1, @v1, @v2]
+
+    Vocalist[@v1].instrument_pks = []
+    Instrument.order(:id).select_map([:first, :last]).must_equal [[nil, nil], [nil, nil], @v2]
   end
 
   it "should set associated pks correctly with left-side cpks for a many_to_many association" do
@@ -1451,6 +1470,9 @@ describe "AssociationPks plugin" do
     Vocalist[@v1].hit_pks = [@h1, @h2]
     Vocalist[@v2].hit_pks.must_equal [@h3]
     Hit.order(:year, :week).select_map([:first, :last]).must_equal [@v1, @v1, @v2]
+
+    Vocalist[@v1].hit_pks = []
+    Hit.order(:year, :week).select_map([:first, :last]).must_equal [[nil, nil], [nil, nil], @v2]
   end
 
   it "should set associated right-side cpks correctly with left-side cpks for a many_to_many association" do

data/spec/integration/prepared_statement_test.rb

@@ -55,14 +55,14 @@ describe "Prepared Statements and Bound Arguments" do
   end
 
   it "should support placeholder literal strings with call" do
-    @ds.filter("numb = ?", :$n).call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(Sequel.lit("numb = ?", :$n)).call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
   end
 
   it "should support named placeholder literal strings and handle multiple named placeholders correctly with call" do
-    @ds.filter("numb = :n", :n=>:$n).call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(Sequel.lit("numb = :n", :n=>:$n)).call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
     @ds.insert(:numb=>20)
     @ds.insert(:numb=>30)
-    @ds.filter("numb > :n1 AND numb < :n2 AND numb = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1).call(:select, :n3=>20, :n2=>30, :n1=>10).must_equal [{:id=>2, :numb=>20}]
+    @ds.filter(Sequel.lit("numb > :n1 AND numb < :n2 AND numb = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1)).call(:select, :n3=>20, :n2=>30, :n1=>10).must_equal [{:id=>2, :numb=>20}]
   end
 
   it "should support datasets with static sql and placeholders with call" do
@@ -78,7 +78,7 @@ describe "Prepared Statements and Bound Arguments" do
   end
 
   it "should support subselects with literal strings with call" do
-    @ds.filter(:id=>:$i, :numb=>@ds.select(:numb).filter("numb = ?", :$n)).call(:select, :n=>10, :i=>1).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:id=>:$i, :numb=>@ds.select(:numb).filter(Sequel.lit("numb = ?", :$n))).call(:select, :n=>10, :i=>1).must_equal [{:id=>1, :numb=>10}]
   end
 
   it "should support subselects with static sql and placeholders with call" do
@@ -186,14 +186,14 @@ describe "Prepared Statements and Bound Arguments" do
   end
 
   it "should support placeholder literal strings with prepare" do
-    @ds.filter("numb = ?", :$n).prepare(:select, :seq_select).call(:n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(Sequel.lit("numb = ?", :$n)).prepare(:select, :seq_select).call(:n=>10).must_equal [{:id=>1, :numb=>10}]
   end
 
   it "should support named placeholder literal strings and handle multiple named placeholders correctly with prepare" do
-    @ds.filter("numb = :n", :n=>:$n).prepare(:select, :seq_select).call(:n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(Sequel.lit("numb = :n", :n=>:$n)).prepare(:select, :seq_select).call(:n=>10).must_equal [{:id=>1, :numb=>10}]
     @ds.insert(:numb=>20)
     @ds.insert(:numb=>30)
-    @ds.filter("numb > :n1 AND numb < :n2 AND numb = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1).call(:select, :n3=>20, :n2=>30, :n1=>10).must_equal [{:id=>2, :numb=>20}]
+    @ds.filter(Sequel.lit("numb > :n1 AND numb < :n2 AND numb = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1)).call(:select, :n3=>20, :n2=>30, :n1=>10).must_equal [{:id=>2, :numb=>20}]
   end
 
   it "should support datasets with static sql and placeholders with prepare" do
@@ -209,7 +209,7 @@ describe "Prepared Statements and Bound Arguments" do
   end
 
   it "should support subselects with literal strings with prepare" do
-    @ds.filter(:id=>:$i, :numb=>@ds.select(:numb).filter("numb = ?", :$n)).prepare(:select, :seq_select).call(:n=>10, :i=>1).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:id=>:$i, :numb=>@ds.select(:numb).filter(Sequel.lit("numb = ?", :$n))).prepare(:select, :seq_select).call(:n=>10, :i=>1).must_equal [{:id=>1, :numb=>10}]
   end
 
   it "should support subselects with static sql and placeholders with prepare" do

data/spec/integration/spec_helper.rb

@@ -36,6 +36,10 @@ if DB.adapter_scheme == :ibmdb || (DB.adapter_scheme == :ado && DB.database_type
   end
 end
 
+if ENV['SEQUEL_NO_AUTO_LITERAL_STRINGS']
+  DB.extension :no_auto_literal_strings
+end
+
 if ENV['SEQUEL_ERROR_SQL']
   DB.extension :error_sql
 end

data/spec/model/association_reflection_spec.rb

@@ -523,3 +523,33 @@ describe Sequel::Model::Associations::AssociationReflection, "with caching disab
   end
 end
 
+describe Sequel::Model::Associations::AssociationReflection, "with default association options" do
+  before do
+    @db = Sequel.mock
+    @c = Class.new(Sequel::Model)
+    @c.dataset = @db[:foo]
+  end
+
+  it "should use default_association_options as defaults" do
+    @c.default_association_options = {:foo=>1, :bar=>2}
+    @c.many_to_one :c, :class=>@c, :foo=>3
+    r = @c.association_reflection(:c)
+    r[:foo].must_equal 3
+    r[:bar].must_equal 2
+  end
+
+  it "should inherit default_association_options" do
+    @c.default_association_options = {:foo=>1, :bar=>2}
+    c = Class.new(@c)
+    c.many_to_one :c, :class=>c, :foo=>3
+    r = c.association_reflection(:c)
+    r[:foo].must_equal 3
+    r[:bar].must_equal 2
+
+    @c.default_association_options[:bar] = 4
+    c.many_to_one :d, :class=>c, :foo=>3
+    r = c.association_reflection(:d)
+    r[:foo].must_equal 3
+    r[:bar].must_equal 2
+  end
+end

data/spec/model/associations_spec.rb

@@ -448,6 +448,8 @@ describe Sequel::Model, "many_to_one" do
     d.associations[:parent] = 42
     d.parent(true).wont_equal 42 
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
+    d.parent(:reload=>true).wont_equal 42 
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
   end
   
   it "should use a callback if given one as the argument" do
@@ -728,7 +730,7 @@ describe Sequel::Model, "one_to_one" do
     DB.reset
   end
   
-  it "should have the getter method return a single object if the :one_to_one option is true" do
+  it "should have the getter method return a single object" do
     @c2.one_to_one :attribute, :class => @c1
     att = @c2.new(:id => 1234).attribute
     DB.sqls.must_equal ['SELECT * FROM attributes WHERE (attributes.node_id = 1234) LIMIT 1']
@@ -1122,21 +1124,6 @@ describe Sequel::Model, "one_to_one" do
     proc{p.parent = nil}.must_raise(Sequel::HookFailed)
   end
 
-  it "should raise error and not call internal add or remove method if before callback returns false, even if raise_on_save_failure is false" do
-    p = @c2.load(:id=>321)
-    c = @c2.load(:id=>123)
-    p.raise_on_save_failure = false
-    @c2.one_to_one :parent, :class => @c2, :before_set=>:bs
-    def p.bs(x) cancel_action end
-    def p._parent=; raise; end
-    proc{p.parent = c}.must_raise(Sequel::HookFailed)
-    
-    p.associations[:parent].must_equal nil
-    p.associations[:parent] = c
-    p.parent.must_equal c
-    proc{p.parent = nil}.must_raise(Sequel::HookFailed)
-  end
-
   it "should not validate the associated object in setter if the :validate=>false option is used" do
     @c2.one_to_one :parent, :class => @c2, :validate=>false
     n = @c2.new(:id => 1234)
@@ -2814,6 +2801,9 @@ describe Sequel::Model, "one_through_one" do
     [@c1, @c2].each{|c| c.dataset._fetch = {}}
     DB.reset
   end
+  after do
+    DB.fetch = {:id => 1, :x => 1}
+  end
 
   it "should use implicit key values and join table if omitted" do
     @c2.one_through_one :attribute, :class => @c1 
@@ -3021,6 +3011,177 @@ describe Sequel::Model, "one_through_one" do
     @c2.one_through_one :attribute, :class => @c1, :distinct=>true
     @c2.load(:id=>10).attribute_dataset.sql.must_equal "SELECT DISTINCT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 10) LIMIT 1"
   end
+
+  it "should not add a setter method if the :read_only option is true" do
+    @c2.one_through_one :attribute, :class => @c1, :read_only=>true
+    im = @c2.instance_methods.collect{|x| x.to_s}
+    im.must_include('attribute')
+    im.wont_include('attribute=')
+  end
+
+  it "should add a setter method" do
+    @c2.one_through_one :attribute, :class => @c1
+    attrib = @c1.new(:id=>3)
+    DB.fetch = []
+    o = @c2.load(:id => 1234)
+    o.attribute = nil
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1"]
+
+    o.attribute = attrib
+    sqls = DB.sqls
+    ["INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (3, 1234)",
+      "INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 3)"].must_include(sqls.slice! 1)
+    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1"]
+
+    DB.fetch = {:node_id=>1234, :attribute_id=>5}
+    o.attribute = nil
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1",
+      "DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 5))"]
+
+    o.attribute = attrib
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1",
+      "UPDATE attributes_nodes SET attribute_id = 3 WHERE ((node_id = 1234) AND (attribute_id = 5))"]
+
+    @c2.load(:id => 1234).attribute = @c1.new(:id=>5)
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1"]
+  end
+
+  it "should use a transaction in the setter method" do
+    @c2.one_through_one :attribute, :class => @c1
+    @c2.use_transactions = true
+    attrib = @c1.load(:id=>3)
+    DB.fetch = []
+    @c2.new(:id => 1234).attribute = nil
+    DB.sqls.must_equal ['BEGIN',
+      "SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1",
+      'COMMIT']
+  end
+    
+  it "should have setter method respect :join_table_block option" do
+    @c2.one_through_one :attribute, :class => @c1, :join_table_block=>proc{|ds| ds.where(:a)}
+    attrib = @c1.new(:id=>3)
+    DB.fetch = []
+    o = @c2.new(:id => 1234)
+    o.attribute = nil
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (a AND (node_id = 1234)) LIMIT 1"]
+
+    o.attribute = attrib
+    sqls = DB.sqls
+    ["INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (3, 1234)",
+      "INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 3)"].must_include(sqls.slice! 1)
+    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (a AND (node_id = 1234)) LIMIT 1"]
+
+    DB.fetch = {:node_id=>1234, :attribute_id=>5}
+    o.attribute = nil
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (a AND (node_id = 1234)) LIMIT 1",
+      "DELETE FROM attributes_nodes WHERE (a AND (node_id = 1234) AND (attribute_id = 5))"]
+
+    o.attribute = attrib
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (a AND (node_id = 1234)) LIMIT 1",
+      "UPDATE attributes_nodes SET attribute_id = 3 WHERE (a AND (node_id = 1234) AND (attribute_id = 5))"]
+  end
+
+  it "should have the setter method respect the :left_primary_key and :right_primary_key option" do
+    @c2.one_through_one :attribute, :class => @c1, :left_primary_key=>:xxx, :right_primary_key=>:yyy
+    attrib = @c1.new(:id=>3, :yyy=>7)
+    DB.fetch = []
+    o = @c2.new(:id => 1234, :xxx=>5)
+    o.attribute = nil
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 5) LIMIT 1"]
+
+    o.attribute = attrib
+    sqls = DB.sqls
+    ["INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (7, 5)",
+      "INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (5, 7)"].must_include(sqls.slice! 1)
+    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 5) LIMIT 1"]
+
+    DB.fetch = {:node_id=>1234, :attribute_id=>9}
+    o.attribute = nil
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 5) LIMIT 1",
+      "DELETE FROM attributes_nodes WHERE ((node_id = 5) AND (attribute_id = 9))"]
+
+    o.attribute = attrib
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 5) LIMIT 1",
+      "UPDATE attributes_nodes SET attribute_id = 7 WHERE ((node_id = 5) AND (attribute_id = 9))"]
+  end
+    
+  it "should have the setter method respect composite keys" do
+    @c2.one_through_one :attribute, :class => @c1, :left_key=>[:node_id, :y], :left_primary_key=>[:id, :x], :right_key=>[:attribute_id, :z], :right_primary_key=>[:id, :w]
+    attrib = @c1.load(:id=>3, :w=>7)
+    @c1.def_column_alias :w, :w
+    DB.fetch = []
+    o = @c2.new(:id => 1234, :x=>5)
+    o.attribute = nil
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1"]
+
+    o.attribute = attrib
+    sqls = DB.sqls
+    sqls.slice!(1).must_match(/\AINSERT INTO attributes_nodes \((attribute_id|z|node_id|y), (attribute_id|z|node_id|y), (attribute_id|z|node_id|y), (attribute_id|z|node_id|y)\) VALUES \((3|7|1234|5), (3|7|1234|5), (3|7|1234|5), (3|7|1234|5)\)\z/)
+    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1"]
+
+    DB.fetch = {:node_id=>1234, :attribute_id=>10, :y=>6, :z=>8}
+    o.attribute = nil
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1",
+      "DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5) AND (attribute_id = 10) AND (z = 8))"]
+
+    o.attribute = attrib
+    sqls = DB.sqls
+    ["UPDATE attributes_nodes SET attribute_id = 3, z = 7 WHERE ((node_id = 1234) AND (y = 5) AND (attribute_id = 10) AND (z = 8))",
+     "UPDATE attributes_nodes SET z = 7, attribute_id = 3 WHERE ((node_id = 1234) AND (y = 5) AND (attribute_id = 10) AND (z = 8))"].must_include(sqls.slice!(1))
+    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1"]
+  end
+
+  it "should raise an error if the current model object that doesn't have a valid primary key" do
+    @c2.one_through_one :attribute, :class => @c1
+    p = @c2.new
+    c = @c2.load(:id=>123)
+    proc{c.attribute = p}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if the associated object that doesn't have a valid primary key" do
+    @c2.one_through_one :attribute, :class => @c1
+    p = @c2.new
+    c = @c2.load(:id=>123)
+    proc{p.attribute = c}.must_raise(Sequel::Error)
+  end
+
+  it "should make the change to the foreign_key value inside a _association= method" do
+    @c2.one_through_one :attribute, :class => @c1
+    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_attribute=")
+    attrib = @c1.new(:id=>3)
+    o = @c2.new(:id => 1234)
+    def o._attribute=(x)
+      @x = x
+    end
+    o.attribute = attrib
+    o.instance_variable_get(:@x).must_equal attrib
+  end
+
+  it "should have a :setter option define the _association= method" do
+    @c2.one_through_one :attribute, :class => @c1, :setter=>proc{|x| @x = x}
+    attrib = @c1.new(:id=>3)
+    o = @c2.new(:id => 1234)
+    o.attribute = attrib
+    o.instance_variable_get(:@x).must_equal attrib
+  end
+
+  it "should support (before|after)_set callbacks" do
+    h = []
+    @c2.one_through_one :attribute, :class => @c1, :before_set=>[proc{|x,y| h << x.pk; h << (y ? -y.pk : :y)}, :blah], :after_set=>proc{h << :l}
+    @c2.class_eval do
+      self::Foo = h
+      def blah(x)
+        model::Foo << (x ? x.pk : :x)
+      end
+    end
+    attrib = @c1.new(:id=>3)
+    o = @c2.new(:id => 1234)
+    h.must_equal []
+    o.attribute = attrib
+    h.must_equal [1234, -3, 3, :l]
+    o.attribute = nil
+    h.must_equal [1234, -3, 3, :l, 1234, :y, :x, :l]
+  end
 end
 
 describe "Filtering by associations" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.31.0
+  version: 4.32.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2016-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -232,6 +232,7 @@ extra_rdoc_files:
 - doc/release_notes/4.29.0.txt
 - doc/release_notes/4.30.0.txt
 - doc/release_notes/4.31.0.txt
+- doc/release_notes/4.32.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -352,6 +353,7 @@ files:
 - doc/release_notes/4.3.0.txt
 - doc/release_notes/4.30.0.txt
 - doc/release_notes/4.31.0.txt
+- doc/release_notes/4.32.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt
 - doc/release_notes/4.6.0.txt
@@ -488,6 +490,7 @@ files:
 - lib/sequel/extensions/migration.rb
 - lib/sequel/extensions/mssql_emulate_lateral_with_apply.rb
 - lib/sequel/extensions/named_timezones.rb
+- lib/sequel/extensions/no_auto_literal_strings.rb
 - lib/sequel/extensions/null_dataset.rb
 - lib/sequel/extensions/pagination.rb
 - lib/sequel/extensions/pg_array.rb
@@ -697,6 +700,7 @@ files:
 - spec/extensions/mssql_optimistic_locking_spec.rb
 - spec/extensions/named_timezones_spec.rb
 - spec/extensions/nested_attributes_spec.rb
+- spec/extensions/no_auto_literal_strings_spec.rb
 - spec/extensions/null_dataset_spec.rb
 - spec/extensions/optimistic_locking_spec.rb
 - spec/extensions/pagination_spec.rb