forgery 0.6.0 → 0.7.0

data/lib/forgery/formats/phone

@@ -1 +1 @@
-#-(###)###-####
+#-###-###-####

data/lib/forgery/version.rb

@@ -1,3 +1,3 @@
 class Forgery
-  VERSION = "0.6.0"
+  VERSION = '0.7.0'.freeze
 end

data/spec/dictionaries_spec.rb

@@ -6,7 +6,7 @@ describe Forgery::Dictionaries do
 
     dictionaries[:colors]
 
-    dictionaries.should be_loaded(:colors)
+    expect(dictionaries).to be_loaded(:colors)
   end
 
   it "should load a dictionary when called by the key" do
@@ -14,11 +14,11 @@ describe Forgery::Dictionaries do
 
     dictionaries.reset!
 
-    dictionaries.should_not be_loaded(:colors)
+    expect(dictionaries).not_to be_loaded(:colors)
 
     dictionaries[:colors]
 
-    dictionaries.should be_loaded(:colors)
+    expect(dictionaries).to be_loaded(:colors)
   end
 
   it "should clear the loaded dictionaries when calling reset!" do
@@ -26,10 +26,10 @@ describe Forgery::Dictionaries do
 
     dictionaries[:colors]
 
-    dictionaries.should be_loaded(:colors)
+    expect(dictionaries).to be_loaded(:colors)
 
     dictionaries.reset!
 
-    dictionaries.should_not be_loaded(:colors)
+    expect(dictionaries).not_to be_loaded(:colors)
   end
 end

data/spec/extensions/array_spec.rb

@@ -6,20 +6,20 @@ describe Array do
   end
 
   it "should get a random item out of the array" do
-    10.times { @array.should include(@array.random) }
+    10.times { expect(@array).to include(@array.random) }
   end
 
   it "should return nil if the array is empty" do
-    Forgery::Extend([]).random.should be_nil
+    expect(Forgery::Extend([]).random).to be_nil
   end
 
   it "should return a random subset of the array" do
     @array.random_subset(5).each do |i|
-      @array.should include(i)
+      expect(@array).to include(i)
     end
   end
 
   it "should return a random subset of the array that is 3 long" do
-    @array.random_subset(3).size.should == 3
+    expect(@array.random_subset(3).size).to eq(3)
   end
 end

data/spec/extensions/range_spec.rb

@@ -2,30 +2,32 @@ require 'spec_helper'
 require 'timeout'
 
 describe Range do
-  it "should get a random number out of the range" do
+  it 'should get a random number out of the range' do
     range = Forgery::Extend(0..9)
-    10.times { range.should include(range.random) }
+    10.times { expect(range).to include(range.random) }
   end
 
-  it "should not take a long time when the range is huge" do
-    Timeout.timeout(1){Forgery::Extend(1234567890..12345678901234567890).random}.should_not raise_error(Timeout::Error)
+  it 'should not take a long time when the range is huge' do
+    expect do
+      Timeout.timeout(1) { Forgery::Extend(1_234_567_890..12_345_678_901_234_567_890).random }
+    end.not_to raise_error
   end
 
-  it "should return nil for a random number from a reverse range" do
-    10.times { Forgery::Extend(9..0).random.should be_nil }
+  it 'should return nil for a random number from a reverse range' do
+    10.times { expect(Forgery::Extend(9..0).random).to be_nil }
   end
 
-  it "should get a random string our of the range" do
-    range = Forgery::Extend("a".."z")
-    10.times { range.should include(range.random) }
+  it 'should get a random string our of the range' do
+    range = Forgery::Extend('a'..'z')
+    10.times { expect(range).to include(range.random) }
   end
 
-  it "should return nil if the maximum is less than the minimum" do
-    Forgery::Extend("z".."a").random.should be_nil
+  it 'should return nil if the maximum is less than the minimum' do
+    expect(Forgery::Extend('z'..'a').random).to be_nil
   end
 
-  it "should not return the maximum at excluded range" do
-    Kernel.should_receive(:rand).with(9).and_return(8)
-    Forgery::Extend(0...9).random.should_not be_equal 9
+  it 'should not return the maximum at excluded range' do
+    expect(Random).to receive(:rand).with(0...9).and_return(8)
+    expect(Forgery::Extend(0...9).random).to_not eq(9)
   end
 end

data/spec/extensions/string_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe String do
   it "should change a single # to a number 0-9" do
-    (0..9).should include(Integer(Forgery::Extend("#").to_numbers))
+    expect(0..9).to include(Integer(Forgery::Extend("#").to_numbers))
   end
 
   it "should change two #'s to two numbers 0-9" do
     Forgery::Extend("##").to_numbers.split("").each do |s|
-      (0..9).should include(Integer(s))
+      expect(0..9).to include(Integer(s))
     end
   end
 
@@ -16,14 +16,14 @@ describe String do
     n = s.to_numbers
     0.upto(s.size - 1) do |i|
       if s[i, 1] == "#"
-        ('0'..'9').should include(n[i, 1])
+        expect('0'..'9').to include(n[i, 1])
       else
-        ('0'..'9').should_not include(n[i, 1])
+        expect('0'..'9').not_to include(n[i, 1])
       end
     end
   end
 
   it "should allow the replacing of a different character" do
-    (0..9).should include(Integer(Forgery::Extend("-").to_numbers("-")))
+    expect(0..9).to include(Integer(Forgery::Extend("-").to_numbers("-")))
   end
 end

data/spec/file_reader_spec.rb

@@ -2,27 +2,27 @@ require 'spec_helper'
 
 describe Forgery::FileReader do
   it "should return an array when calling read_dictionary" do
-    Forgery::FileReader.read_dictionary(:colors).should be_is_a(Array)
+    expect(Forgery::FileReader.read_dictionary(:colors)).to be_is_a(Array)
   end
 
   it "should return an array when calling read_format" do
-    Forgery::FileReader.read_format(:phone).should be_is_a(Array)
+    expect(Forgery::FileReader.read_format(:phone)).to be_is_a(Array)
   end
 
   it "should override default dictionaries if Forgery#load_from! was called" do
     Forgery.load_from! "spec/data"
-    Forgery::FileReader.read_dictionary(:female_first_names).should == %w(Amber)
+    expect(Forgery::FileReader.read_dictionary(:female_first_names)).to eq(%w(Amber))
   end
 
   it "should read dictionaries from custom places if Forgery#load_from! was called" do
     Forgery.load_from! "spec/data"
-    Forgery::FileReader.read_dictionary(:code_names).should include('Shiretoko')
+    expect(Forgery::FileReader.read_dictionary(:code_names)).to include('Shiretoko')
   end
 
   it "should raise an exception if file wasn't found in load paths" do
-    lambda {
+    expect {
       Forgery::FileReader.read_dictionary(:non_existing_dictionary)
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
   after do
     # reset load_paths

data/spec/forgery/address_spec.rb

@@ -2,16 +2,16 @@ require 'spec_helper'
 
 describe Forgery::Address do
   it "should return a random street" do
-    Forgery.dictionaries[:streets].should include(Forgery::Address.street_name)
+    expect(Forgery.dictionaries[:streets]).to include(Forgery::Address.street_name)
   end
 
   it "should return a random street number" do
     original_format = Forgery::Address.street_number.gsub(/\d/, '#')
-    Forgery.formats[:street_number].should include(original_format)
+    expect(Forgery.formats[:street_number]).to include(original_format)
   end
 
   it "should return a random street suffix" do
-    Forgery.dictionaries[:street_suffixes].should include(Forgery::Address.street_suffix)
+    expect(Forgery.dictionaries[:street_suffixes]).to include(Forgery::Address.street_suffix)
   end
 
   describe ".street_address" do
@@ -21,64 +21,64 @@ describe Forgery::Address do
 
     it "should return a random street suffix" do
       street_suffix = @split_address.pop
-      Forgery.dictionaries[:street_suffixes].should include(street_suffix)
+      expect(Forgery.dictionaries[:street_suffixes]).to include(street_suffix)
     end
 
     it "should return a random street number" do
       street_number_format = @split_address.shift.gsub(/\d/, '#')
-      Forgery.formats[:street_number].should include(street_number_format)
+      expect(Forgery.formats[:street_number]).to include(street_number_format)
     end
 
     it "should return a random street" do
       @split_address.pop
       @split_address.shift
       street = @split_address.join(" ")
-      Forgery.dictionaries[:streets].should include(street)
+      expect(Forgery.dictionaries[:streets]).to include(street)
     end
   end
 
   it "should return a random city" do
     city = Forgery::Address.city
-    Forgery.dictionaries[:cities].should include(city)
+    expect(Forgery.dictionaries[:cities]).to include(city)
   end
 
   it "should return a random state" do
     state = Forgery::Address.state
-    Forgery.dictionaries[:states].should include(state)
+    expect(Forgery.dictionaries[:states]).to include(state)
   end
 
   it "should return a random state abbreviation" do
     state_abbrev = Forgery::Address.state_abbrev
-    Forgery.dictionaries[:state_abbrevs].should include(state_abbrev)
+    expect(Forgery.dictionaries[:state_abbrevs]).to include(state_abbrev)
   end
 
   it "should return a random Canadian province or territory" do
     province = Forgery::Address.province
-    Forgery.dictionaries[:provinces].should include(province)
+    expect(Forgery.dictionaries[:provinces]).to include(province)
   end
 
   it "should return a random Canadian province or territory abbreviation" do
     province_abbrev = Forgery::Address.province_abbrev
-    Forgery.dictionaries[:province_abbrevs].should include(province_abbrev)
+    expect(Forgery.dictionaries[:province_abbrevs]).to include(province_abbrev)
   end
 
   it "should return a random country" do
     country = Forgery::Address.country
-    Forgery.dictionaries[:countries].should include(country)
+    expect(Forgery.dictionaries[:countries]).to include(country)
   end
 
   it "should return a random continent" do
     continent = Forgery::Address.continent
-    Forgery.dictionaries[:continents].should include(continent)
+    expect(Forgery.dictionaries[:continents]).to include(continent)
   end
 
   it "should return a random zip code" do
     zip_format = Forgery::Address.zip.gsub(/\d/, '#')
-    Forgery.formats[:zip].should include(zip_format)
+    expect(Forgery.formats[:zip]).to include(zip_format)
   end
 
   it "should return a random phone number" do
     phone_format = Forgery::Address.phone.gsub(/\d/, '#')
-    Forgery.formats[:phone].should include(phone_format)
+    expect(Forgery.formats[:phone]).to include(phone_format)
   end
 end

data/spec/forgery/bank_account_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Forgery::BankAccount do
+
+  describe 'ibans' do
+    it 'returns a random iban' do
+      expect(Forgery.dictionaries[:ibans]).to include(Forgery::BankAccount.iban)
+    end
+  end
+
+  describe 'bics' do
+    it 'returns a random bic' do
+      expect(Forgery.dictionaries[:bics]).to include(Forgery::BankAccount.bic)
+    end
+  end
+end

data/spec/forgery/basic_spec.rb

@@ -3,54 +3,54 @@ require 'spec_helper'
 describe Forgery::Basic do
   describe ".password" do
     it "should only uppercase characters" do
-      Forgery::Basic.password(:allow_lower => false,
+      expect(Forgery::Basic.password(:allow_lower => false,
                             :allow_upper => true,
                             :allow_numeric => false,
-                            :allow_special => false).should only_contain(Forgery::Basic::UPPER_ALPHA)
+                            :allow_special => false)).to only_contain(Forgery::Basic::UPPER_ALPHA)
     end
 
     it "should only contain lowercase characters" do
-      Forgery::Basic.password(:allow_lower => true,
+      expect(Forgery::Basic.password(:allow_lower => true,
                             :allow_upper => false,
                             :allow_numeric => false,
-                            :allow_special => false).should only_contain(Forgery::Basic::LOWER_ALPHA)
+                            :allow_special => false)).to only_contain(Forgery::Basic::LOWER_ALPHA)
     end
 
     it "should only contain numeric characters" do
-      Forgery::Basic.password(:allow_lower => false,
+      expect(Forgery::Basic.password(:allow_lower => false,
                             :allow_upper => false,
                             :allow_numeric => true,
-                            :allow_special => false).should only_contain(Forgery::Basic::NUMERIC)
+                            :allow_special => false)).to only_contain(Forgery::Basic::NUMERIC)
     end
 
     it "should only contain special characters" do
-      Forgery::Basic.password(:allow_lower => false,
+      expect(Forgery::Basic.password(:allow_lower => false,
                             :allow_upper => false,
                             :allow_numeric => false,
-                            :allow_special => true).should only_contain(Forgery::Basic::SPECIAL_CHARACTERS)
+                            :allow_special => true)).to only_contain(Forgery::Basic::SPECIAL_CHARACTERS)
     end
 
     it "should only contain lower and uppercase characters" do
-      Forgery::Basic.password(:allow_lower => true,
+      expect(Forgery::Basic.password(:allow_lower => true,
                             :allow_upper => true,
                             :allow_numeric => false,
-                            :allow_special => false).should only_contain(Forgery::Basic::LOWER_ALPHA,
+                            :allow_special => false)).to only_contain(Forgery::Basic::LOWER_ALPHA,
                                                                          Forgery::Basic::UPPER_ALPHA)
     end
 
     it "should only contain numeric and special characters" do
-      Forgery::Basic.password(:allow_lower => false,
+      expect(Forgery::Basic.password(:allow_lower => false,
                             :allow_upper => false,
                             :allow_numeric => true,
-                            :allow_special => true).should only_contain(Forgery::Basic::NUMERIC,
+                            :allow_special => true)).to only_contain(Forgery::Basic::NUMERIC,
                                                                         Forgery::Basic::SPECIAL_CHARACTERS)
     end
 
     it "should contain any of the defined characters" do
-      Forgery::Basic.password(:allow_lower => true,
+      expect(Forgery::Basic.password(:allow_lower => true,
                             :allow_upper => true,
                             :allow_numeric => true,
-                            :allow_special => true).should only_contain(Forgery::Basic::NUMERIC,
+                            :allow_special => true)).to only_contain(Forgery::Basic::NUMERIC,
                                                                         Forgery::Basic::SPECIAL_CHARACTERS,
                                                                         Forgery::Basic::LOWER_ALPHA,
                                                                         Forgery::Basic::UPPER_ALPHA)
@@ -59,118 +59,118 @@ describe Forgery::Basic do
 
   describe ".encrypt" do
     it "should encrypt to hex digits" do
-      Forgery::Basic.encrypt("something").should only_contain(Forgery::Basic::HEX_DIGITS)
+      expect(Forgery::Basic.encrypt("something")).to only_contain(Forgery::Basic::HEX_DIGITS)
     end
 
     it "should encrypt different words to different output" do
-      Forgery::Basic.encrypt("foo").should_not == Forgery::Basic.encrypt("bar")
+      expect(Forgery::Basic.encrypt("foo")).not_to eq(Forgery::Basic.encrypt("bar"))
     end
 
     it "should allow a salt that changes the output" do
-      Forgery::Basic.encrypt("foo", "baz").should_not == Forgery::Basic.encrypt("foo", "bar")
+      expect(Forgery::Basic.encrypt("foo", "baz")).not_to eq(Forgery::Basic.encrypt("foo", "bar"))
     end
 
     it "should have the same output when encrypting twice" do
-      Forgery::Basic.encrypt("foo", "bar").should == Forgery::Basic.encrypt("foo", "bar")
+      expect(Forgery::Basic.encrypt("foo", "bar")).to eq(Forgery::Basic.encrypt("foo", "bar"))
     end
   end
 
   describe ".boolean" do
     it "should return true or false" do
-      [true, false].should include(Forgery::Basic.boolean)
+      expect([true, false]).to include(Forgery::Basic.boolean)
     end
   end
 
   describe ".color" do
     it "should return a random color" do
-      Forgery.dictionaries[:colors].should include(Forgery::Basic.color)
+      expect(Forgery.dictionaries[:colors]).to include(Forgery::Basic.color)
     end
   end
 
   describe ".hex_color" do
     it "should return a 6-character hex color" do
-      Forgery::Basic.hex_color.should match(/#(#{Forgery::Basic::HEX_DIGITS.join('|')}){6}/)
+      expect(Forgery::Basic.hex_color).to match(/#(#{Forgery::Basic::HEX_DIGITS.join('|')}){6}/)
     end
   end
 
   describe ".short_hex_color" do
     it "should return a 3-character hex color" do
-      Forgery::Basic.short_hex_color.should match(/#(#{Forgery::Basic::HEX_DIGITS.join('|')}){3}/)
+      expect(Forgery::Basic.short_hex_color).to match(/#(#{Forgery::Basic::HEX_DIGITS.join('|')}){3}/)
     end
   end
 
   describe ".number" do
     it "should return a number >= the at_least option" do
-      Forgery::Basic.number(:at_least => 2).should >= 2
+      expect(Forgery::Basic.number(:at_least => 2)).to be >= 2
     end
 
     it "should return a number <= the at_most option" do
-      Forgery::Basic.number(:at_most => 12).should <= 12
+      expect(Forgery::Basic.number(:at_most => 12)).to be <= 12
     end
   end
 
   describe ".text" do
     it "should return text whose length is >= the at_least option" do
-      Forgery::Basic.text(:at_least => 5).size.should >= 5
+      expect(Forgery::Basic.text(:at_least => 5).size).to be >= 5
     end
 
     it "should return text whose length is <= the at_most option" do
-      Forgery::Basic.text(:at_most => 15).size.should <= 15
+      expect(Forgery::Basic.text(:at_most => 15).size).to be <= 15
     end
     
     it "should return text whose length is == the exactly option" do
-      Forgery::Basic.text(:exactly => 20).size.should == 20
+      expect(Forgery::Basic.text(:exactly => 20).size).to eq(20)
     end
 
     it "should only uppercase characters" do
-      Forgery::Basic.text(:allow_lower => false,
+      expect(Forgery::Basic.text(:allow_lower => false,
                         :allow_upper => true,
                         :allow_numeric => false,
-                        :allow_special => false).should only_contain(Forgery::Basic::UPPER_ALPHA)
+                        :allow_special => false)).to only_contain(Forgery::Basic::UPPER_ALPHA)
     end
 
     it "should only contain lowercase characters" do
-      Forgery::Basic.text(:allow_lower => true,
+      expect(Forgery::Basic.text(:allow_lower => true,
                         :allow_upper => false,
                         :allow_numeric => false,
-                        :allow_special => false).should only_contain(Forgery::Basic::LOWER_ALPHA)
+                        :allow_special => false)).to only_contain(Forgery::Basic::LOWER_ALPHA)
     end
 
     it "should only contain numeric characters" do
-      Forgery::Basic.text(:allow_lower => false,
+      expect(Forgery::Basic.text(:allow_lower => false,
                         :allow_upper => false,
                         :allow_numeric => true,
-                        :allow_special => false).should only_contain(Forgery::Basic::NUMERIC)
+                        :allow_special => false)).to only_contain(Forgery::Basic::NUMERIC)
     end
 
     it "should only contain special characters" do
-      Forgery::Basic.text(:allow_lower => false,
+      expect(Forgery::Basic.text(:allow_lower => false,
                         :allow_upper => false,
                         :allow_numeric => false,
-                        :allow_special => true).should only_contain(Forgery::Basic::SPECIAL_CHARACTERS)
+                        :allow_special => true)).to only_contain(Forgery::Basic::SPECIAL_CHARACTERS)
     end
 
     it "should only contain lower and uppercase characters" do
-      Forgery::Basic.text(:allow_lower => true,
+      expect(Forgery::Basic.text(:allow_lower => true,
                         :allow_upper => true,
                         :allow_numeric => false,
-                        :allow_special => false).should only_contain(Forgery::Basic::LOWER_ALPHA,
+                        :allow_special => false)).to only_contain(Forgery::Basic::LOWER_ALPHA,
                                                                      Forgery::Basic::UPPER_ALPHA)
     end
 
     it "should only contain numeric and special characters" do
-      Forgery::Basic.text(:allow_lower => false,
+      expect(Forgery::Basic.text(:allow_lower => false,
                         :allow_upper => false,
                         :allow_numeric => true,
-                        :allow_special => true).should only_contain(Forgery::Basic::NUMERIC,
+                        :allow_special => true)).to only_contain(Forgery::Basic::NUMERIC,
                                                                     Forgery::Basic::SPECIAL_CHARACTERS)
     end
 
     it "should contain any of the defined characters" do
-      Forgery::Basic.text(:allow_lower => true,
+      expect(Forgery::Basic.text(:allow_lower => true,
                         :allow_upper => true,
                         :allow_numeric => true,
-                        :allow_special => true).should only_contain(Forgery::Basic::NUMERIC,
+                        :allow_special => true)).to only_contain(Forgery::Basic::NUMERIC,
                                                                     Forgery::Basic::SPECIAL_CHARACTERS,
                                                                     Forgery::Basic::LOWER_ALPHA,
                                                                     Forgery::Basic::UPPER_ALPHA)