forgery 0.2.2 → 0.3.0

data/spec/{forgeries/basic_forgery_spec.rb → forgery/basic_spec.rb}

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

data/spec/{forgeries/internet_forgery_spec.rb → forgery/internet_spec.rb}

@@ -1,30 +1,30 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe InternetForgery do
+describe Forgery::Internet do
   describe ".user_name" do
     it "should return a username that is lowercase" do
-      InternetForgery.user_name.should only_contain(BasicForgery::LOWER_ALPHA)
+      Forgery::Internet.user_name.should only_contain(Forgery::Basic::LOWER_ALPHA)
     end
   end
 
   it "should return a top level domain" do
-    Forgery.dictionaries[:top_level_domains].should include(InternetForgery.top_level_domain)
+    Forgery.dictionaries[:top_level_domains].should include(Forgery::Internet.top_level_domain)
   end
 
   describe ".domain_name" do
     it "should return a domain name that contains a lowercase company name" do
-      downcase_company_name = InternetForgery.domain_name.split('.').first
+      downcase_company_name = Forgery::Internet.domain_name.split('.').first
       Forgery.dictionaries[:company_names].any?{ |cn| cn =~ /#{downcase_company_name}/i }
     end
 
     it "should return a domain name that contains a top level domain" do
-      Forgery.dictionaries[:top_level_domains].should include(InternetForgery.domain_name.split('.').last)
+      Forgery.dictionaries[:top_level_domains].should include(Forgery::Internet.domain_name.split('.').last)
     end
   end
 
   describe ".email_address" do
     it "should match the email format" do
-      InternetForgery.email_address.should match(/.+@.+\.(#{Forgery.dictionaries[:top_level_domains].join("|")})/)
+      Forgery::Internet.email_address.should match(/.+@.+\.(#{Forgery.dictionaries[:top_level_domains].join("|")})/)
     end
   end
 end

data/spec/{forgeries/lorem_ipsum_forgery_spec.rb → forgery/lorem_ipsum_spec.rb}

@@ -1,128 +1,128 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe LoremIpsumForgery do
+describe Forgery::LoremIpsum do
   describe ".paragraphs" do
     it "should return text" do
-      LoremIpsumForgery.paragraphs.should be_a_kind_of(String)
+      Forgery::LoremIpsum.paragraphs.should be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      LoremIpsumForgery.paragraphs.size.should >= 1
+      Forgery::LoremIpsum.paragraphs.size.should >= 1
     end
 
     it "should default to returning 2 paragraphs separated by \\n\\n" do
-      LoremIpsumForgery.paragraphs.split("\n\n").size.should == 2
+      Forgery::LoremIpsum.paragraphs.split("\n\n").size.should == 2
     end
 
     it "should default to returning 3 sentences per paragraph" do
-      paragraphs = LoremIpsumForgery.paragraphs.split("\n\n")
+      paragraphs = Forgery::LoremIpsum.paragraphs.split("\n\n")
       paragraphs.each do |paragraph|
         paragraph.scan(".").size.should == 3
       end
     end
 
     it "should wrap paragraphs in html paragraph tags when the :html option is true" do
-      paragraphs = LoremIpsumForgery.paragraphs(2, :html => true).split("\n\n")
+      paragraphs = Forgery::LoremIpsum.paragraphs(2, :html => true).split("\n\n")
       paragraphs.each do |paragraph|
         paragraph.should match(/<p>.+?<\/p>/)
       end
     end
 
     it "should wrap paragraphs in specified wrapping text" do
-      paragraphs = LoremIpsumForgery.paragraphs(2, :wrap => {:start => "foo", :end => "bar"}).split("\n\n")
+      paragraphs = Forgery::LoremIpsum.paragraphs(2, :wrap => {:start => "foo", :end => "bar"}).split("\n\n")
       paragraphs.each do |paragraph|
         paragraph.should match(/foo.+bar/)
       end
     end
 
     it "should separate paragraphs with the specified string" do
-      LoremIpsumForgery.paragraphs(2, :separator => "foo").split("foo").size.should == 2
+      Forgery::LoremIpsum.paragraphs(2, :separator => "foo").split("foo").size.should == 2
     end
   end
 
   describe ".paragraph" do
     it "should return text" do
-      LoremIpsumForgery.paragraph.should be_a_kind_of(String)
+      Forgery::LoremIpsum.paragraph.should be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      LoremIpsumForgery.paragraph.size.should >= 1
+      Forgery::LoremIpsum.paragraph.size.should >= 1
     end
 
     it "should return a single paragraph" do
-      LoremIpsumForgery.paragraph.scan("\n\n").size.should == 0
+      Forgery::LoremIpsum.paragraph.scan("\n\n").size.should == 0
     end
   end
 
   describe ".sentences" do
     it "should return text" do
-      LoremIpsumForgery.sentences.should be_a_kind_of(String)
+      Forgery::LoremIpsum.sentences.should be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      LoremIpsumForgery.sentences.size.should >= 1
+      Forgery::LoremIpsum.sentences.size.should >= 1
     end
 
     it "should return two sentences by default" do
-      LoremIpsumForgery.sentences.scan(".").size.should == 2
+      Forgery::LoremIpsum.sentences.scan(".").size.should == 2
     end
 
     it "should return as many sentences as you specify" do
-      LoremIpsumForgery.sentences(4).scan(".").size.should == 4
+      Forgery::LoremIpsum.sentences(4).scan(".").size.should == 4
     end
   end
 
   describe ".sentence" do
     it "should return text" do
-      LoremIpsumForgery.sentence.should be_a_kind_of(String)
+      Forgery::LoremIpsum.sentence.should be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      LoremIpsumForgery.sentence.size.should >= 1
+      Forgery::LoremIpsum.sentence.size.should >= 1
     end
 
     it "should return a single sentence" do
-      LoremIpsumForgery.sentence.scan(".").size.should == 1
+      Forgery::LoremIpsum.sentence.scan(".").size.should == 1
     end
   end
 
   describe ".words" do
     it "should return text" do
-      LoremIpsumForgery.words.should be_a_kind_of(String)
+      Forgery::LoremIpsum.words.should be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      LoremIpsumForgery.words.size.should >= 1
+      Forgery::LoremIpsum.words.size.should >= 1
     end
   end
 
   describe ".word" do
     it "should return text" do
-      LoremIpsumForgery.word.should be_a_kind_of(String)
+      Forgery::LoremIpsum.word.should be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      LoremIpsumForgery.word.size.should >= 1
+      Forgery::LoremIpsum.word.size.should >= 1
     end
   end
 
   describe ".characters" do
     it "should return text" do
-      LoremIpsumForgery.characters.should be_a_kind_of(String)
+      Forgery::LoremIpsum.characters.should be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      LoremIpsumForgery.characters.size.should >= 1
+      Forgery::LoremIpsum.characters.size.should >= 1
     end
   end
 
   describe ".character" do
     it "should return text" do
-      LoremIpsumForgery.character.should be_a_kind_of(String)
+      Forgery::LoremIpsum.character.should be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      LoremIpsumForgery.character.size.should >= 1
+      Forgery::LoremIpsum.character.size.should >= 1
     end
   end
 end

data/spec/{forgeries/monetary_forgery_spec.rb → forgery/monetary_spec.rb}

@@ -1,4 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe MonetaryForgery do
+describe Forgery::Monetary do
 end

data/spec/{forgeries/name_forgery_spec.rb → forgery/name_spec.rb}

@@ -1,4 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe NameForgery do
+describe Forgery::Name do
 end

data/spec/{forgeries/personal_forgery_spec.rb → forgery/personal_spec.rb}

@@ -1,15 +1,15 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe PersonalForgery do
+describe Forgery::Personal do
   describe '.gender' do
     it 'should return male or female' do
-      Forgery.dictionaries[:genders].should include(PersonalForgery.gender)
+      Forgery.dictionaries[:genders].should include(Forgery::Personal.gender)
     end
   end
   
   describe '.shirt_size' do
     it 'should return a sane size' do
-      Forgery.dictionaries[:shirt_sizes].should include(PersonalForgery.shirt_size)
+      Forgery.dictionaries[:shirt_sizes].should include(Forgery::Personal.shirt_size)
     end
   end
 end