data_magic 0.19 → 0.20

data/lib/data_magic/translation.rb

@@ -1,307 +1,14 @@
 require 'data_magic/date_translation'
+require 'data_magic/standard_translation'
 
 module DataMagic
   class Translation
+    include StandardTranslation
     include DateTranslation
 
-    attr_reader :parent
-
     def initialize(parent)
       @parent = parent
     end
 
-    #
-    # return a random name (first and last)
-    #
-    def full_name
-      Faker::Name.name
-    end
-    alias_method :dm_full_name, :full_name
-
-    #
-    # return a random first name
-    #
-    def first_name
-      Faker::Name.first_name
-    end
-    alias_method :dm_first_name, :first_name
-
-    #
-    # return a random last name
-    #
-    def last_name
-      Faker::Name.last_name
-    end
-    alias_method :dm_last_name, :last_name
-
-    #
-    # return a random name prefix
-    #
-    def name_prefix
-      Faker::Name.prefix
-    end
-    alias_method :dm_name_prefix, :name_prefix
-
-    #
-    # return a random name suffix
-    #
-    def name_suffix
-      Faker::Name.suffix
-    end
-    alias_method :dm_name_suffix, :name_suffix
-
-    #
-    # return a random title
-    #
-    def title
-      Faker::Name.title
-    end
-    alias_method :dm_title, :title
-
-    #
-    # return a random street address
-    #
-    def street_address(include_secondary=false)
-      Faker::Address.street_address(include_secondary)
-    end
-    alias_method :dm_street_address, :street_address
-
-    #
-    # return a random secondary address
-    #
-    def secondary_address
-      Faker::Address.secondary_address
-    end
-    alias_method :dm_secondary_address, :secondary_address
-
-    #
-    # return a random city
-    #
-    def city
-      Faker::Address.city
-    end
-    alias_method :dm_city, :city
-
-    #
-    # return a random state
-    #
-    def state
-      Faker::Address.state
-    end
-    alias_method :dm_state, :state
-
-    #
-    # return a random state abbreviation
-    #
-    def state_abbr
-      Faker::Address.state_abbr
-    end
-    alias_method :dm_state_abbr, :state_abbr
-
-    #
-    # return a random 5 or 9 digit zip code
-    #
-    def zip_code
-      Faker::Address.zip
-    end
-    alias_method :dm_zip_code, :zip_code
-
-    #
-    # return a random country
-    #
-    def country
-      Faker::Address.country
-    end
-    alias_method :dm_country, :country
-
-
-    #
-    # return a random company name
-    #
-    def company_name
-      Faker::Company.name
-    end
-    alias_method :dm_company_name, :company_name
-
-    #
-    # return a random catch phrase
-    #
-    def catch_phrase
-      Faker::Company.catch_phrase
-    end
-    alias_method :dm_catch_phrase, :catch_phrase
-
-    #
-    # return random words - default is 3 words
-    #
-    def words(number = 3)
-      Faker::Lorem.words(number).join(' ')
-    end
-    alias_method :dm_words, :words
-
-    #
-    # return a random sentence - default minimum word count is 4
-    #
-    def sentence(min_word_count = 4)
-      Faker::Lorem.sentence(min_word_count)
-    end
-    alias_method :dm_sentence, :sentence
-
-    #
-    # return random sentences - default is 3 sentences
-    #
-    def sentences(sentence_count = 3)
-      Faker::Lorem.sentences(sentence_count).join(' ')
-    end
-    alias_method :dm_sentences, :sentences
-
-    #
-    # return random paragraphs - default is 3 paragraphs
-    #
-    def paragraphs(paragraph_count = 3)
-      Faker::Lorem.paragraphs(paragraph_count).join('\n\n')
-    end
-    alias_method :dm_paragraphs, :paragraphs
-
-    #
-    # return random characters - default is 255 characters
-    #
-    def characters(character_count = 255)
-      Faker::Lorem.characters(character_count)
-    end
-    alias_method :dm_characters, :characters
-
-    #
-    # return a random email address
-    #
-    def email_address(name=nil)
-      Faker::Internet.email(name)
-    end
-    alias_method :dm_email_address, :email_address
-
-    #
-    # return a random domain name
-    #
-    def domain_name
-      Faker::Internet.domain_name
-    end
-    alias_method :dm_domain_name, :domain_name
-
-    #
-    # return a random url
-    #
-    def url
-      Faker::Internet.url
-    end
-    alias_method :dm_url, :url
-
-    #
-    # return a random user name
-    #
-    def user_name
-      Faker::Internet.user_name
-    end
-    alias_method :dm_user_name, :user_name
-
-    #
-    # return a random phone number
-    #
-    def phone_number
-      value = Faker::PhoneNumber.phone_number
-      remove_extension(value)
-    end
-    alias_method :dm_phone_number, :phone_number
-
-    #
-    # return a random cell number
-    #
-    def cell_phone
-      value = Faker::PhoneNumber.cell_phone
-      remove_extension(value)
-    end
-    alias_method :dm_cell_phone, :cell_phone
-
-    #
-    # return a random value from an array or range
-    #
-    def randomize(value)
-      case value
-      when Array then value[rand(value.size)]
-      when Range then rand((value.last+1) - value.first) + value.first
-      else value
-      end
-    end
-    alias_method :dm_randomize, :randomize
-
-    #
-    # return an element from the array.  The first request will return
-    # the first element, the second request will return the second,
-    # and so forth.
-    #
-    def sequential(value)
-      index = index_variable_for(value)
-      index = (index ? index + 1 : 0)
-      index = 0 if index == value.length
-      set_index_variable(value, index)
-      value[index]
-    end
-
-    #
-    # return a value based on a mast
-    # The # character will be replaced with a number
-    # The A character will be replaced with an upper case letter
-    # The a character will be replaced with a lower case letter
-    #
-    def mask(value)
-      result = ''
-      value.each_char do |ch|
-        case ch
-        when '#' then result += randomize(0..9).to_s
-        when 'A' then result += ('A'..'Z').to_a[rand(26)]
-        when 'a' then result += ('a'..'z').to_a[rand(26)]
-        else result += ch
-        end
-      end
-      result
-    end
-    alias_method :dm_mask, :mask
-
-
-
-    private
-
-    def set_index_variable(ary, value)
-      index_hash[index_name(ary)] = value
-    end
-
-    def index_variable_for(ary)
-      value = index_hash[index_name(ary)]
-      index_hash[index_name(ary)] = -1 unless value
-      index_hash[index_name(ary)]
-    end
-
-    def index_name(ary)
-      "#{ary[0]}#{ary[1]}_index".gsub(' ', '_').downcase
-    end
-
-    def index_hash
-      dh = data_hash[parent]
-      data_hash[parent] = {} unless dh
-      data_hash[parent]
-    end
-
-    def data_hash
-      $data_magic_data_hash ||= {}
-    end
-
-    def process(value)
-      eval value
-    end
-
-    def remove_extension(phone)
-      index = phone.index('x')
-      phone = phone[0, (index-1)] if index
-      phone
-    end
   end
 end

data/lib/data_magic/version.rb

@@ -1,3 +1,3 @@
 module DataMagic
-  VERSION = "0.19"
+  VERSION = "0.20"
 end

data/spec/lib/data_magic_spec.rb

@@ -11,19 +11,19 @@ describe DataMagic do
     end
     
     it "should default to a directory named config" do
-      DataMagic.yml_directory.should == 'config/data'
+      expect(DataMagic.yml_directory).to eql 'config/data'
     end
 
     it "should store a yml directory" do
       DataMagic.yml_directory = 'test_dir'
-      DataMagic.yml_directory.should == 'test_dir'
+      expect(DataMagic.yml_directory).to eql 'test_dir'
     end
   end
 
   context "when reading yml files" do
     it "should read files from the config directory" do
       DataMagic.yml_directory = 'test'
-      File.should_receive(:read).with("test/fname").and_return('test')
+      expect(File).to receive(:read).with("test/fname").and_return('test')
       DataMagic.load("fname")
     end
 

data/spec/lib/translation_spec.rb

@@ -9,251 +9,251 @@ describe "DataMagic translations" do
     let(:example) { TestSubject.new }
 
     def set_field_value(value)
-      DataMagic.should_receive(:yml).twice.and_return({'key' => {'field' => value}})
+      expect(DataMagic).to receive(:yml).twice.and_return({'key' => {'field' => value}})
     end
     
     it "should deliver the hash from the yaml" do
       set_field_value 'value'
-      example.data_for('key').should have_field_value 'value'
+      expect(example.data_for('key')).to have_field_value 'value'
     end
 
     it "should allow you to use a symbol for the key" do
       set_field_value 'value'
-      example.data_for(:key).should have_field_value 'value'
+      expect(example.data_for(:key)).to have_field_value 'value'
     end
 
     it "should default to use a file named 'default.yml'" do
       DataMagic.yml_directory = 'test'
-      File.should_receive(:read).with("test/default.yml").and_return('test')
-      DataMagic.should_receive(:yml).and_return(nil)
-      DataMagic.should_receive(:yml).and_return({'key' => {'field' => 'value'}})
-      example.data_for('key').should have_field_value 'value'
+      expect(File).to receive(:read).with("test/default.yml").and_return('test')
+      expect(DataMagic).to receive(:yml).and_return(nil)
+      expect(DataMagic).to receive(:yml).and_return({'key' => {'field' => 'value'}})
+      expect(example.data_for('key')).to have_field_value 'value'
     end
 
     it "should clone the data returned so it can be resued" do
       yaml = double('yaml')
-      yaml.stub(:merge).and_return(yaml)
-      DataMagic.should_receive(:yml).twice.and_return(yaml)
-      yaml.should_receive(:[]).and_return(yaml)
-      yaml.should_receive(:clone).and_return({'field' => 'value'})
-      example.data_for('key').should have_field_value 'value'
+      expect(yaml).to receive(:merge).and_return(yaml)
+      expect(DataMagic).to receive(:yml).twice.and_return(yaml)
+      expect(yaml).to receive(:[]).and_return(yaml)
+      expect(yaml).to receive(:clone).and_return({'field' => 'value'})
+      expect(example.data_for('key')).to have_field_value 'value'
     end
 
     it "should merge the provided data with the yaml data" do
       yaml = double('yaml')
-      DataMagic.should_receive(:yml).twice.and_return(yaml)
-      yaml.should_receive(:[]).and_return(yaml)
-      yaml.should_receive(:merge).and_return(yaml)
-      yaml.should_receive(:clone).and_return({'field' => 'value'})
-      example.data_for('key').should have_field_value 'value'
+      expect(DataMagic).to receive(:yml).twice.and_return(yaml)
+      expect(yaml).to receive(:[]).and_return(yaml)
+      expect(yaml).to receive(:merge).and_return(yaml)
+      expect(yaml).to receive(:clone).and_return({'field' => 'value'})
+      expect(example.data_for('key')).to have_field_value 'value'
     end
 
     context "translating random names" do
       it "should add a name" do
-        Faker::Name.should_receive(:name).and_return('Joseph')
+        expect(Faker::Name).to receive(:name).and_return('Joseph')
         set_field_value '~full_name'
-        example.data_for('key').should have_field_value 'Joseph'
+        expect(example.data_for('key')).to have_field_value 'Joseph'
       end
 
       it "should add first name" do
-        Faker::Name.should_receive(:first_name).and_return('Sam')
+        expect(Faker::Name).to receive(:first_name).and_return('Sam')
         set_field_value '~first_name'
-        example.data_for('key').should have_field_value 'Sam'
+        expect(example.data_for('key')).to have_field_value 'Sam'
       end
 
       it "should add last name" do
-        Faker::Name.should_receive(:last_name).and_return('Smith')
+        expect(Faker::Name).to receive(:last_name).and_return('Smith')
         set_field_value '~last_name'
-        example.data_for('key').should have_field_value 'Smith'
+        expect(example.data_for('key')).to have_field_value 'Smith'
       end
 
       it "should add name prefix" do
-        Faker::Name.should_receive(:prefix).and_return("Mr")
+        expect(Faker::Name).to receive(:prefix).and_return("Mr")
         set_field_value '~name_prefix'
-        example.data_for('key').should have_field_value 'Mr'
+        expect(example.data_for('key')).to have_field_value 'Mr'
       end
 
       it "should add name suffix" do
-        Faker::Name.should_receive(:suffix).and_return('Jr')
+        expect(Faker::Name).to receive(:suffix).and_return('Jr')
         set_field_value '~name_suffix'
-        example.data_for('key').should have_field_value 'Jr'
+        expect(example.data_for('key')).to have_field_value 'Jr'
       end
     end
 
     context "translating random addresses" do
       it "should add a street address" do
-        Faker::Address.should_receive(:street_address).and_return("123 Main")
+        expect(Faker::Address).to receive(:street_address).and_return("123 Main")
         set_field_value '~street_address'
-        example.data_for('key').should have_field_value '123 Main'
+        expect(example.data_for('key')).to have_field_value '123 Main'
       end
 
       it "should add a city" do
-        Faker::Address.should_receive(:city).and_return('Cleveland')
+        expect(Faker::Address).to receive(:city).and_return('Cleveland')
         set_field_value '~city'
-        example.data_for('key').should have_field_value 'Cleveland'
+        expect(example.data_for('key')).to have_field_value 'Cleveland'
       end
 
       it "should add a state" do
-        Faker::Address.should_receive(:state).and_return('Ohio')
+        expect(Faker::Address).to receive(:state).and_return('Ohio')
         set_field_value '~state'
-        example.data_for('key').should have_field_value 'Ohio'
+        expect(example.data_for('key')).to have_field_value 'Ohio'
       end
 
       it "should add a state abbreviation" do
-        Faker::Address.should_receive(:state_abbr).and_return('OH')
+        expect(Faker::Address).to receive(:state_abbr).and_return('OH')
         set_field_value '~state_abbr'
-        example.data_for('key').should have_field_value 'OH'
+        expect(example.data_for('key')).to have_field_value 'OH'
       end
 
       it "should add a zip code" do
-        Faker::Address.should_receive(:zip).and_return('11111')
+        expect(Faker::Address).to receive(:zip).and_return('11111')
         set_field_value '~zip_code'
-        example.data_for('key').should have_field_value '11111'
+        expect(example.data_for('key')).to have_field_value '11111'
       end
 
       it "should add a country" do
-        Faker::Address.should_receive(:country).and_return("United States")
+        expect(Faker::Address).to receive(:country).and_return("United States")
         set_field_value '~country'
-        example.data_for('key').should have_field_value 'United States'
+        expect(example.data_for('key')).to have_field_value 'United States'
       end
 
       it "should add a secondary address" do
-        Faker::Address.should_receive(:secondary_address).and_return('2nd floor')
+        expect(Faker::Address).to receive(:secondary_address).and_return('2nd floor')
         set_field_value '~secondary_address'
-        example.data_for('key').should have_field_value '2nd floor'
+        expect(example.data_for('key')).to have_field_value '2nd floor'
       end
     end
 
     context "translating company names" do
       it "should add a company name" do
-        Faker::Company.should_receive(:name).and_return('LeanDog')
+        expect(Faker::Company).to receive(:name).and_return('LeanDog')
         set_field_value '~company_name'
-        example.data_for('key').should have_field_value 'LeanDog'
+        expect(example.data_for('key')).to have_field_value 'LeanDog'
       end
     end
 
     context "translating internet names" do
       it "should add an email address" do
-        Faker::Internet.should_receive(:email).and_return('buddy@example.com')
+        expect(Faker::Internet).to receive(:email).and_return('buddy@example.com')
         set_field_value '~email_address'
-        example.data_for('key').should have_field_value 'buddy@example.com'
+        expect(example.data_for('key')).to have_field_value 'buddy@example.com'
       end
 
       it "should add a domain name" do
-        Faker::Internet.should_receive(:domain_name).and_return("google.com")
+        expect(Faker::Internet).to receive(:domain_name).and_return("google.com")
         set_field_value '~domain_name'
-        example.data_for('key').should have_field_value 'google.com'
+        expect(example.data_for('key')).to have_field_value 'google.com'
       end
 
       it "should add a user name" do
-        Faker::Internet.should_receive(:user_name).and_return('very_cheezy')
+        expect(Faker::Internet).to receive(:user_name).and_return('very_cheezy')
         set_field_value '~user_name'
-        example.data_for('key').should have_field_value 'very_cheezy'
+        expect(example.data_for('key')).to have_field_value 'very_cheezy'
       end
     end
     
     context "translating phone numbers" do
       it "shold add a phone number" do
-        Faker::PhoneNumber.should_receive(:phone_number).and_return('555-555-5555')
+        expect(Faker::PhoneNumber).to receive(:phone_number).and_return('555-555-5555')
         set_field_value '~phone_number'
-        example.data_for('key').should have_field_value '555-555-5555'
+        expect(example.data_for('key')).to have_field_value '555-555-5555'
       end
     end
 
     context "translating random phrases" do
       it "should add a catch phrase" do
-        Faker::Company.should_receive(:catch_phrase).and_return('Ruby is cool')
+        expect(Faker::Company).to receive(:catch_phrase).and_return('Ruby is cool')
         set_field_value '~catch_phrase'
-        example.data_for('key').should have_field_value 'Ruby is cool'
+        expect(example.data_for('key')).to have_field_value 'Ruby is cool'
       end
 
       it "should add random words" do
-        Faker::Lorem.should_receive(:words).and_return(['random', 'words'])
+        expect(Faker::Lorem).to receive(:words).and_return(['random', 'words'])
         set_field_value '~words'
-        example.data_for('key').should have_field_value 'random words'
+        expect(example.data_for('key')).to have_field_value 'random words'
       end
 
       it "should default to returning 3 words" do
         set_field_value '~words'
-        example.data_for('key')['field'].split.size.should == 3
+        expect(example.data_for('key')['field'].split.size).to eql 3
       end
 
       it "should allow you to specify the number of words" do
         set_field_value '~words(4)'
-        example.data_for('key')['field'].split.size.should == 4
+        expect(example.data_for('key')['field'].split.size).to eql 4
       end
 
       it "should add a random sentence" do
-        Faker::Lorem.should_receive(:sentence).and_return('a sentence')
+        expect(Faker::Lorem).to receive(:sentence).and_return('a sentence')
         set_field_value '~sentence'
-        example.data_for('key').should have_field_value 'a sentence'
+        expect(example.data_for('key')).to have_field_value 'a sentence'
       end
 
       it "should default to returning a minimum of 4 words" do
         set_field_value '~sentence'
-        example.data_for('key')['field'].split.size.should >= 4
+        expect(example.data_for('key')['field'].split.size).to be >= 4
       end
 
       it "should allow you to specify a minimum word count" do
         set_field_value '~sentence(20)'
-        example.data_for('key')['field'].split.size.should >= 20
+        expect(example.data_for('key')['field'].split.size).to be >= 20
       end
 
       it "should add sentences" do
-        Faker::Lorem.should_receive(:sentences).and_return(['this is sentences'])
+        expect(Faker::Lorem).to receive(:sentences).and_return(['this is sentences'])
         set_field_value '~sentences'
-        example.data_for('key').should have_field_value 'this is sentences'
+        expect(example.data_for('key')).to have_field_value 'this is sentences'
       end
 
       it "should default to returning a default of 3 sentences" do
         set_field_value '~sentences'
-        example.data_for('key')['field'].split('.').size.should >= 3
+        expect(example.data_for('key')['field'].split('.').size).to be >= 3
       end
 
       it "should allow you to specify the number of  sentences" do
         set_field_value '~sentences(10)'
-        example.data_for('key')['field'].split('.').size.should >= 10
+        expect(example.data_for('key')['field'].split('.').size).to be >= 10
       end
 
       it "should add a paragraphs" do
-        Faker::Lorem.should_receive(:paragraphs).and_return(['this is a paragraph'])
+        expect(Faker::Lorem).to receive(:paragraphs).and_return(['this is a paragraph'])
         set_field_value '~paragraphs'
-        example.data_for('key').should have_field_value 'this is a paragraph'
+        expect(example.data_for('key')).to have_field_value 'this is a paragraph'
       end
 
       it "should return 3 paragraphs by default" do
         set_field_value '~paragraphs'
-        example.data_for('key')['field'].split('\n\n').size.should == 3
+        expect(example.data_for('key')['field'].split('\n\n').size).to eql 3
       end
 
       it "should allow you to specify the number of paragraphs" do
         set_field_value '~paragraphs(10)'
-        example.data_for('key')['field'].split('\n\n').size.should == 10
+        expect(example.data_for('key')['field'].split('\n\n').size).to eql 10
       end
 
       it "should add characters" do
-        Faker::Lorem.should_receive(:characters).and_return('abcdefg')
+        expect(Faker::Lorem).to receive(:characters).and_return('abcdefg')
         set_field_value '~characters'
-        example.data_for('key').should have_field_value 'abcdefg'
+        expect(example.data_for('key')).to have_field_value 'abcdefg'
       end
     end
 
     context "translating boolean values" do
       it "should resolve true" do
         set_field_value true
-        example.data_for('key').should have_field_value true
+        expect(example.data_for('key')).to have_field_value true
       end
 
       it "should resolve false" do
         set_field_value false
-        example.data_for('key').should have_field_value false
+        expect(example.data_for('key')).to have_field_value false
       end
     end
 
     context "with numeric values" do
       it "doesn't translate values" do
         set_field_value(1)
-        example.data_for("key").should have_field_value 1
+        expect(example.data_for("key")).to have_field_value 1
       end
     end
 
@@ -266,31 +266,31 @@ describe "DataMagic translations" do
     context "providing date values" do
       it "should provide today's date" do
         set_field_value '~today'
-        example.data_for('key').should have_field_value Date.today.strftime('%D')
+        expect(example.data_for('key')).to have_field_value Date.today.strftime('%D')
       end
 
       it "should provide tomorrow's date" do
         set_field_value '~tomorrow'
         tomorrow = Date.today + 1
-        example.data_for('key').should have_field_value tomorrow.strftime('%D')
+        expect(example.data_for('key')).to have_field_value tomorrow.strftime('%D')
       end
 
       it "should provide yesterday's date" do
         set_field_value '~yesterday'
         yesterday = Date.today - 1
-        example.data_for('key').should have_field_value yesterday.strftime('%D')
+        expect(example.data_for('key')).to have_field_value yesterday.strftime('%D')
       end
 
       it "should provide a date that is some number of days from now" do
         set_field_value '~5.days_from_today'
         the_date = Date.today + 5
-        example.data_for('key').should have_field_value the_date.strftime('%D')
+        expect(example.data_for('key')).to have_field_value the_date.strftime('%D')
       end
 
       it "should provide a date that is some number of days ago" do
         set_field_value '~5.days_ago'
         the_date = Date.today - 5
-        example.data_for('key').should have_field_value the_date.strftime('%D')
+        expect(example.data_for('key')).to have_field_value the_date.strftime('%D')
       end
     end
   end