forgery 0.2.2

data/lib/dictionaries/top_level_domains

@@ -0,0 +1,9 @@
+biz
+com
+info
+name
+net
+org
+gov
+edu
+mil

data/lib/extensions/array.rb

@@ -0,0 +1,11 @@
+class Array
+  def random
+    self[Kernel.rand(size)]
+  end
+
+  def random_subset(len=2)
+    rs = []
+    len.times { rs << random }
+    rs
+  end
+end

data/lib/extensions/hash.rb

@@ -0,0 +1,12 @@
+class Hash
+  # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+
+  # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+  # Modifies the receiver in place.
+  def reverse_merge!(other_hash)
+    replace(reverse_merge(other_hash))
+  end
+end

data/lib/extensions/range.rb

@@ -0,0 +1,9 @@
+class Range
+  def random
+    Integer(first) && Integer(last)
+    raise ArgumentError if first > last
+    Kernel.rand(last - first + 1) + first
+  rescue ArgumentError
+    self.to_a.random
+  end
+end

data/lib/extensions/string.rb

@@ -0,0 +1,48 @@
+class String
+  def to_numbers(replace='#')
+    self.gsub(/#{replace}/){ Kernel.rand(10) }
+  end
+
+  if !defined?(RAILS_ROOT)
+    def camelize(first_letter = :upper)
+      case first_letter
+      when :upper
+        to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      when :lower
+        first.downcase + camelize(self)[1..-1]
+      end
+    end
+
+    def underscore
+      to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    if Module.method(:const_get).arity == 1
+      def constantize
+        names = self.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
+    else
+      def constantize
+        names = self.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_get(name, false) || constant.const_missing(name)
+        end
+        constant
+      end
+    end
+  end
+end

data/lib/file_reader.rb

@@ -0,0 +1,53 @@
+class FileReader
+
+  def self.read_dictionary(dictionary)
+    read_file(path_to_dictionary(dictionary))
+  end
+
+  def self.read_format(format)
+    read_file(path_to_format(format))
+  end
+
+protected
+
+  def self.read_file(file)
+    lines = []
+    IO.foreach(file) do |line|
+      lines << line.chomp unless line.chomp == ''
+    end
+    lines
+  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

data/lib/forgeries/address_forgery.rb

@@ -0,0 +1,136 @@
+# Generates random address information.
+class AddressForgery < Forgery
+  # Gets a random street name out of the 'streets' dictionary.
+  #
+  #   AddressForgery.street_name
+  #   # => "Atwood"
+  #
+  #   AddressForgery.street_name
+  #   # => "Fordem"
+  def self.street_name
+    dictionaries[: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
+    formats[:street_number].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
+    dictionaries[: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
+    dictionaries[:cities].random
+  end
+
+  # Gets a random state out of the 'states' dictionary.
+  #
+  #   AddressForgery.state
+  #   # => "Mississippi"
+  #
+  #   AddressForgery.state
+  #   # => "Minnesota"
+  def self.state
+    dictionaries[: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
+    dictionaries[:state_abbrevs].random
+  end
+
+  # Gets a random Canadian province or territory out of the 'provinces' dictionary.
+  #
+  #   AddressForgery.province
+  #   # => "Ontario"
+  #
+  #   AddressForgery.province
+  #   # => "Northwest Territories"
+  def self.province
+    dictionaries[:provinces].random
+  end
+
+  # Gets a random Canadian province or territory abbreviation out of the 'province_abbrev' dictionary.
+  #
+  #   AddressForgery.province_abbrev
+  #   # => "ON"
+  #
+  #   AddressForgery.province_abbrev
+  #   # => "NT"
+  def self.province_abbrev
+    dictionaries[:province_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
+    formats[:zip].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
+    formats[:phone].random.to_numbers
+  end
+
+  # Gets a random country out of the 'countries' dictionary.
+  #
+  #   AddressForgery.country
+  #   # => "Uruguay"
+  #
+  #   AddressForgery.country
+  #   # => "Romania"
+  def self.country
+    dictionaries[:countries].random
+  end
+end

data/lib/forgeries/basic_forgery.rb

@@ -0,0 +1,71 @@
+require 'digest/sha1'
+
+class BasicForgery < Forgery
+  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
+    dictionaries[: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
+    dictionaries[:frequencies].random
+  end
+end

data/lib/forgeries/internet_forgery.rb

@@ -0,0 +1,17 @@
+class InternetForgery < Forgery
+  def self.user_name
+    (dictionaries[:male_first_names].random[0,1] + dictionaries[:last_names].random).downcase
+  end
+
+  def self.top_level_domain
+    dictionaries[:top_level_domains].random
+  end
+
+  def self.domain_name
+    dictionaries[: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,112 @@
+class LoremIpsumForgery < Forgery
+
+  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 => (dictionaries[:lorem_ipsum].length-quantity)) if quantity.is_a?(Fixnum)
+
+    dictionaries[: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 => (dictionaries[: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] +
+        dictionaries[: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
+
+  def self.lorem_ipsum_words
+    @@lorem_ipsum_words ||= dictionaries[:lorem_ipsum].join(" ").downcase.gsub(/\.|,|;/, '').split(" ")
+  end
+
+  def self.lorem_ipsum_characters
+    @@lorem_ipsum_characters ||= dictionaries[:lorem_ipsum].join("").downcase.gsub(/[^a-z\s]/,'')
+  end
+
+end