new_data_magic 1.2

data/features/yaml/example.yml

@@ -0,0 +1,65 @@
+dm:
+  value1: this is value 1
+  value2: this is value 2
+  full_name: ~full_name
+  first_name: ~first_name
+  last_name: ~last_name
+  name_prefix: ~name_prefix
+  name_suffix: ~name_suffix
+  street: ~street_address
+  street_plus:  ~street_address(true)
+  city: ~city
+  state: ~state
+  state_ab: ~state_abbr
+  zip: ~zip_code
+  country: ~country
+  second_address: ~secondary_address
+  company: ~company_name
+  email: ~email_address
+  email_plus: ~email_address('buddy')
+  domain_name: ~domain_name
+  url: ~url
+  user_name: ~user_name
+  phone: ~phone_number
+  cell: ~cell_phone
+  catch_phrase: ~catch_phrase
+  words: ~words
+  sentence: ~sentence
+  sentences: ~sentences
+  paragraphs: ~paragraphs
+  characters: ~characters
+  bool_true: true
+  bool_false: false
+  random: ~randomize ['Tom', 'Dick', 'Harry']
+  ordered: ~sequential ['first', 'second', 'third']
+  range:  ~randomize 1..5
+  mask: ~mask "###-AAA_aaa"
+  job_title: ~job_title
+  today: ~today
+  tomorrow: ~tomorrow
+  yesterday: ~yesterday
+  5daysfromtoday: ~5.days_from_today
+  5daysago: ~5.days_ago
+  some_month: ~month
+  month_abbr: ~month_abbr
+  some_day: ~day_of_week
+  day_abbr: ~day_of_week_abbr
+  this:
+    is_nested: Nested Value
+    translate_nested:
+      full_name: ~full_name
+      first_name: ~first_name
+  color_hex: ~color_hex
+  color_name: ~color_name
+  number: ~number(digits = 10, true)
+  decimal: ~decimal(before_decimal = 5, after_decimal = 3)
+  merge: ~merge(separator = '--', [first_name, last_name, number(3)])
+  date_between: ~date_between(from = '01/01/2021', to = '31/12/2021', format = '%d/%m/%y')
+
+dynamic:
+  blah: ~blah
+
+other:
+  name: Cheezy
+  address: 123 Main Street
+  email: cheezy@example.com

data/lib/data_magic/core_ext/hash.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Hash
+  def deep_copy
+    Marshal.load(Marshal.dump(self))
+  end
+end

data/lib/data_magic/core_ext/integer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Integer
+  def days_from_today(format = '%D')
+    the_day = Date.today + self
+    the_day.strftime(format)
+  end
+
+  def days_ago(format = '%D')
+    the_day = Date.today - self
+    the_day.strftime(format)
+  end
+end

data/lib/data_magic/core_ext/string.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class String
+  def is_integer
+    true if Integer(self)
+  rescue StandardError
+    false
+  end
+end

data/lib/data_magic/date_translation.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module DataMagic
+  module DateTranslation
+    #
+    # return today's date
+    #
+    # @param String the format to use for the date.  Default is %D
+    #
+    # See http://ruby-doc.org/stdlib-1.9.3/libdoc/date/rdoc/Date.html#method-i-strftime
+    # for details of the formats
+    #
+    def today(format = '%D')
+      Date.today.strftime(format)
+    end
+    alias dm_today today
+
+    #
+    # return tomorrow's date
+    #
+    # @param String the format to use for the date.  Default is %D
+    #
+    # See http://ruby-doc.org/stdlib-1.9.3/libdoc/date/rdoc/Date.html#method-i-strftime
+    # for details of the formats
+    #
+    def tomorrow(format = '%D')
+      tomorrow = Date.today + 1
+      tomorrow.strftime(format)
+    end
+    alias dm_tomorrow tomorrow
+
+    #
+    # return yesterday's date
+    #
+    # @param String the format to use for the date.  Default is %D
+    #
+    # See http://ruby-doc.org/stdlib-1.9.3/libdoc/date/rdoc/Date.html#method-i-strftime
+    # for details of the formats
+    #
+    def yesterday(format = '%D')
+      yesterday = Date.today - 1
+      yesterday.strftime(format)
+    end
+    alias dm_yesterday yesterday
+
+    #
+    # return a month
+    #
+    def month
+      randomize(Date::MONTHNAMES[1..-1])
+    end
+    alias dm_month month
+
+    #
+    # return a month abbreviation
+    #
+    def month_abbr
+      randomize(Date::ABBR_MONTHNAMES[1..-1])
+    end
+    alias dm_month_abbr month_abbr
+
+    #
+    # return a day of the week
+    #
+    def day_of_week
+      randomize(Date::DAYNAMES)
+    end
+    alias dm_day_of_week day_of_week
+
+    def day_of_week_abbr
+      randomize(Date::ABBR_DAYNAMES)
+    end
+    alias dm_day_of_week_abbr day_of_week_abbr
+
+    ##################################################################
+    #                                                                #
+    #                   NEW TRANSLATOR STARTS HERE                   #
+    #                                                                #
+    ##################################################################
+
+    #
+    # return random date within the range
+    #
+    def date_between(from = nil, to = nil, format = '%D')
+      raise ArgumentError, 'Invalid date format' if from.to_s.empty? || to.to_s.empty?
+
+      start_date = from.nil? ? Date.today.strftime(format) : Date.strptime(from, format)
+      end_date = to.nil? ? Date.today.strftime(format) : Date.strptime(to, format)
+
+      Faker::Date.between(from: start_date, to: end_date).strftime(format)
+    end
+    alias dm_date_between date_between
+
+    ##################################################################
+    #                                                                #
+    #                   NEW TRANSLATOR ENDS HERE                     #
+    #                                                                #
+    ##################################################################
+  end
+end

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'
+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 'byebug'
+
+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