sequel 5.28.0 → 5.33.0

data/spec/extensions/identifier_mangling_spec.rb

@@ -1,201 +0,0 @@
-require_relative "spec_helper"
-
-describe "identifier_mangling extension" do
-  it "should respect the :quote_identifiers option" do
-    db = Sequel::Database.new(:quote_identifiers=>false).extension(:identifier_mangling)
-    db.quote_identifiers?.must_equal false
-    db = Sequel::Database.new(:quote_identifiers=>true).extension(:identifier_mangling)
-    db.quote_identifiers?.must_equal true
-  end
-
-  it "should respect the :quote_identifiers setting" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.quote_identifiers?.must_equal true
-    db.quote_identifiers = false
-    db.quote_identifiers?.must_equal false
-  end
-
-  it "should upcase on input and downcase on output by default" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.send(:identifier_input_method_default).must_equal :upcase
-    db.send(:identifier_output_method_default).must_equal :downcase
-  end
-
-  it "should respect the :identifier_input_method option" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.identifier_input_method.must_equal :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.must_be_nil
-    db = Sequel::Database.new(:identifier_input_method=>nil).extension(:identifier_mangling)
-    db.identifier_input_method.must_be_nil
-    db.identifier_input_method = :downcase
-    db.identifier_input_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase).extension(:identifier_mangling)
-    db.identifier_input_method.must_equal :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.must_be_nil
-  end
-  
-  it "should respect the :identifier_output_method option" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.identifier_output_method.must_equal :downcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.must_be_nil
-    db = Sequel::Database.new(:identifier_output_method=>nil).extension(:identifier_mangling)
-    db.identifier_output_method.must_be_nil
-    db.identifier_output_method = :downcase
-    db.identifier_output_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase).extension(:identifier_mangling)
-    db.identifier_output_method.must_equal :upcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.must_be_nil
-  end
-
-  it "should respect the identifier_input_method_default method if Sequel.identifier_input_method is not called" do
-    class Sequel::Database
-      @identifier_input_method = nil
-    end
-    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_input_method_default; :downcase end}
-    x.new.extension(:identifier_mangling).identifier_input_method.must_equal :downcase
-    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_input_method_default; :camelize end}
-    y.new.extension(:identifier_mangling).identifier_input_method.must_equal :camelize
-  end
-  
-  it "should respect the identifier_output_method_default method if Sequel.identifier_output_method is not called" do
-    class Sequel::Database
-      @identifier_output_method = nil
-    end
-    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_output_method_default; :upcase end}
-    x.new.extension(:identifier_mangling).identifier_output_method.must_equal :upcase
-    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_output_method_default; :underscore end}
-    y.new.extension(:identifier_mangling).identifier_output_method.must_equal :underscore
-  end
-end
-
-describe "Database#input_identifier_meth" do
-  it "should be the input_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.identifier_input_method = nil
-    db.send(:input_identifier_meth).call(:a).must_equal 'a'
-    db.identifier_input_method = :upcase
-    db.send(:input_identifier_meth).call(:a).must_equal 'A'
-  end
-end
-
-describe "Database#output_identifier_meth" do
-  it "should be the output_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.identifier_output_method = nil
-    db.send(:output_identifier_meth).call('A').must_equal :A
-    db.identifier_output_method = :downcase
-    db.send(:output_identifier_meth).call('A').must_equal :a
-  end
-end
-
-describe "Database#metadata_dataset" do
-  it "should be a dataset with the default settings for identifier_mangling" do
-    ds = Sequel::Database.new.extension(:identifier_mangling).send(:metadata_dataset)
-    ds.literal(:a).must_equal "\"A\""
-    ds.send(:output_identifier, 'A').must_equal :a
-  end
-end
-
-describe "Dataset" do
-  before do
-    @dataset = Sequel.mock.extension(:identifier_mangling).dataset
-  end
-  
-  it "should get quote_identifiers default from database" do
-    db = Sequel::Database.new(:quote_identifiers=>true).extension(:identifier_mangling)
-    db[:a].quote_identifiers?.must_equal true
-    db = Sequel::Database.new(:quote_identifiers=>false).extension(:identifier_mangling)
-    db[:a].quote_identifiers?.must_equal false
-  end
-
-  it "should get identifier_input_method default from database" do
-    db = Sequel::Database.new(:identifier_input_method=>:upcase).extension(:identifier_mangling)
-    db[:a].identifier_input_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:downcase).extension(:identifier_mangling)
-    db[:a].identifier_input_method.must_equal :downcase
-  end
-
-  it "should get identifier_output_method default from database" do
-    db = Sequel::Database.new(:identifier_output_method=>:upcase).extension(:identifier_mangling)
-    db[:a].identifier_output_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:downcase).extension(:identifier_mangling)
-    db[:a].identifier_output_method.must_equal :downcase
-  end
-  
-  it "should have with_quote_identifiers method which returns cloned dataset with changed literalization of identifiers" do
-    @dataset.with_quote_identifiers(true).literal(:a).must_equal '"a"'
-    @dataset.with_quote_identifiers(false).literal(:a).must_equal 'a'
-    ds = @dataset.freeze.with_quote_identifiers(false)
-    ds.literal(:a).must_equal 'a'
-    ds.frozen?.must_equal true
-  end
-  
-  it "should have with_identifier_input_method method which returns cloned dataset with changed literalization of identifiers" do
-    @dataset.with_identifier_input_method(:upcase).literal(:a).must_equal 'A'
-    @dataset.with_identifier_input_method(:downcase).literal(:A).must_equal 'a'
-    @dataset.with_identifier_input_method(:reverse).literal(:at_b).must_equal 'b_ta'
-    ds = @dataset.freeze.with_identifier_input_method(:reverse)
-    ds.frozen?.must_equal true
-    ds.literal(:at_b).must_equal 'b_ta'
-  end
-  
-  it "should have with_identifier_output_method method which returns cloned dataset with changed identifiers returned from the database" do
-    @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
-    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "at_b_C").must_equal :AT_B_C
-    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "at_b_C").must_equal :at_b_c
-    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    ds = @dataset.freeze.with_identifier_output_method(:reverse)
-    ds.send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    ds.frozen?.must_equal true
-  end
-  
-  it "should have output_identifier handle empty identifiers" do
-    @dataset.send(:output_identifier, "").must_equal :untitled
-    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "").must_equal :UNTITLED
-    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "").must_equal :untitled
-    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "").must_equal :deltitnu
-  end
-end
-
-describe "identifier_mangling extension" do
-  it "should be able to load dialects based on the database name" do
-    Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.must_equal 'SELECT #2011-12-13#'
-    Sequel.mock(:host=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
-    Sequel.mock(:host=>'mssql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
-    Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
-    Sequel.mock(:host=>'oracle')[:a].limit(1).sql.must_equal 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
-    Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM \"a\" WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(\"b\", ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
-    Sequel.mock(:host=>'sqlanywhere').from(:a).offset(1).sql.must_equal 'SELECT TOP 2147483647 START AT (1 + 1) * FROM "A"'
-    Sequel.mock(:host=>'sqlite')[Sequel[:a].as(:b)].sql.must_equal "SELECT * FROM `a` AS 'b'"
-  end
-end
-
-describe Sequel::Model, ".[] optimization" do
-  before do
-    @db = Sequel.mock(:quote_identifiers=>true).extension(:identifier_mangling)
-    def @db.schema(*) [[:id, {:primary_key=>true}]] end
-    def @db.supports_schema_parsing?() true end
-    @c = Class.new(Sequel::Model(@db))
-    @ds = @db.dataset.with_quote_identifiers(true)
-  end
-
-  it "should have simple_pk and simple_table respect dataset's identifier input methods" do
-    ds = @db.from(:ab).with_identifier_input_method(:reverse)
-    @c.set_dataset ds
-    @c.simple_table.must_equal '"ba"'
-    @c.set_primary_key :cd
-    @c.simple_pk.must_equal '"dc"'
-    @c.set_dataset ds.from(Sequel[:ef][:gh])
-    @c.simple_table.must_equal '"fe"."hg"'
-  end
-
-  with_symbol_splitting "should have simple_pk and simple_table respect dataset's identifier input methods when using splittable symbols" do
-    ds = @db.from(:ab).with_identifier_input_method(:reverse)
-    @c.set_dataset ds.from(:ef__gh)
-    @c.simple_table.must_equal '"fe"."hg"'
-  end
-end

data/spec/extensions/implicit_subquery_spec.rb

@@ -1,58 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Dataset::ImplicitSubquery" do
-  it "should implicitly use a subquery for most dataset query methods" do
-    db = Sequel.mock
-    db.extend_datasets{def supports_cte?; true end}
-    ds = db["SELECT * FROM table"].extension(:implicit_subquery)
-    ds.columns(:id, :a)
-    ods = db[:c]
-    ods.columns(:id, :b)
-
-    ds.cross_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 CROSS JOIN c"
-    ds.distinct.sql.must_equal "SELECT DISTINCT * FROM (SELECT * FROM table) AS t1"
-    ds.except(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 EXCEPT SELECT * FROM c) AS t1"
-    ds.exclude(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
-    ds.exclude_having(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 HAVING NOT c"
-    ds.filter(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
-    ds.for_update.sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FOR UPDATE"
-    ds.full_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FULL JOIN c"
-    ds.full_outer_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FULL OUTER JOIN c"
-    ds.graph(ods).sql.must_equal "SELECT t1.id, t1.a, c.id AS c_id, c.b FROM (SELECT * FROM table) AS t1 LEFT OUTER JOIN c"
-    ds.grep(:c, 'a').sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE ((c LIKE 'a' ESCAPE '\\'))"
-    ds.group(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.group_append(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.group_and_count(:c).sql.must_equal "SELECT c, count(*) AS count FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.group_by(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.having(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 HAVING c"
-    ds.inner_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
-    ds.intersect(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 INTERSECT SELECT * FROM c) AS t1"
-    ds.invert.sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE 'f'"
-    ds.join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
-    ds.join_table(:inner, :c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
-    ds.left_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LEFT JOIN c USING (d)"
-    ds.left_outer_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LEFT OUTER JOIN c USING (d)"
-    ds.limit(1).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LIMIT 1"
-    ds.lock_style('FOR UPDATE').sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FOR UPDATE"
-    ds.natural_full_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL FULL JOIN c"
-    ds.natural_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL JOIN c"
-    ds.natural_left_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL LEFT JOIN c"
-    ds.natural_right_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL RIGHT JOIN c"
-    ds.offset(1).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 OFFSET 1"
-    ds.order(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.order_append(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.order_by(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.order_more(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.order_prepend(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.right_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 RIGHT JOIN c USING (d)"
-    ds.right_outer_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 RIGHT OUTER JOIN c USING (d)"
-    ds.select(:c).sql.must_equal "SELECT c FROM (SELECT * FROM table) AS t1"
-    ds.select_append(:c).sql.must_equal "SELECT *, c FROM (SELECT * FROM table) AS t1"
-    ds.select_group(:c).sql.must_equal "SELECT c FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.select_more(:c).sql.must_equal "SELECT *, c FROM (SELECT * FROM table) AS t1"
-    ds.union(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 UNION SELECT * FROM c) AS t1"
-    ds.where(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
-    ds.with(:d, ods).sql.must_equal "WITH d AS (SELECT * FROM c) SELECT * FROM (SELECT * FROM table) AS t1"
-    ds.with_recursive(:d, ods, ods).sql.must_equal "WITH d AS (SELECT * FROM c UNION ALL SELECT * FROM c) SELECT * FROM (SELECT * FROM table) AS t1"
-  end
-end

data/spec/extensions/index_caching_spec.rb

@@ -1,66 +0,0 @@
-require_relative "spec_helper"
-
-describe "index_caching extension" do
-  before do
-    @db = Sequel.connect('mock://postgres').extension(:index_caching)
-    @indexes = {'"table"'=>{:table_idx_unique=>{:columns=>[:first_col, :second_col], :unique=>true, :deferrable=>nil}}}
-    @filename = "spec/files/test_indexes_#$$.dump"
-    @db.instance_variable_set(:@indexes, @indexes)
-  end
-  after do
-    File.delete(@filename) if File.exist?(@filename)
-  end
-
-  it "#indexes should return cached index information" do
-    @db.indexes(:table).must_equal @indexes['"table"']
-    @db.indexes(:table, {}).must_equal @indexes['"table"']
-  end 
-
-  it "#indexes should skip cached information if given options" do
-    @db.indexes(:table, :schema=>:b).must_equal({})
-  end 
-
-  it "Database should remove cached indexes when schema is changed" do
-    @db.create_table(:table){Integer :a}
-    @db.indexes(:table).must_equal({})
-  end
-
-  it "Database#freeze should allow cached information to work" do
-    @db.freeze.indexes(:table).must_equal @indexes['"table"']
-  end
-  
-  it "Database#freeze should allow removing index information" do
-    @db.freeze
-    @db.create_table(:table){Integer :a}
-    @db.indexes(:table).must_equal({})
-  end
-
-  it "Database#dump_index_cache should dump the index cache to the given file" do
-    File.exist?(@filename).must_equal false
-    @db.dump_index_cache(@filename)
-    File.exist?(@filename).must_equal true
-    File.size(@filename).must_be :>,  0
-  end
-
-  it "Database#load_index_cache should load the index cache from the given file dumped by #dump_index_cache" do
-    @db.dump_index_cache(@filename)
-    db = Sequel::Database.new.extension(:index_caching)
-    db.load_index_cache(@filename)
-    db.extension(:index_caching)
-    @db.instance_variable_get(:@indexes).must_equal @indexes
-  end
-
-  it "Database#dump_index_cache? should dump the index cache to the given file unless the file exists" do
-    File.open(@filename, 'wb'){|f|}
-    File.size(@filename).must_equal 0
-    @db.dump_index_cache?(@filename)
-    File.size(@filename).must_equal 0
-  end
-
-  it "Database#load_index_cache? should load the index cache from the given file if it exists" do
-    db = Sequel::Database.new.extension(:index_caching)
-    File.exist?(@filename).must_equal false
-    db.load_index_cache?(@filename)
-    db.instance_variable_get(:@indexes).must_equal({})
-  end
-end

data/spec/extensions/inflector_spec.rb

@@ -1,183 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :inflector
-
-describe String do
-  it "#camelize and #camelcase should transform the word to CamelCase" do
-    "egg_and_hams".camelize.must_equal "EggAndHams"
-    "egg_and_hams".camelize(false).must_equal "eggAndHams"
-    "post".camelize.must_equal "Post"
-    "post".camelcase.must_equal "Post"
-  end
-
-  it "#constantize should eval the string to get a constant" do
-    "String".constantize.must_equal String
-    "String::Inflections".constantize.must_equal String::Inflections
-    proc{"BKSDDF".constantize}.must_raise NameError
-    proc{"++A++".constantize}.must_raise NameError
-  end
-  
-  it "#dasherize should transform underscores to dashes" do
-    "egg_and_hams".dasherize.must_equal "egg-and-hams"
-    "post".dasherize.must_equal "post"
-  end
-  
-  it "#demodulize should remove any preceding modules" do
-    "String::Inflections::Blah".demodulize.must_equal "Blah"
-    "String::Inflections".demodulize.must_equal "Inflections"
-    "String".demodulize.must_equal "String"
-  end
-  
-  it "#humanize should remove _i, transform underscore to spaces, and capitalize" do
-    "egg_and_hams".humanize.must_equal "Egg and hams"
-    "post".humanize.must_equal "Post"
-    "post_id".humanize.must_equal "Post"
-  end
-  
-  it "#titleize and #titlecase should underscore, humanize, and capitalize all words" do
-    "egg-and: hams".titleize.must_equal "Egg And: Hams"
-    "post".titleize.must_equal "Post"
-    "post".titlecase.must_equal "Post"
-  end
-  
-  it "#underscore should add underscores between CamelCased words, change :: to / and - to _, and downcase" do
-    "EggAndHams".underscore.must_equal "egg_and_hams"
-    "EGGAndHams".underscore.must_equal "egg_and_hams"
-    "Egg::And::Hams".underscore.must_equal "egg/and/hams"
-    "post".underscore.must_equal "post"
-    "post-id".underscore.must_equal "post_id"
-  end
-
-  it "#pluralize should transform words from singular to plural" do
-    "post".pluralize.must_equal "posts"
-    "octopus".pluralize.must_equal"octopuses"
-    "the blue mailman".pluralize.must_equal "the blue mailmen"
-    "CamelOctopus".pluralize.must_equal "CamelOctopuses"
-  end
-  
-  it "#singularize should transform words from plural to singular" do
-    "posts".singularize.must_equal "post"
-    "octopuses".singularize.must_equal "octopus"
-    "the blue mailmen".singularize.must_equal "the blue mailman"
-    "CamelOctopuses".singularize.must_equal "CamelOctopus"
-  end
-  
-  it "#tableize should transform class names to table names" do
-    "RawScaledScorer".tableize.must_equal "raw_scaled_scorers"
-    "egg_and_ham".tableize.must_equal "egg_and_hams"
-    "fancyCategory".tableize.must_equal "fancy_categories"
-  end
-  
-  it "#classify should tranform table names to class names" do
-    "egg_and_hams".classify.must_equal "EggAndHam"
-    "post".classify.must_equal "Post"
-  end
-  
-  it "#foreign_key should create a foreign key name from a class name" do
-    "Message".foreign_key.must_equal "message_id"
-    "Message".foreign_key(false).must_equal "messageid"
-    "Admin::Post".foreign_key.must_equal "post_id"
-  end
-end
-
-describe String::Inflections do
-  before do
-    @plurals, @singulars, @uncountables = String.inflections.plurals.dup, String.inflections.singulars.dup, String.inflections.uncountables.dup
-  end
-  after do
-    String.inflections.plurals.replace(@plurals)
-    String.inflections.singulars.replace(@singulars)
-    String.inflections.uncountables.replace(@uncountables)
-  end
-
-  it "should be possible to clear the list of singulars, plurals, and uncountables" do
-    String.inflections.clear(:plurals)
-    String.inflections.plurals.must_equal []
-    String.inflections.plural('blah', 'blahs')
-    String.inflections.clear
-    String.inflections.plurals.must_equal []
-    String.inflections.singulars.must_equal []
-    String.inflections.uncountables.must_equal []
-  end
-
-  it "should be able to specify new inflection rules" do
-    String.inflections do |i|
-      i.plural(/xx$/i, 'xxx')
-      i.singular(/ttt$/i, 'tt')
-      i.irregular('yy', 'yyy')
-      i.uncountable(%w'zz')
-    end
-    'roxx'.pluralize.must_equal 'roxxx'
-    'rottt'.singularize.must_equal 'rott'
-    'yy'.pluralize.must_equal 'yyy'
-    'yyy'.singularize.must_equal 'yy'
-    'zz'.pluralize.must_equal 'zz'
-    'zz'.singularize.must_equal 'zz'
-  end
-
-  it "should be yielded and returned by String.inflections" do
-    String.inflections{|i| i.must_equal String::Inflections}.must_equal String::Inflections
-  end
-end
-
-describe 'Default inflections' do
-  it "should support the default inflection rules" do
-    {
-      :test=>:tests,
-      :ax=>:axes,
-      :testis=>:testes,
-      :octopus=>:octopuses,
-      :virus=>:viruses,
-      :alias=>:aliases,
-      :status=>:statuses,
-      :bus=>:buses,
-      :buffalo=>:buffaloes,
-      :tomato=>:tomatoes,
-      :datum=>:data,
-      :bacterium=>:bacteria,
-      :analysis=>:analyses,
-      :basis=>:bases,
-      :diagnosis=>:diagnoses,
-      :parenthesis=>:parentheses,
-      :prognosis=>:prognoses,
-      :synopsis=>:synopses,
-      :thesis=>:theses,
-      :wife=>:wives,
-      :giraffe=>:giraffes,
-      :self=>:selves,
-      :dwarf=>:dwarves,
-      :hive=>:hives,
-      :fly=>:flies,
-      :buy=>:buys,
-      :soliloquy=>:soliloquies,
-      :day=>:days,
-      :attorney=>:attorneys,
-      :boy=>:boys,
-      :hoax=>:hoaxes,
-      :lunch=>:lunches,
-      :princess=>:princesses,
-      :matrix=>:matrices,
-      :vertex=>:vertices,
-      :index=>:indices,
-      :mouse=>:mice,
-      :louse=>:lice,
-      :quiz=>:quizzes,
-      :motive=>:motives,
-      :movie=>:movies,
-      :series=>:series,
-      :crisis=>:crises,
-      :person=>:people,
-      :man=>:men,
-      :woman=>:women,
-      :child=>:children,
-      :sex=>:sexes,
-      :move=>:moves
-    }.each do |k, v|
-      k.to_s.pluralize.must_equal v.to_s
-      v.to_s.singularize.must_equal k.to_s
-    end
-    [:equipment, :information, :rice, :money, :species, :series, :fish, :sheep, :news].each do |a|
-      a.to_s.pluralize.must_equal a.to_s.singularize
-    end
-  end
-end