pseudo_entity 0.0.1

data/lib/pseudo_entity/version.rb

@@ -0,0 +1,3 @@
+class PseudoEntity
+  VERSION = "0.0.1"
+end

data/lib/pseudo_entity.rb

@@ -0,0 +1,138 @@
+class PseudoEntity
+
+  require 'pseudo_entity/randoms'
+
+  include Enumerable
+  include Randoms
+
+  def initialize(options={})
+    parse_options options
+  end
+
+  def address
+    "#{street_address}\n#{city}, #{state}. #{zip_code}"
+  end
+
+  def age
+    Date.today.year - birth_day.year
+  end
+
+  def apartment?
+    street_modifier_needed == :apartment
+  end
+
+  def birth_year
+    birth_day.year
+  end
+
+  def credit_card_last_four
+    credit_card_number[-4..-1]
+  end
+  alias :credit_card_last4 :credit_card_last_four
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+
+  def google_map_url
+    "https://maps.google.com/maps?q=loc:#{latitude},#{longitude}"
+  end
+
+  # Reset all internal values causing them to be regenerated.
+  def reset!
+    self.instance_variables.each { |variable| instance_variable_set(variable, nil) }
+    self
+  end
+
+  def street_address
+    # Yes it is in 2-1 order because that's how the US Post Office says to do it.
+    # Apartment, Suites, etc go on the first line if there are two lines or at the end of the single line
+    # http://pe.usps.com/businessmail101/addressing/deliveryaddress.htm
+    "#{street_address_line_2} #{street_address_line_1}".strip
+  end
+
+  def street_address_line_1
+    if apartment?
+      "APT #{apartment_number}"
+    elsif suite?
+      "STE #{suite_number}"
+    else
+      street_position
+    end
+  end
+
+  def street_address_line_2
+    street_address_line_1 # Force the determination of line 1 as this effects line 2
+    street_modifier_needed? ? street_position : nil
+  end
+
+  def suite?
+    street_modifier_needed == :suite
+  end
+
+  def yelp_business_id
+    # Yelp API version 2.0 id
+    "#{company_name.gsub(' ', '-').delete('.')}-#{city.gsub(' ', '-').delete('.')}"
+  end
+
+  def yelp_business_url
+    "http://www.yelp.com/biz/#{yelp_business_id}"
+  end
+
+  def yelp_user_id
+    random_alpha_numeric(22)
+  end
+
+  def to_s
+    add = address.sub("\n","\n         ")
+    [
+        "Name: #{full_name}",
+        "Age: #{age}",
+        "Sex: #{sex}",
+        "Email: #{email_address}",
+        "IP Address: #{ip_address}",
+        "Website: #{website}",
+        "Short Url: #{short_url}",
+        "Phone: #{phone_number}",
+        "Address: #{add}",
+        "Coordinates: #{latitude}, #{longitude}",
+        "Timezone: #{time_zone}",
+        "Bank: #{bank_name} #{bank_routing_number} #{bank_account_number}",
+        "Credit Union: #{credit_union_name}",
+        "Card: #{credit_card_issuer} #{credit_card_number}",
+        "Company: #{company_name}",
+        "Slogan: #{slogan}",
+        "Tax ID: #{federal_tax_id}",
+        "Login: #{login}",
+        "Password: #{password}"
+    ].join("\n")
+  end
+
+  def self.all
+    @all = Randoms.names.map { |name| new :first_name => name.first, :last_name => name.last }
+  end
+
+  def self.each(&block)
+    all.each(&block)
+  end
+
+  def self.to_a
+    all
+  end
+
+  def self.load_caches(verbose=false)
+    entity = new
+    RandomValues.each do |method|
+      puts method if verbose
+      begin
+        entity.send(method)
+      rescue  => e
+        puts e.message
+      end
+    end
+    true
+  end
+
+end
+
+require 'pseudo_entity/version'

data/psuedo_entity.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pseudo_entity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pseudo_entity'
+  spec.version       = PseudoEntity::VERSION
+  spec.authors       = ['Frank Hall']
+  spec.email         = ['ChapterHouse.Dune@gmail.com']
+  spec.description   = %q{A class for generating realistic looking data for people, companies, etc.}
+  spec.summary       = %q{A class for generating realistic looking data for people, companies, etc.}
+  spec.homepage      = 'http://chapterhouse.github.io/pseudo_entity'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.13'
+
+  spec.add_runtime_dependency 'uuidtools', '~> 2.1'
+  spec.add_runtime_dependency 'active_support', '>= 2.0'
+  spec.add_runtime_dependency 'tzinfo'
+  spec.add_runtime_dependency 'huge_enumerable'
+
+end

data/spec/lib/pseudo_entity/randoms_spec.rb

@@ -0,0 +1,276 @@
+require 'spec_helper'
+
+describe PseudoEntity::Randoms do
+
+  RSpec::Matchers.define :be_all_digits do
+    match do |string|
+      string.gsub(/[0-9]*/,'').empty?
+    end
+  end
+
+  RSpec::Matchers.define :be_all_alphabetic_characters do
+    match do |string|
+      string.gsub(/[a-z]|[A-Z]*/,'').empty?
+    end
+  end
+
+  RSpec::Matchers.define :be_all_alphanumeric_characters do
+    match do |string|
+      string.gsub(/[a-z]|[A-Z][0-9]*/,'').empty?
+    end
+  end
+
+
+  context "when included" do
+
+    let(:class_a_regex) { /^10\.(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){2}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/ }
+    let(:class_b_regex) { /^172\.(?:(?:1[6-9]|2[0-9]|3[0-1]?)\.)(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.)(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/ }
+    let(:class_c_regex) { /^192\.168\.(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.)(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/ }
+
+    subject(:instance) do
+      klass = Class.new
+      klass.send(:include, PseudoEntity::Randoms)
+      klass.new
+    end
+
+    it "responds to all RandomValues" do
+      PseudoEntity::RandomValues.all? { |method| instance.respond_to?(method.to_sym) }.should be_true
+    end
+
+    it "lists all RandomValues as methods" do
+      (PseudoEntity::RandomValues - instance.methods).should be_empty
+    end
+
+    it "responds to ArityValues" do
+      methods = PseudoEntity::ArityValues.map { |regexp| regexp.to_s.match(/.*\^(.*_)\\d.*/)[1] + rand(100).to_s }
+      methods.all? { |method| instance.respond_to?(method.to_sym) }.should be_true
+    end
+
+    it "responds to ArityRandoms" do
+      methods = PseudoEntity::ArityRandoms.map { |regexp| regexp.to_s.match(/.*\^(.*_)\\d.*/)[1] + rand(100).to_s }
+      methods.all? { |method| instance.respond_to?(method.to_sym, true) }.should be_true
+    end
+
+    it "has private ArityRandoms" do
+      methods = PseudoEntity::ArityRandoms.map { |regexp| regexp.to_s.match(/.*\^(.*_)\\d.*/)[1] + rand(100).to_s }
+      methods.all? { |method| !instance.respond_to?(method.to_sym) }.should be_true
+    end
+
+    it "has corresponding private random_X methods for RandomValues" do
+      (PseudoEntity::RandomValues.map { |method| "random_#{method}".to_sym } - instance.private_methods).should be_empty
+    end
+
+    context "#parse_options" do
+
+      it "sets initial values" do
+        value_names = PseudoEntity::RandomValues
+        hash = value_names.inject({}) { |hsh, name| hsh[name] = "123 #{name}"; hsh}
+        instance.send(:parse_options, hash)
+        value_names.all? { |name| instance.send(name) == "123 #{name}" }.should be_true
+      end
+
+    end
+
+    context "#random_alpha" do
+
+      it "returns X characters" do
+        instance.send(:random_alpha, 256).size.should eql(256)
+      end
+
+      it "only generates alphabetic characters" do
+        instance.stub(:rand).and_return(*(0..51).to_a)
+        instance.send(:random_alpha, 256).should be_all_alphanumeric_characters
+        # If only alphabetic characters are available then nothing should show up at slot 52
+        instance.stub(:rand).and_return(52)
+        instance.send(:random_alpha, 1).size.should eq(0)
+      end
+
+    end
+
+    context "#random_alpha_numeric" do
+
+      it "returns X characters" do
+        instance.send(:random_alpha_numeric, 256).size.should eql(256)
+      end
+
+      it "only generates alphabetic characters or digits" do
+        instance.stub(:rand).and_return(*(0..61).to_a)
+        instance.send(:random_alpha, 256).should be_all_alphabetic_characters
+        # If only alphabetic characters and digits are available then nothing should show up at slot 62
+        instance.stub(:rand).and_return(62)
+        instance.send(:random_alpha_numeric, 1).size.should eq(0)
+      end
+
+    end
+
+    context "#random_apartment_number" do
+
+      it "never returns zero or less" do
+        instance.stub(:rand).and_return(0)
+        instance.send(:random_apartment_number).should > 0
+      end
+
+    end
+
+    context "#random_bank_account_number" do
+
+      it "is thirteen characters long" do
+        instance.send(:random_bank_account_number).size.should eql(13)
+      end
+
+      it "is all digits" do
+        instance.send(:random_bank_account_number).should be_all_digits
+      end
+
+    end
+
+    context "#random_bank_routing_number" do
+
+      it "is nine characters long" do
+        instance.send(:random_bank_routing_number).size.should eql(9)
+      end
+
+      it "is all digits" do
+        instance.send(:random_bank_routing_number).should be_all_digits
+      end
+
+    end
+
+    context "#random_numeric" do
+
+      it "return X characters" do
+        instance.send(:random_alpha_numeric, 256).size.should eql(256)
+      end
+
+      it "only generates digits" do
+        instance.send(:random_numeric, 256).should be_all_digits
+      end
+
+    end
+
+    context "#random_birth_day" do
+
+      it "is always be at least 21 years ago" do
+        instance.stub(:rand).and_return(0)
+        (Date.today.year - instance.send(:random_birth_day).year).should >= 21
+      end
+
+    end
+
+    context "#random_class_a_ip_address" do
+
+      it "is in the private class A range" do
+        instance.send(:random_class_a_ip_address).should =~ class_a_regex
+      end
+
+    end
+
+    context "#random_class_b_ip_address" do
+
+      it "is in the private class B range" do
+        instance.send(:random_class_b_ip_address).should =~ class_b_regex
+      end
+
+    end
+
+    context "#random_class_c_ip_address" do
+
+      it "is in the private class C range" do
+        instance.send(:random_class_c_ip_address).should =~ class_c_regex
+      end
+
+    end
+
+    context "#random_email_address" do
+
+      it "conforms to the pattern name@domain" do
+        simple_email_regex = /^.*@.*\..*$/
+        instance.send(:random_email_address) =~ simple_email_regex
+      end
+
+    end
+
+    context "#random_facebook_id" do
+
+      it "is all digits" do
+        instance.send(:random_facebook_id).should be_all_digits
+      end
+
+      it "is a maximum of 64 bits long" do
+        # This is a little brittle but not sure how else to test this
+        instance.should_receive(:rand).with(2**64).and_return(2**64)
+        instance.send(:random_facebook_id)
+      end
+
+    end
+
+    context "#random_federal_tax_id" do
+
+      it "is nine characters long" do
+        instance.send(:random_federal_tax_id).size.should eql(9)
+      end
+
+      it "is all digits" do
+        instance.send(:random_federal_tax_id).should be_all_digits
+      end
+
+    end
+
+    context "#random_google_analytics_account_id" do
+      it "conforms to Google's Analytic Account pattern" do
+        instance.send(:random_google_analytics_account_id).should =~ /^UA-\d{7}-\d{2}$/
+      end
+    end
+
+    context "#random_ip_address" do
+
+      it "is one of the non routable IP addresses" do
+        ip_address = instance.send(:random_ip_address)
+        [class_a_regex, class_b_regex, class_c_regex].any? { |regexp| ip_address =~ regexp }.should be_true
+      end
+
+    end
+
+    context "#random_phone_number" do
+
+      it "is a ten digit comma separated value" do
+        instance.send(:random_phone_number).should =~ /^[0-9]{3}-[0-9]{3}-[0-9]{4}$/
+      end
+
+    end
+
+    context  "#random_property_number" do
+
+      it "will never be less than 10" do
+        instance.stub(:rand).and_return(0)
+        instance.send(:random_property_number).should >= 10
+      end
+
+    end
+
+    context "#random_sex" do
+
+      it "will never be less than 10" do
+        instance.stub(:rand).and_return(0)
+        instance.send(:random_property_number).should >= 10
+      end
+
+    end
+
+  end
+
+  context "as itself" do
+
+    subject(:random) { PseudoEntity::Randoms }
+
+    it "should create a token smaller than 32 characters" do
+      random.token(3).size.should eq(3)
+    end
+
+    it "should create a token larger than 32 characters" do
+      random.token(128).size.should eq(128)
+    end
+
+  end
+
+end

data/spec/lib/pseudo_entity_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe PseudoEntity do
+
+  let(:age) { 10 }
+  let(:date) { age.years.ago }
+  let(:cc_last_four) { '4321' }
+  let(:latitude) { 1.2 }
+  let(:longitude) { 3.4 }
+  let(:street_position) { 'street_position' }
+  let(:company_name) { 'Some Company Ltd.'}
+  let(:city) { 'St. Archibald' }
+  let(:state) { 'ZZ' }
+  let(:zip_code) { 12345 }
+  let(:first_name) { 'John' }
+  let(:last_name) { 'Smith' }
+
+  subject(:pseudo_entity) do
+    PseudoEntity.new.tap{ |pe|
+      pe.stub(:birth_day).and_return(date)
+      pe.stub(:city).and_return(city)
+      pe.stub(:state).and_return(state)
+      pe.stub(:zip_code).and_return(zip_code)
+      pe.stub(:credit_card_number).and_return('98765' + cc_last_four)
+      pe.stub(:first_name).and_return(first_name)
+      pe.stub(:last_name).and_return(last_name)
+      pe.stub(:latitude).and_return(latitude)
+      pe.stub(:longitude).and_return(longitude)
+      pe.stub(:street_position).and_return(street_position)
+      pe.stub(:company_name).and_return(company_name)
+      pe.stub(:city).and_return(city)
+    }
+  end
+
+  it "should calculate age" do
+    pseudo_entity.age.should eql(age)
+  end
+
+  it "should combine components into a full address" do
+    pseudo_entity.stub(:street_address).and_return('street_address')
+    pseudo_entity.address.should eql("street_address\n#{city}, #{state}. #{zip_code}")
+  end
+
+  it "should identify when an address is and is not an apartment" do
+    pseudo_entity.stub(:street_modifier_needed).and_return(:apartment)
+    pseudo_entity.apartment?.should be_true
+    pseudo_entity.stub(:street_modifier_needed).and_return(:something_else)
+    pseudo_entity.apartment?.should be_false
+  end
+
+  it "should extract birth year" do
+    pseudo_entity.birth_year.should eql(date.year)
+  end
+
+  it "should extract the last four digits of the credit card number" do
+    pseudo_entity.credit_card_last_four.should eql(cc_last_four)
+  end
+
+  it "should combine names into a full name" do
+    pseudo_entity.full_name.should eql("#{first_name} #{last_name}")
+  end
+
+  it "should generate a google map url from latitude and longitude" do
+    pseudo_entity.google_map_url.should eql("https://maps.google.com/maps?q=loc:#{latitude},#{longitude}")
+  end
+
+  it "should not return new values without resetting" do
+    names = [ 'Jack', 'Jill' ]
+    pseudo_entity = PseudoEntity.new
+    pseudo_entity.stub(:random_first_name).and_return(names.shift)
+    pseudo_entity.first_name.should equal(pseudo_entity.first_name)
+  end
+
+  it "should return new values after a reset" do
+    names = [ 'Jack', 'Jill' ]
+    pseudo_entity = PseudoEntity.new
+    pseudo_entity.stub(:random_first_name).and_return(names.shift)
+    name = pseudo_entity.first_name
+    pseudo_entity.reset!
+    pseudo_entity.stub(:random_first_name).and_return(names.shift)
+    pseudo_entity.first_name.should_not eql(name)
+  end
+
+  it "should return self after a reset" do
+    pseudo_entity.reset!.should equal(pseudo_entity)
+  end
+
+  it "should combine addresses in 2,1 order" do
+    pseudo_entity.stub(:street_address_line_1).and_return(:street_address_line_1)
+    pseudo_entity.stub(:street_address_line_2).and_return(:street_address_line_2)
+    pseudo_entity.street_address.should  eql('street_address_line_2 street_address_line_1')
+  end
+
+  it "should trim missing street information" do
+    pseudo_entity.stub(:street_address_line_1).and_return(:street_address_line_1)
+    pseudo_entity.stub(:street_address_line_2).and_return('')
+    pseudo_entity.street_address.should == 'street_address_line_1'
+    pseudo_entity.stub(:street_address_line_1).and_return('')
+    pseudo_entity.stub(:street_address_line_2).and_return(:street_address_line_2)
+    pseudo_entity.street_address.should eql('street_address_line_2')
+  end
+
+  it "should apartment number as street address line 1 when the address is at an apartment" do
+    apartment_number = 1234
+    pseudo_entity.stub(:apartment_number).and_return(apartment_number)
+    pseudo_entity.stub(:apartment?).and_return(true)
+    pseudo_entity.stub(:suite?).and_return(false)
+    pseudo_entity.street_address_line_1.should eql("APT #{apartment_number}")
+  end
+
+  it "should suite number as street address line 1 when the address is at a suite" do
+    suite_number = 1234
+    pseudo_entity.stub(:suite_number).and_return(suite_number)
+    pseudo_entity.stub(:apartment?).and_return(false)
+    pseudo_entity.stub(:suite?).and_return(true)
+    pseudo_entity.street_address_line_1.should eql("STE #{suite_number}")
+  end
+
+  it "should use the street position as street address line 1 when not at an apartment or suite" do
+    pseudo_entity.stub(:apartment?).and_return(false)
+    pseudo_entity.stub(:suite?).and_return(false)
+    pseudo_entity.street_address_line_1.should eql(street_position)
+  end
+
+  it "should use street position as street address line 2 when a street modifier is needed" do
+    pseudo_entity.stub(:street_modifier_needed?).and_return(true)
+    pseudo_entity.street_address_line_2.should eql(street_position)
+  end
+
+  it "should return nil as street address line 2 when a street modifier is not needed" do
+    pseudo_entity.stub(:street_modifier_needed?).and_return(false)
+    pseudo_entity.street_address_line_2.should be_nil
+  end
+
+  it "should identify when an address is and is not an suite" do
+    pseudo_entity.stub(:street_modifier_needed).and_return(:suite)
+    pseudo_entity.suite?.should be_true
+    pseudo_entity.stub(:street_modifier_needed).and_return(:something_else)
+    pseudo_entity.suite?.should be_false
+  end
+
+  it "should generate a yelp business id from the company name and the city" do
+    pseudo_entity.yelp_business_id.should == 'Some-Company-Ltd-St-Archibald'
+  end
+
+  it "should generate a yelp business url from the yelp business id" do
+    pseudo_entity.stub(:yelp_business_id).and_return(:yelp_business_id)
+    pseudo_entity.yelp_business_url.should == 'http://www.yelp.com/biz/yelp_business_id'
+  end
+
+  it "should generate a string 22 characters long for yelp user id" do
+    yelp_user_id = pseudo_entity.yelp_user_id
+    yelp_user_id.should be_an_instance_of(String)
+    yelp_user_id.size.should eql(22)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'pseudo_entity'