data_magic 0.19 → 0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ccfe171cef2e6531ccb7f404aaf9518264abb48e
-  data.tar.gz: 8ea09be1c4c8d01b5eb5f0bc5b5d818e709820c2
+  metadata.gz: ff25f8071c1ca6ce22e590a4b777580455462a79
+  data.tar.gz: d55354c90fa70805f751911bb7e4eb265c28e180
 SHA512:
-  metadata.gz: fd55e139c938a7762013aada0e8b786bdd0cf267e7bedb9278bfe329dccf8f76f527215192e4c926060b0c12c5e6a4345fb9416f8dfa84ad4544b3f7650a8dd4
-  data.tar.gz: 37074915707e495cccded1682cdf50f5dfd84a21f510b4d59efea3e1fcf73727cc84fff4b650403c36c2e034bcd2627e3bc29e9977221a014859c27490a43c93
+  metadata.gz: 6ef9572077dd3c9e779d52eebf3479675b127dbaeea21a85c66fdc7fbff7d741e3aa91b5892248359234ecc84b03b39fcda6820c67c9abd171df67d98f328110
+  data.tar.gz: fa514dc15cd7457f3c64dc0a5358a20d485eae611f4c3b6538a0c13105b510394bd8139922065c75f35bdaf144ebc627c7eb0dadacf4f107238df92d4ffe6e67

data/.ruby-version

@@ -1 +1 @@
-ruby-2.0.0-p353
+ruby-2.1.2

data/.travis.yml

@@ -1,8 +1,6 @@
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
   - 2.0.0
-  - rbx-19mode
+  - 2.1.0
+
 

data/ChangeLog

@@ -1,3 +1,8 @@
+=== Version 0.20 / 2014-9-21
+* Enhancements
+  * Added the ability to nest entries under headings
+  * Added the ability to call the translation methods directlry on DataMagic module
+
 === Version 0.19 / 2014-6-1
 * Enhancements
   * Can now include ERB in the yml file due to update in yml_reader

data/Guardfile

@@ -1,7 +1,7 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard 'rspec', :cli => '--color --format Fuubar' do
+guard 'rspec', cmd: 'rspec --color --format Fuubar' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { "spec" }
   watch('spec/spec_helper.rb')  { "spec" }

data/data_magic.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   
   gem.add_dependency 'faker', '>= 1.1.2'
-  gem.add_dependency 'yml_reader', '>= 0.3'
+  gem.add_dependency 'yml_reader', '>= 0.4'
 
   gem.add_development_dependency 'rspec', '>= 2.12.0'
   gem.add_development_dependency 'cucumber', '>= 1.2.0'

data/features/data_magic.feature

@@ -37,8 +37,8 @@ Feature: Functionality of the data_magic gem
     And the value for "url" should include "http://"
 
   Scenario: Getting a phone number
-    Then the value for "phone" should be 1 word long
-    And the value for "cell" should be 1 word long
+    Then the value for "phone" should be a phone number
+    And the value for "cell" should be a phone number
 
   Scenario: Random phrases
     Then the value for "catch_phrase" should exist
@@ -114,3 +114,11 @@ Feature: Functionality of the data_magic gem
   Scenario: It should allow one to add new translator methods
     When I add the blah translator
     Then the value for "blah" should be "foobar"
+
+  Scenario: Getting values from nested entries
+    Then the nested value for this is_nested should be "Nested Value"
+
+  Scenario: Should be able to call the translator methods on DataMagic module
+    Then I should be able to call the full_name translator
+    And I should be able to call the state translator
+    And I should be able to call the today translator

data/features/step_definitions/data_magic_steps.rb

@@ -20,27 +20,27 @@ end
 
 
 Then /^the value for "(.+)" should be "(.+)"$/ do |key, value|
-  @data[key].should == value
+  expect(@data[key]).to eql value
 end
 
 Then /^the value for "(.+)" should be (true|false)$/ do |key, value|
-  @data[key].should == eval(value)
+  expect(@data[key]).to eql eval(value)
 end
 
 Then /^the value for "(.+)" should be (\d+) word|words long$/ do |key, length|
-  @data[key].split(' ').size.should == length.to_i
+  expect(@data[key].split(' ').size).to eql length.to_i
 end
 
 Then /^the value for "(.+)" should have a minimum of (\d+) word|wordss$/ do |key, length|
-  @data[key].split(' ').size.should >= length.to_i
+  expect(@data[key].split(' ').size).to be >= length.to_i
 end
 
 Then /^the value for "(.*?)" should be (\d+) characters long$/ do |key, length|
-  @data[key].length.should == length.to_i
+  expect(@data[key].length).to eql length.to_i
 end
 
 Then /^the value for "(.+)" should exist$/ do |key|
-  @data[key].should_not be_nil
+  expect(@data[key]).not_to be_nil
 end
 
 When /^I load the file "(.+)"$/ do |file_name|
@@ -48,76 +48,76 @@ When /^I load the file "(.+)"$/ do |file_name|
 end
 
 Then /^the value for "(.*?)" should be either "(.*?)", "(.*?)", or "(.*?)"$/ do |key, vala, valb, valc|
-  [vala, valb, valc].should include @data[key]
+  expect([vala, valb, valc]).to include @data[key]
 end
 
 Then /^the value for "(.*?)" should be between (\d+) and (\d+)$/ do |key, low, high|
   value = @data[key]
-  value.should >= low.to_i
-  value.should <= high.to_i
+  expect(value).to be >= low.to_i
+  expect(value).to be <= high.to_i
 end
 
 Then /^the value for "(.*?)" should begin with (\d+) numbers$/ do |key, num|
   value = @data[key]
-  value[0,num.to_i].is_integer.should be_true
+  expect(value[0,num.to_i].is_integer).to be true
 end
 
 Then /^the value for "(.*?)" should have (\d+) upper case letters after a dash$/ do |key, num|
   value = @data[key]
-  value[4,num.to_i].upcase.should == value[4,3]
+  expect(value[4,num.to_i].upcase).to eql value[4,3]
 end
 
 Then /^the value for "(.*?)" should end with (\d+) lower case letters$/ do |key, num|
   value = @data[key]
-  value[-1 * num.to_i,num.to_i].downcase.should == value[-3,3]
+  expect(value[-1 * num.to_i,num.to_i].downcase).to eql value[-3,3]
 end
 
 Then /^the value for "(.*?)" should include "(.*?)"$/ do |key, value|
-  @data[key].should include value
+  expect(@data[key]).to include value
 end
 
 Then /^the value for "(.*?)" should be today\'s date$/ do |key|
-  @data[key].should == Date.today.strftime('%D')
+  expect(@data[key]).to eql Date.today.strftime('%D')
 end
 
 Then /^the value for "(.*?)" should be tomorrow\'s date$/ do |key|
   tomorrow = Date.today + 1
-  @data[key].should == tomorrow.strftime('%D')
+  expect(@data[key]).to eql tomorrow.strftime('%D')
 end
 
 Then /^the value for "(.*?)" should be yesterday\'s date$/ do |key|
   yesterday = Date.today - 1
-  @data[key].should == yesterday.strftime('%D')
+  expect(@data[key]).to eql yesterday.strftime('%D')
 end
 
 Then /^the value for "(.*?)" should be five days from today$/ do |key|
   the_day = Date.today + 5
-  @data[key].should == the_day.strftime('%D')
+  expect(@data[key]).to eql the_day.strftime('%D')
 end
 
 Then /^the value for "(.*?)" should be five days ago$/ do |key|
   the_day = Date.today - 5
-  @data[key].should == the_day.strftime('%D')
+  expect(@data[key]).to eql the_day.strftime('%D')
 end
 
 Then /^the value for "(.*?)" should be a valid month$/ do |key|
   months = %w[January February March April May June July August September October November December]
-  months.should include @data[key]
+  expect(months).to include @data[key]
 end
 
 Then /^the value for "(.*?)" should be a valid month abbreviation$/ do |key|
   months = %w[Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec]
-  months.should include @data[key]
+  expect(months).to include @data[key]
 end
 
 Then /^the value for "(.*?)" should be a valid day$/ do |key|
   days = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday]
-  days.should include @data[key]
+  expect(days).to include @data[key]
 end
 
 Then /^the value for "(.*?)" should be a valid day abbreviation$/ do |key|
   days = %w[Sun Mon Tue Wed Thu Fri Sat]
-  days.should include @data[key]
+  expect(days).to include @data[key]
 end
 
 When /^I add the blah translator$/ do
@@ -136,9 +136,28 @@ When /^I add the blah translator$/ do
 end
 
 Then(/^the (?:first|second|third) value for the sequential data should be "(.*?)"$/) do |value|
-  @data['ordered'].should == value
+  expect(@data['ordered']).to eql value
 end
 
 When(/^I ask for the data again$/) do
   @data = @tc.data_for 'dm'
 end
+
+Then(/^the nested value for this is_nested should be "(.*?)"$/) do |value|
+  expect(@data['this']['is_nested']).to eql value
+end
+
+Then(/^the value for "(.*?)" should be a phone number$/) do |value|
+  phone = @data[value]
+  if phone.split(' ').length == 2
+    expect(phone).to include "("
+    expect(phone).to include ")"
+  else
+    expect(phone.split(' ').length).to eql 1
+  end
+end
+
+Then(/^I should be able to call the (.+) translator$/) do |method|
+  value = DataMagic.send method
+  expect(value).not_to be_empty
+end

data/features/yaml/example.yml

@@ -44,6 +44,8 @@ dm:
   month_abbr: ~month_abbr
   some_day: ~day_of_week
   day_abbr: ~day_of_week_abbr
+  this:
+    is_nested: Nested Value
 
 dynamic:
   blah: ~blah

data/lib/data_magic.rb

@@ -2,11 +2,15 @@ require 'data_magic/core_ext/string'
 require 'data_magic/core_ext/fixnum'
 require "data_magic/version"
 require "data_magic/translation"
+require 'data_magic/date_translation'
+require 'data_magic/standard_translation'
 require 'yml_reader'
 require 'faker'
 
 module DataMagic
   extend YmlReader
+  extend StandardTranslation
+  extend DateTranslation
 
   attr_reader :parent
 
@@ -42,6 +46,7 @@ module DataMagic
     data.each do |key, value|
       unless value.nil?
         next if !value.respond_to?('[]') || value.is_a?(Numeric)
+        next if value.is_a?(Hash)
         data[key] = translate(value[1..-1]) if value[0,1] == "~"
       end
     end

data/lib/data_magic/standard_translation.rb

@@ -0,0 +1,300 @@
+module DataMagic
+  module StandardTranslation
+
+    attr_reader :parent
+
+    #
+    # 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