forgery 0.2.2

data/lib/forgeries/monetary_forgery.rb

@@ -0,0 +1,13 @@
+class MonetaryForgery < Forgery
+  def self.formatted_money(options={})
+    "$%1.2f" % money(options)
+  end
+
+  def self.money(options={})
+    options = {:max => 10,
+               :min => 0}.merge(options)
+
+    value = ((options[:min] * 100)..(options[:max] * 100)).random
+    "%1.2f" % (value.to_f / 100)
+  end
+end

data/lib/forgeries/name_forgery.rb

@@ -0,0 +1,34 @@
+class NameForgery < Forgery
+
+  def self.last_name
+    dictionaries[:last_names].random
+  end
+
+  def self.first_name
+    [dictionaries[:male_first_names], dictionaries[:female_first_names]].random.random
+  end
+
+  def self.full_name
+    "#{self.first_name} #{self.last_name}"
+  end
+
+  def self.male_first_name
+    dictionaries[:male_first_names].random
+  end
+
+  def self.female_first_name
+    dictionaries[:female_first_names].random
+  end
+
+  def self.company_name
+    dictionaries[:company_names].random
+  end
+
+  def self.title
+    dictionaries[:name_titles].random
+  end
+
+  def self.suffix
+    dictionaries[:name_suffixes].random
+  end
+end

data/lib/forgeries/personal_forgery.rb

@@ -0,0 +1,22 @@
+class PersonalForgery < Forgery
+
+  def self.gender
+    dictionaries[:genders].random
+  end
+
+  def self.abbreviated_gender
+    gender[0,1]
+  end
+
+  def self.shirt_size
+    dictionaries[:shirt_sizes].random
+  end
+
+  def self.race
+    dictionaries[:races].random
+  end
+
+  def self.language
+    dictionaries[:languages].random
+  end
+end

data/lib/forgery.rb

@@ -0,0 +1,47 @@
+# Require forgeries at the bottom of the file so Forgery works as a gem both
+# within rails and outside of it.
+
+# Loading forgery helpers.
+require File.expand_path(File.dirname(__FILE__) + '/file_reader')
+require File.expand_path(File.dirname(__FILE__) + '/dictionaries')
+require File.expand_path(File.dirname(__FILE__) + '/formats')
+
+# Loading class extensions
+Dir[File.expand_path(File.dirname(__FILE__) + '/extensions/**/*.rb')].uniq.each do |file|
+  require file
+end
+
+class Forgery
+
+  def self.dictionaries
+    @@dictionaries ||= Dictionaries.new
+  end
+
+  def self.formats
+    @@formats ||= Formats.new
+  end
+
+end
+
+# Alternate Forgery api, see spec/forgery_spec.rb for examples.
+def Forgery(forgery, method=nil, *args)
+  klass = "#{forgery.to_s.camelize}Forgery".constantize
+  if method
+    klass.send(method, *args)
+  else
+    klass
+  end
+end
+
+# Loading the other forgeries AFTER the initial Forgery class is defined.
+Dir[File.expand_path(File.dirname(__FILE__) + '/forgeries/**/*.rb')].uniq.each do |file|
+  require file
+end
+
+# Loading rails forgeries to override current forgery methods and add new
+# forgeries
+if defined?(RAILS_ROOT)
+  Dir[File.expand_path(RAILS_ROOT + '/lib/forgery/**/*.rb')].uniq.each do |file|
+    require file
+  end
+end

data/lib/formats.rb

@@ -0,0 +1,24 @@
+class Formats
+
+  def initialize
+    @formats = {}
+  end
+
+  def [](key)
+    symbolized_key = key.to_sym
+    if @formats.has_key?(symbolized_key)
+      @formats[symbolized_key]
+    else
+      @formats[symbolized_key] = FileReader.read_format(symbolized_key)
+    end
+  end
+
+  def loaded?(key)
+    @formats.has_key?(key.to_sym)
+  end
+
+  def reset!
+    @formats = {}
+  end
+
+end

data/lib/formats/phone

@@ -0,0 +1 @@
+#-(###)###-####

data/lib/formats/street_number

@@ -0,0 +1,5 @@
+#
+##
+###
+####
+#####

data/lib/formats/zip

@@ -0,0 +1,2 @@
+#####
+#####-####

data/spec/dictionaries_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Dictionaries do
+  it "should check if the dictionary is loaded" do
+    dictionaries = Dictionaries.new
+
+    dictionaries[:colors]
+
+    dictionaries.should be_loaded(:colors)
+  end
+
+  it "should load a dictionary when called by the key" do
+    dictionaries = Dictionaries.new
+
+    dictionaries.reset!
+
+    dictionaries.should_not be_loaded(:colors)
+
+    dictionaries[:colors]
+
+    dictionaries.should be_loaded(:colors)
+  end
+
+  it "should clear the loaded dictionaries when calling reset!" do
+    dictionaries = Dictionaries.new
+
+    dictionaries[:colors]
+
+    dictionaries.should be_loaded(:colors)
+
+    dictionaries.reset!
+
+    dictionaries.should_not be_loaded(:colors)
+  end
+end

data/spec/extensions/array_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Array do
+  before do
+    @array = [0,1,2,3,4,5,6,7,8,9]
+  end
+
+  it "should get a random item out of the array" do
+    10.times { @array.should include(@array.random) }
+  end
+
+  it "should return nil if the array is empty" do
+    [].random.should be_nil
+  end
+
+  it "should return a random subset of the array" do
+    @array.random_subset(5).each do |i|
+      @array.should 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
+  end
+end

data/spec/extensions/range_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'timeout'
+
+describe Range do
+  it "should get a random number out of the range" do
+    range = (0..9)
+    10.times { range.should include(range.random) }
+  end
+
+  it "should not take a long time when the range is huge" do
+    Timeout.timeout(1){(1234567890..12345678901234567890).random}.should_not raise_error(Timeout::Error)
+  end
+
+  it "should return nil for a random number from a reverse range" do
+    10.times { (9..0).random.should be_nil }
+  end
+
+  it "should get a random string our of the range" do
+    range = ("a".."z")
+    10.times { range.should include(range.random) }
+  end
+
+  it "should return nil if the maximum is less than the minimum" do
+    ("z".."a").random.should be_nil
+  end
+end

data/spec/extensions/string_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe String do
+  it "should change a single # to a number 0-9" do
+    (0..9).should include(Integer("#".to_numbers))
+  end
+
+  it "should change two #'s to two numbers 0-9" do
+    "##".to_numbers.split("").each do |s|
+      (0..9).should include(Integer(s))
+    end
+  end
+
+  it "should only replace #'s in the string with numbers 0-9" do
+    s = '###-###-####'
+    n = s.to_numbers
+    0.upto(s.size - 1) do |i|
+      if s[i, 1] == "#"
+        ('0'..'9').should include(n[i, 1])
+      else
+        ('0'..'9').should_not include(n[i, 1])
+      end
+    end
+  end
+
+  it "should allow the replacing of a different character" do
+    (0..9).should include(Integer("-".to_numbers("-")))
+  end
+end

data/spec/file_reader_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe FileReader do
+  it "should return an array when calling read_dictionary" do
+    FileReader.read_dictionary(:colors).should be_is_a(Array)
+  end
+
+  it "should return an array when calling read_format" do
+    FileReader.read_format(:phone).should be_is_a(Array)
+  end
+end

data/spec/forgeries/address_forgery_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe AddressForgery do
+  it "should return a random street" do
+    Forgery.dictionaries[:streets].should include(AddressForgery.street_name)
+  end
+
+  it "should return a random street number" do
+    original_format = AddressForgery.street_number.gsub(/\d/, '#')
+    Forgery.formats[:street_number].should include(original_format)
+  end
+
+  it "should return a random street suffix" do
+    Forgery.dictionaries[:street_suffixes].should include(AddressForgery.street_suffix)
+  end
+
+  describe ".street_address" do
+    before do
+      @split_address = AddressForgery.street_address.split
+    end
+
+    it "should return a random street suffix" do
+      street_suffix = @split_address.pop
+      Forgery.dictionaries[:street_suffixes].should 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)
+    end
+
+    it "should return a random street" do
+      @split_address.pop
+      @split_address.shift
+      street = @split_address.join(" ")
+      Forgery.dictionaries[:streets].should include(street)
+    end
+  end
+
+  it "should return a random city" do
+    city = AddressForgery.city
+    Forgery.dictionaries[:cities].should include(city)
+  end
+
+  it "should return a random state" do
+    state = AddressForgery.state
+    Forgery.dictionaries[:states].should include(state)
+  end
+
+  it "should return a random state abbreviation" do
+    state_abbrev = AddressForgery.state_abbrev
+    Forgery.dictionaries[:state_abbrevs].should include(state_abbrev)
+  end
+
+  it "should return a random Canadian province or territory" do
+    province = AddressForgery.province
+    Forgery.dictionaries[:provinces].should include(province)
+  end
+
+  it "should return a random Canadian province or territory abbreviation" do
+    province_abbrev = AddressForgery.province_abbrev
+    Forgery.dictionaries[:province_abbrevs].should include(province_abbrev)
+  end
+
+  it "should return a random country" do
+    country = AddressForgery.country
+    Forgery.dictionaries[:countries].should include(country)
+  end
+
+  it "should return a random zip code" do
+    zip_format = AddressForgery.zip.gsub(/\d/, '#')
+    Forgery.formats[:zip].should include(zip_format)
+  end
+
+  it "should return a random phone number" do
+    phone_format = AddressForgery.phone.gsub(/\d/, '#')
+    Forgery.formats[:phone].should include(phone_format)
+  end
+end

data/spec/forgeries/basic_forgery_spec.rb

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