sevenwire-forgery 0.1.0

data/lib/forgeries/address_forgery.rb

@@ -0,0 +1,117 @@
+# Generates random address information.
+class AddressForgery < Forgery
+  dictionaries :streets, :street_suffixes, :cities, :states, :state_abbrevs, :countries
+  formats :zip, :phone, :street_number
+
+  # Gets a random street name out of the 'streets' dictionary.
+  #
+  #   AddressForgery.street_name
+  #   # => "Atwood"
+  #
+  #   AddressForgery.street_name
+  #   # => "Fordem"
+  def self.street_name
+    STREETS.random
+  end
+
+  # Gets one of the formats from 'street_number_formats' and converts it to
+  # numbers.
+  #
+  #   AddressForgery.street_number
+  #   # => 1
+  #
+  #   AddressForgery.street_number
+  #   # => 1234
+  def self.street_number
+    STREET_NUMBER_FORMATS.random.to_numbers
+  end
+
+  # Gets a random street suffix out of the 'street_suffixes' dictionary.
+  #
+  #   AddressForgery.street_suffix
+  #   # => "Street"
+  #
+  #   AddressForgery.street_suffix
+  #   # => "Parkway"
+  def self.street_suffix
+    STREET_SUFFIXES.random
+  end
+
+  # Gets a full street address, including street number, street name, and
+  # street suffix.
+  #
+  #   AddressForgery.street_address
+  #   # => "92 West Circle"
+  #
+  #   AddressForgery.street_address
+  #   # => "93265 Harper Lane"
+  def self.street_address
+    "#{street_number} #{street_name} #{street_suffix}"
+  end
+
+  # Gets a random city out of the 'cities' dictionary.
+  #
+  #   AddressForgery.city
+  #   # => "Anaheim"
+  #
+  #   AddressForgery.city
+  #   # => "Sacramento"
+  def self.city
+    CITIES.random
+  end
+
+  # Gets a random state out of the 'states' dictionary.
+  #
+  #   AddressForgery.state
+  #   # => "Mississippi"
+  #
+  #   AddressForgery.state
+  #   # => "Minnesota"
+  def self.state
+    STATES.random
+  end
+
+  # Gets a random state abbreviation out of the 'state_abbrev' dictionary.
+  #
+  #   AddressForgery.state_abbrev
+  #   # => "GA"
+  #
+  #   AddressForgery.state_abbrev
+  #   # => "TX"
+  def self.state_abbrev
+    STATE_ABBREVS.random
+  end
+
+  # Gets one of the formats from 'zip_formats' and converts it to numbers.
+  #
+  #   AddressForgery.zip
+  #   # => "52474"
+  #
+  #   AddressForgery.zip
+  #   # => "66702-4349"
+  def self.zip
+    ZIP_FORMATS.random.to_numbers
+  end
+
+  # Gets one of the formats from 'phone_formats' and converts it to numbers.
+  #
+  #   AddressForgery.phone
+  #   # => "1-(416)185-8799"
+  #
+  #   AddressForgery.phone
+  #   # => "1-(589)248-0418"
+  def self.phone
+    PHONE_FORMATS.random.to_numbers
+  end
+
+  # Gets a random country out of the 'countries' dictionary.
+  #
+  #   AddressForgery.country
+  #   # => "Uruguay"
+  #
+  #   AddressForgery.country
+  #   # => "Romania"
+  def self.country
+    COUNTRIES.random
+  end
+end

data/lib/forgeries/basic_forgery.rb

@@ -0,0 +1,73 @@
+require 'digest/sha1'
+
+class BasicForgery < Forgery
+  dictionaries :colors, :frequencies
+
+  HEX_DIGITS = %w{0 1 2 3 4 5 6 7 8 9 a b c d e f}
+  UPPER_ALPHA = ('A'..'Z').to_a
+  LOWER_ALPHA = ('a'..'z').to_a
+  NUMERIC = ('0'..'9').to_a
+  SPECIAL_CHARACTERS = %w{! ' @ # $ % ^ & * ( ) _ + - = [ ] { } ; : " , . / ?}
+  BOOLEAN = [true, false]
+
+  def self.password(options={})
+    options = {:at_least => 6,
+               :at_most => 12,
+               :allow_lower => true,
+               :allow_upper => true,
+               :allow_numeric => true,
+               :allow_special => false}.merge!(options)
+    self.text(options)
+  end
+
+  def self.encrypt(password="password", salt=Time.now.to_s)
+    Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+  end
+
+  def self.boolean
+    BOOLEAN.random
+  end
+
+  def self.color
+    COLORS.random
+  end
+
+  def self.hex_color
+    hex_digits = (1..6).collect { HEX_DIGITS.random}
+    "##{hex_digits.join}"
+  end
+
+  def self.short_hex_color
+    hex_color[0,4]
+  end
+
+  def self.number(options={})
+    options = {:at_least => 1,
+               :at_most => 10}.merge(options)
+
+    (options[:at_least]..options[:at_most]).random
+  end
+
+  def self.text(options={})
+    options = {:at_least => 10,
+               :at_most => 15,
+               :allow_lower => true,
+               :allow_upper => true,
+               :allow_numeric => true,
+               :allow_special => false}.merge!(options)
+
+    allowed_characters = []
+    allowed_characters += LOWER_ALPHA if options[:allow_lower]
+    allowed_characters += UPPER_ALPHA if options[:allow_upper]
+    allowed_characters += NUMERIC if options[:allow_numeric]
+    allowed_characters += SPECIAL_CHARACTERS if options[:allow_special]
+
+    length = (options[:at_least]..options[:at_most]).random
+
+    allowed_characters.random_subset(length).join
+  end
+
+  def self.frequency
+    FREQUENCIES.random
+  end
+end

data/lib/forgeries/internet_forgery.rb

@@ -0,0 +1,19 @@
+class InternetForgery < Forgery
+  dictionaries :male_first_names, :female_first_names, :last_names, :top_level_domains, :company_names
+
+  def self.user_name
+    (MALE_FIRST_NAMES.random[0,1] + LAST_NAMES.random).downcase
+  end
+
+  def self.top_level_domain
+    TOP_LEVEL_DOMAINS.random
+  end
+
+  def self.domain_name
+    COMPANY_NAMES.random.downcase + '.' + self.top_level_domain
+  end
+  
+  def self.email_address
+    self.user_name + '@' + self.domain_name
+  end
+end

data/lib/forgeries/lorem_ipsum_forgery.rb

@@ -0,0 +1,107 @@
+class LoremIpsumForgery < Forgery
+  dictionaries :lorem_ipsum
+  LOREM_IPSUM_WORDS = LOREM_IPSUM.join(" ").downcase.gsub(/\.|,|;/, '').split(" ")
+  LOREM_IPSUM_CHARACTERS = LOREM_IPSUM.join("").downcase.gsub(/[^a-z\s]/,'')
+
+  def self.text(what=:sentence, quantity=2, options={})
+    case what
+    when :character
+      self.character(options)
+    when :characters
+      self.characters(quantity, options)
+    when :word
+      self.word(options)
+    when :words
+      self.words(quantity, options)
+    when :sentence
+      self.sentence(options)
+    when :sentences
+      self.sentences(quantity, options)
+    when :paragraph
+      self.paragraph(options)
+    when :paragraphs
+      self.paragraphs(quantity, options)
+    end
+  end
+
+
+  def self.character(options={})
+    self.characters(1, options)
+  end
+
+  def self.characters(quantity=10, options={})
+    options.merge!(:random_limit => LOREM_IPSUM_CHARACTERS.length-quantity) if quantity.is_a?(Fixnum)
+
+    LOREM_IPSUM_CHARACTERS[range_from_quantity(quantity, options)]
+  end
+
+  def self.word(options={})
+    self.words(1, options)
+  end
+
+  def self.words(quantity=10, options={})
+    options.merge!(:random_limit => LOREM_IPSUM_WORDS.length-quantity) if quantity.is_a?(Fixnum)
+
+    LOREM_IPSUM_WORDS[range_from_quantity(quantity, options)].join(" ")
+  end
+
+  def self.sentence(options={})
+    self.sentences(1, options)
+  end
+
+  def self.sentences(quantity=2, options={})
+    options.merge!(:random_limit => (LOREM_IPSUM.length-quantity)) if quantity.is_a?(Fixnum)
+
+    LOREM_IPSUM[range_from_quantity(quantity, options)].join(" ")
+  end
+
+  def self.paragraph(options={})
+    self.paragraphs(1, options)
+  end
+
+  def self.paragraphs(quantity=2, options={})
+    options.reverse_merge!(:separator => "\n\n",
+                           :wrap => {
+                             :start => "",
+                             :end => "" },
+                           :html => false,
+                           :sentences => 3)
+    options.merge!(:random_limit => (LOREM_IPSUM.length/options[:sentences])-quantity) if quantity.is_a?(Fixnum)
+
+    if options[:html]
+      options[:wrap] = { :start => "<p>",
+                         :end => "</p>" }
+    end
+
+    range = range_from_quantity(quantity, options)
+    start = range.first * options[:sentences]
+
+    paragraphs = []
+
+    range.to_a.length.times do |i|
+      paragraphs << (
+        options[:wrap][:start] +
+        LOREM_IPSUM[start..(start+options[:sentences]-1)].join(" ") +
+        options[:wrap][:end]
+      )
+      start += options[:sentences]
+    end
+
+    paragraphs.join(options[:separator])
+  end
+
+
+protected
+
+  def self.range_from_quantity(quantity, options={})
+    return quantity if quantity.is_a?(Range)
+
+    if options[:random]
+      start = (0..options[:random_limit]).random
+      start..(start+quantity-1)
+    else
+      0..(quantity-1)
+    end
+  end
+  
+end

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,36 @@
+class NameForgery < Forgery
+  dictionaries :last_names, :male_first_names, :female_first_names, :company_names,
+    :name_suffixes, :name_titles
+
+  def self.last_name
+    LAST_NAMES.random
+  end
+
+  def self.first_name
+    [MALE_FIRST_NAMES, FEMALE_FIRST_NAMES].random.random
+  end
+
+  def self.full_name
+    "#{self.first_name} #{self.last_name}"
+  end
+
+  def self.male_first_name
+    MALE_FIRST_NAMES.random
+  end
+
+  def self.female_first_name
+    FEMALE_FIRST_NAMES.random
+  end
+
+  def self.company_name
+    COMPANY_NAMES.random
+  end
+
+  def self.title
+    NAME_TITLES.random
+  end
+
+  def self.suffix
+    NAME_SUFFIXES.random
+  end
+end

data/lib/forgeries/personal_forgery.rb

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

data/lib/forgery.rb

@@ -0,0 +1,82 @@
+# Require forgeries at the bottom of the file so Forgery works as a gem
+
+Dir[File.expand_path(File.dirname(__FILE__) + '/extensions/**/*.rb')].uniq.each do |file|
+  require file
+end
+
+class Forgery
+  def self.dictionaries(*dictionaries)
+    dictionaries.each do |dictionary|
+      const_set(dictionary.to_s.upcase, read_dictionary(dictionary))
+    end
+  end
+
+  def self.formats(*formats)
+    formats.each do |format|
+      const_set(format.to_s.upcase + "_FORMATS", read_format(format))
+    end
+  end
+
+protected
+
+  def self.read_file(file)
+    lines = []
+    IO.foreach(file) do |line|
+      lines << line.chomp unless line.chomp == ''
+    end
+    lines
+  end
+
+  def self.read_dictionary(dictionary)
+    read_file(path_to_dictionary(dictionary))
+  end
+
+  def self.read_format(format)
+    read_file(path_to_format(format))
+  end
+
+  def self.path_to_format(format)
+    if external_path_to_format(format) && File.exists?(external_path_to_format(format))
+      external_path_to_format(format)
+    else
+      internal_path_to_format(format)
+    end
+  end
+
+  def self.external_path_to_format(format)
+    RAILS_ROOT + '/lib/forgery/formats/' + format.to_s if defined?(RAILS_ROOT)
+  end
+
+  def self.internal_path_to_format(format)
+    File.dirname(__FILE__) + '/formats/' + format.to_s
+  end
+
+  def self.path_to_dictionary(dictionary)
+    if external_path_to_dictionary(dictionary) && File.exists?(external_path_to_dictionary(dictionary))
+      external_path_to_dictionary(dictionary)
+    else
+      internal_path_to_dictionary(dictionary)
+    end
+  end
+
+  def self.external_path_to_dictionary(dictionary)
+    RAILS_ROOT + '/lib/forgery/dictionaries/' + dictionary.to_s if defined?(RAILS_ROOT)
+  end
+
+  def self.internal_path_to_dictionary(dictionary)
+    File.dirname(__FILE__) + '/dictionaries/' + dictionary.to_s
+  end
+end
+
+def Forgery(forgery, method=nil, *args)
+  klass = "#{forgery.to_s.camelize}Forgery".constantize
+  if method
+    klass.send(method, *args)
+  else
+    klass
+  end
+end
+
+Dir[File.expand_path(File.dirname(__FILE__) + '/forgeries/**/*.rb')].uniq.each do |file|
+  require file
+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/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,17 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+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 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/forgeries/address_forgery_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe AddressForgery do
+  it "should return a random street" do
+    AddressForgery::STREETS.should include(AddressForgery.street_name)
+  end
+
+  it "should return a random street number" do
+    original_format = AddressForgery.street_number.gsub(/\d/, '#')
+    AddressForgery::STREET_NUMBER_FORMATS.should include(original_format)
+  end
+
+  it "should return a random street suffix" do
+    AddressForgery::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
+      AddressForgery::STREET_SUFFIXES.should include(street_suffix)
+    end
+
+    it "should return a random street number" do
+      street_number_format = @split_address.shift.gsub(/\d/, '#')
+      AddressForgery::STREET_NUMBER_FORMATS.should include(street_number_format)
+    end
+
+    it "should return a random street" do
+      @split_address.pop
+      @split_address.shift
+      street = @split_address.join(" ")
+      AddressForgery::STREETS.should include(street)
+    end
+  end
+
+  it "should return a random city" do
+    city = AddressForgery.city
+    AddressForgery::CITIES.should include(city)
+  end
+
+  it "should return a random state" do
+    state = AddressForgery.state
+    AddressForgery::STATES.should include(state)
+  end
+
+  it "should return a random state abbreviation" do
+    state_abbrev = AddressForgery.state_abbrev
+    AddressForgery::STATE_ABBREVS.should include(state_abbrev)
+  end
+
+  it "should return a random country" do
+    country = AddressForgery.country
+    AddressForgery::COUNTRIES.should include(country)
+  end
+
+  it "should return a random zip code" do
+    zip_format = AddressForgery.zip.gsub(/\d/, '#')
+    AddressForgery::ZIP_FORMATS.should include(zip_format)
+  end
+
+  it "should return a random phone number" do
+    phone_format = AddressForgery.phone.gsub(/\d/, '#')
+    AddressForgery::PHONE_FORMATS.should include(phone_format)
+  end
+end