centric_data_magic 1.2.4

data/lib/data_magic/standard_translation.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+module DataMagic
+  module StandardTranslation
+    attr_reader :parent
+
+    #
+    # return a random name (first and last)
+    #
+    def full_name
+      Faker::Name.name
+    end
+    alias dm_full_name full_name
+
+    #
+    # return a random first name
+    #
+    def first_name
+      Faker::Name.first_name
+    end
+    alias dm_first_name first_name
+
+    #
+    # return a random last name
+    #
+    def last_name
+      Faker::Name.last_name
+    end
+    alias dm_last_name last_name
+
+    #
+    # return a random name prefix
+    #
+    def name_prefix
+      Faker::Name.prefix
+    end
+    alias dm_name_prefix name_prefix
+
+    #
+    # return a random name suffix
+    #
+    def name_suffix
+      Faker::Name.suffix
+    end
+    alias dm_name_suffix name_suffix
+
+    #################################################################################
+    #  In newer version of Faker, Faker::Name.title is changed to Faker::Job.title  #
+    #################################################################################
+
+    #
+    # return a random job title
+    #
+    def job_title
+      Faker::Job.title
+    end
+    alias dm_job_title job_title
+
+    #
+    # return a random street address
+    #
+    def street_address(include_secondary = false)
+      Faker::Address.street_address(include_secondary: include_secondary)
+    end
+    alias dm_street_address street_address
+
+    #
+    # return a random secondary address
+    #
+    def secondary_address
+      Faker::Address.secondary_address
+    end
+    alias dm_secondary_address secondary_address
+
+    #
+    # return a random city
+    #
+    def city
+      Faker::Address.city
+    end
+    alias dm_city city
+
+    #
+    # return a random state
+    #
+    def state
+      Faker::Address.state
+    end
+    alias dm_state state
+
+    #
+    # return a random state abbreviation
+    #
+    def state_abbr
+      Faker::Address.state_abbr
+    end
+    alias dm_state_abbr state_abbr
+
+    #
+    # return a random 5 or 9 digit zip code
+    #
+    def zip_code
+      Faker::Address.zip
+    end
+    alias dm_zip_code zip_code
+
+    #
+    # return a random country
+    #
+    def country
+      Faker::Address.country
+    end
+    alias dm_country country
+
+    #
+    # return a random company name
+    #
+    def company_name
+      Faker::Company.name
+    end
+    alias dm_company_name company_name
+
+    #
+    # return a random catch phrase
+    #
+    def catch_phrase
+      Faker::Company.catch_phrase
+    end
+    alias dm_catch_phrase catch_phrase
+
+    #
+    # return a credit card number
+    #
+    def credit_card_number
+      Faker::Business.credit_card_number
+    end
+    alias dm_credit_card_number credit_card_number
+
+    #
+    # return a credit card type
+    #
+    def credit_card_type
+      Faker::Business.credit_card_type
+    end
+    alias dm_credit_card_type credit_card_type
+
+    #
+    # return random words - default is 3 words
+    #
+    def words(number = 3)
+      Faker::Lorem.words(number: number).join(' ')
+    end
+    alias dm_words words
+
+    #
+    # return a random sentence - default minimum word count is 4
+    #
+    def sentence(min_word_count = 4)
+      Faker::Lorem.sentence(word_count: min_word_count)
+    end
+    alias dm_sentence sentence
+
+    #
+    # return random sentences - default is 3 sentences
+    #
+    def sentences(sentence_count = 3)
+      Faker::Lorem.sentences(number: sentence_count).join(' ')
+    end
+    alias dm_sentences sentences
+
+    #
+    # return random paragraphs - default is 3 paragraphs
+    #
+    def paragraphs(paragraph_count = 3)
+      Faker::Lorem.paragraphs(number: paragraph_count).join('\n\n')
+    end
+    alias dm_paragraphs paragraphs
+
+    #
+    # return random characters - default is 255 characters
+    #
+    def characters(character_count = 255)
+      Faker::Lorem.characters(number: character_count)
+    end
+    alias dm_characters characters
+
+    #
+    # return a random email address
+    #
+    def email_address(name = nil, domain = nil)
+      Faker::Internet.email(name: name, domain: domain)
+    end
+    alias dm_email_address email_address
+
+    #
+    # return a random domain name
+    #
+    def domain_name
+      Faker::Internet.domain_name
+    end
+    alias dm_domain_name domain_name
+
+    #
+    # return a random url
+    #
+    def url
+      Faker::Internet.url
+    end
+    alias dm_url url
+
+    #
+    # return a random user name
+    #
+    def user_name
+      Faker::Internet.user_name
+    end
+    alias dm_user_name user_name
+
+    #
+    # return a random phone number
+    #
+    def phone_number
+      value = Faker::PhoneNumber.phone_number
+      remove_extension(value)
+    end
+    alias dm_phone_number phone_number
+
+    #
+    # return a random cell number
+    #
+    def cell_phone
+      value = Faker::PhoneNumber.cell_phone
+      remove_extension(value)
+    end
+    alias 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 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|
+        result += case ch
+                  when '#' then randomize(0..9).to_s
+                  when 'A' then ('A'..'Z').to_a[rand(26)]
+                  when 'a' then ('a'..'z').to_a[rand(26)]
+                  else ch
+                  end
+      end
+      result
+    end
+    alias dm_mask mask
+
+    ##################################################################
+    #                                                                #
+    #                   NEW TRANSLATOR STARTS HERE                   #
+    #                                                                #
+    ##################################################################
+
+    #
+    # return a random color code in hex
+    #
+    def color_hex
+      Faker::Color.hex_color
+    end
+    alias dm_color_hex color_hex
+
+    #
+    # return a random color name
+    #
+    def color_name
+      Faker::Color.color_name
+    end
+    alias dm_color_name color_name
+
+    #
+    # return a random number in specified digits
+    #
+    def number(digits, leading_zero = false)
+      leading_zero ? Faker::Number.leading_zero_number(digits: digits) : Faker::Number.number(digits: digits)
+    end
+    alias dm_number number
+
+    #
+    # return a random number in decimal
+    #
+    def decimal(before_decimal, after_decimal = 2)
+      Faker::Number.decimal(l_digits: before_decimal, r_digits: after_decimal)
+    end
+    alias dm_decimal decimal
+
+    #
+    # merge variables
+    #
+    def merge(separator = ' ', *params)
+      params.join(separator)
+    end
+    alias dm_merge merge
+
+    ##################################################################
+    #                                                                #
+    #                   NEW TRANSLATOR ENDS HERE                     #
+    #                                                                #
+    ##################################################################
+
+    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/translation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'data_magic/date_translation'
+require 'data_magic/standard_translation'
+
+module DataMagic
+  class Translation
+    include StandardTranslation
+    include DateTranslation
+
+    def initialize(parent)
+      @parent = parent
+    end
+  end
+end

data/lib/data_magic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DataMagic
+  VERSION = '1.2.4'
+end

data/lib/data_magic.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'data_magic/core_ext/string'
+require 'data_magic/core_ext/integer'
+require 'data_magic/core_ext/hash'
+require 'data_magic/version'
+require 'data_magic/translation'
+require 'data_magic/date_translation'
+require 'data_magic/standard_translation'
+require 'yml_reader'
+require 'faker'
+# require 'debug'
+
+module DataMagic
+  extend YmlReader
+  extend StandardTranslation
+  extend DateTranslation
+
+  attr_reader :parent
+
+  I18n.enforce_available_locales = false if I18n.respond_to? :enforce_available_locales
+
+  def self.locale=(value)
+    Faker::Config.locale = value
+  end
+
+  def self.included(cls)
+    @parent = cls
+    translators.each do |translator|
+      Translation.send :include, translator
+    end
+  end
+
+  def data_for(key, additional = {})
+    if key.is_a?(String) && key.match(%r{/})
+      filename, record = key.split('/')
+      DataMagic.load("#{filename}.yml")
+    else
+      record = key.to_s
+      DataMagic.load(the_file) unless DataMagic.yml
+    end
+    data = DataMagic.yml[record]
+    raise ArgumentError, "Undefined key #{key}" unless data
+
+    prep_data(data.merge(additional.key?(record) ? additional[record] : additional).deep_copy)
+  end
+
+  # Given a scenario, load any fixture it needs.
+  # Fixture tags should be in the form of @datamagic_FIXTUREFILE
+  def self.load_for_scenario(scenario, fixture_folder = DataMagic.yml_directory)
+    orig_yml_directory = DataMagic.yml_directory
+    DataMagic.yml_directory = fixture_folder
+    fixture_files = fixture_files_on(scenario)
+
+    DataMagic.load "#{fixture_files.last}.yml" if fixture_files.count.positive?
+    DataMagic.yml_directory = orig_yml_directory
+  end
+
+  private_class_method
+
+  def the_file
+    ENV['DATA_MAGIC_FILE'] || 'default.yml'
+  end
+
+  def prep_data(data)
+    case data
+    when Hash
+      data.each { |key, value| data[key] = prep_data(value) }
+    when Array
+      data.each_with_index { |value, i|  data[i] = prep_data(value) }
+    when String
+      return translate(data[1..-1]) if data[0, 1] == '~'
+    end
+    data
+  end
+
+  def translate(value)
+    translation.send :process, value
+  rescue StandardError => e
+    raise "Failed to translate: #{value}\n Reason: #{e.message}\n"
+  end
+
+  def translation
+    @translation ||= Translation.new parent
+  end
+
+  # Load a fixture and merge it with an existing hash
+  def self.load_fixture_and_merge_with(fixture_name, base_hash, fixture_folder = DEFAULT_FIXTURE_FOLDER)
+    new_hash = load_fixture(fixture_name, fixture_folder)
+    base_hash.deep_merge new_hash
+  end
+
+  def self.fixture_files_on(scenario)
+    # tags for cuke 2, source_tags for cuke 1
+    tags = scenario.send(scenario.respond_to?(:tags) ? :tags : :source_tags)
+    tags.map(&:name).select { |t| t =~ /@datamagic_/ }.map { |t| t.gsub('@datamagic_', '').to_sym }
+  end
+
+  class << self
+    attr_accessor :yml
+
+    def default_directory
+      'config/data'
+    end
+
+    def add_translator(translator)
+      translators << translator
+    end
+
+    def translators
+      @translators ||= []
+    end
+  end
+end

data/spec/lib/data_magic_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class UserPage
+  include DataMagic
+end
+
+class MockScenario
+  attr_accessor :tags
+
+  def initialize(tags)
+    @tags = tags
+  end
+end
+
+class MockTag
+  attr_reader :name, :line
+
+  def initialize(name, line)
+    @name = name
+    @line = line
+  end
+end
+
+describe DataMagic do
+  context 'when configuring the yml directory' do
+    before(:each) do
+      DataMagic.yml_directory = nil
+    end
+
+    it 'should default to a directory named config' do
+      expect(DataMagic.yml_directory).to eql 'config/data'
+    end
+
+    it 'should store a yml directory' do
+      DataMagic.yml_directory = 'test_dir'
+      expect(DataMagic.yml_directory).to eql 'test_dir'
+    end
+
+    it 'should accept and use locale' do
+      expect(Faker::Config).to receive(:locale=).with('blah')
+      DataMagic.locale = 'blah'
+    end
+  end
+
+  context 'when reading yml files' do
+    it 'should read files from the config directory' do
+      DataMagic.yml = nil
+      DataMagic.load('user.yml')
+      data = UserPage.new.data_for 'valid'
+      expect(data.keys.sort).to eq(%w[job name])
+    end
+
+    it 'should default to reading a file named default.yml' do
+      DataMagic.yml_directory = 'config/data'
+      DataMagic.yml = nil
+      data = UserPage.new.data_for :dm
+      expect(data.keys).to include('value1')
+    end
+
+    it 'should use the value of DATA_MAGIC_FILE if it exists' do
+      DataMagic.yml_directory = 'config/data'
+      DataMagic.yml = nil
+      ENV['DATA_MAGIC_FILE'] = 'user.yml'
+      data = UserPage.new.data_for 'valid'
+      expect(data.keys.sort).to eq(%w[job name])
+      ENV['DATA_MAGIC_FILE'] = nil
+    end
+
+    it 'should merge additional data to the same key if not present in addtional' do
+      DataMagic.yml_directory = 'config/data'
+      data = UserPage.new.data_for 'user/valid', { 'job' => 'Overlord' }
+      expect(data['job']).to eq('Overlord')
+    end
+    it 'should merge additional data to resulting hash if present in additional data' do
+      DataMagic.yml_directory = 'config/data'
+      data = UserPage.new.data_for 'user/valid', { 'valid' => { 'job' => 'Overlord' } }
+      expect(data['job']).to eq('Overlord')
+    end
+  end
+
+  context 'namespaced keys' do
+    it 'loads correct file and retrieves data' do
+      DataMagic.yml_directory = 'config/data'
+      data = UserPage.new.data_for 'user/valid'
+      expect(data.keys.sort).to eq(%w[job name])
+    end
+  end
+
+  context 'loading fixtures for cucumber scenarios' do
+    it 'loads the fixture for a scenario' do
+      DataMagic.yml_directory = 'config/data'
+      scenario = MockScenario.new([MockTag.new('@tag', 1), MockTag.new('@datamagic_user', 1)])
+      expect(DataMagic).to receive(:load).with('user.yml')
+      DataMagic.load_for_scenario scenario
+    end
+
+    it 'uses the last fixture listed for a scenario if multiple exist' do
+      scenario = MockScenario.new([MockTag.new('@fixture_default', 1), MockTag.new('@datamagic_user', 1)])
+      expect(DataMagic).to receive(:load).with('user.yml')
+      DataMagic.load_for_scenario scenario
+    end
+
+    it 'allows you to force loading from a different folder without stepping on the global folder' do
+      DataMagic.yml_directory = 'features'
+      scenario = MockScenario.new([MockTag.new('@tag', 1), MockTag.new('@datamagic_user', 1)])
+      expect(DataMagic).to receive(:load).with('user.yml')
+      DataMagic.load_for_scenario scenario, 'config/data'
+      expect(DataMagic.yml_directory).to eq('features')
+    end
+  end
+end