faker 2.1.0

data/lib/faker/default/restaurant.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Faker
+  class Restaurant < Base
+    flexible :restaurant
+
+    def self.name
+      bothify(parse('restaurant.name'))
+    end
+  end
+end

data/lib/faker/default/science.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Faker
+  class Science < Base
+    class << self
+      def element
+        fetch('science.element')
+      end
+
+      def element_symbol
+        fetch('science.element_symbol')
+      end
+
+      def scientist
+        fetch('science.scientist')
+      end
+    end
+  end
+end

data/lib/faker/default/slack_emoji.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Faker
+  class SlackEmoji < Base
+    class << self
+      def people
+        fetch('slack_emoji.people')
+      end
+
+      def nature
+        fetch('slack_emoji.nature')
+      end
+
+      def food_and_drink
+        fetch('slack_emoji.food_and_drink')
+      end
+
+      def celebration
+        fetch('slack_emoji.celebration')
+      end
+
+      def activity
+        fetch('slack_emoji.activity')
+      end
+
+      def travel_and_places
+        fetch('slack_emoji.travel_and_places')
+      end
+
+      def objects_and_symbols
+        fetch('slack_emoji.objects_and_symbols')
+      end
+
+      def custom
+        fetch('slack_emoji.custom')
+      end
+
+      def emoji
+        parse('slack_emoji.emoji')
+      end
+    end
+  end
+end

data/lib/faker/default/source.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Faker
+  class Source < Base
+    class << self
+      def hello_world(lang: :ruby)
+        fetch("source.hello_world.#{lang}")
+      end
+
+      def print(str: 'some string', lang: :ruby)
+        code = fetch("source.print.#{lang}")
+        code.gsub('faker_string_to_print', str)
+      end
+
+      def print_1_to_10(lang: :ruby)
+        fetch("source.print_1_to_10.#{lang}")
+      end
+    end
+  end
+end

data/lib/faker/default/south_africa.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Faker
+  class SouthAfrica < Base
+    class << self
+      def id_number
+        Faker::IDNumber.south_african_id_number
+      end
+
+      def valid_id_number
+        Faker::IDNumber.valid_south_african_id_number
+      end
+
+      def invalid_id_number
+        Faker::IDNumber.invalid_south_african_id_number
+      end
+
+      def phone_number
+        with_locale 'en-ZA' do
+          Faker::PhoneNumber.phone_number
+        end
+      end
+
+      def cell_phone
+        with_locale 'en-ZA' do
+          Faker::PhoneNumber.cell_phone
+        end
+      end
+
+      def pty_ltd_registration_number
+        Faker::Company.south_african_pty_ltd_registration_number
+      end
+
+      def close_corporation_registration_number
+        Faker::Company.south_african_close_corporation_registration_number
+      end
+
+      def listed_company_registration_number
+        Faker::Company.south_african_listed_company_registration_number
+      end
+
+      def trust_registration_number
+        Faker::Company.south_african_trust_registration_number
+      end
+
+      def vat_number
+        Faker::Finance.vat_number(country: 'ZA')
+      end
+    end
+  end
+end

data/lib/faker/default/space.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Faker
+  class Space < Base
+    flexible :space
+    class << self
+      def planet
+        fetch('space.planet')
+      end
+
+      def moon
+        fetch('space.moon')
+      end
+
+      def galaxy
+        fetch('space.galaxy')
+      end
+
+      def nebula
+        fetch('space.nebula')
+      end
+
+      def star_cluster
+        fetch('space.star_cluster')
+      end
+
+      def constellation
+        fetch('space.constellation')
+      end
+
+      def star
+        fetch('space.star')
+      end
+
+      def agency
+        fetch('space.agency')
+      end
+
+      def agency_abv
+        fetch('space.agency_abv')
+      end
+
+      def nasa_space_craft
+        fetch('space.nasa_space_craft')
+      end
+
+      def company
+        fetch('space.company')
+      end
+
+      def distance_measurement
+        rand(10..100).to_s + ' ' + fetch('space.distance_measurement')
+      end
+
+      def meteorite
+        fetch('space.meteorite')
+      end
+
+      def launch_vehicle
+        fetch('space.launch_vehicle')
+      end
+    end
+  end
+end

data/lib/faker/default/string.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Faker
+  class String < Base
+    class << self
+      def random(length: 32)
+        utf8string select_a length
+      end
+
+      private
+
+      def select_a(length)
+        if length.class.included_modules.include? Enumerable
+          select_a sample(length.to_enum.to_a)
+        else
+          length # recursive base case
+        end
+      end
+
+      def utf8string(length)
+        ratio = char_space_ratio
+        (1..length.to_i).map do
+          space_or_utf8_char ratio
+        end.join
+      end
+
+      def space_or_utf8_char(ratio)
+        sample [32.chr(Encoding::UTF_8), [utf8character] * ratio].flatten
+      end
+
+      def char_space_ratio
+        sample [2, [3] * 5, [5] * 17, [7] * 11, 11, 191].flatten
+      end
+
+      def utf8character
+        sample([
+                 rand(32..90), # latin alphabet
+                 rand(128),             # 7-bit ASCII
+                 rand(0xd800),          # utf-8 codepoints below utf-16 surrogate halves
+                 rand(57_344..1_114_111) # utf-8 codepoints above utf-16 surrogate halves
+               ]).chr(Encoding::UTF_8)
+      end
+    end
+  end
+end

data/lib/faker/default/stripe.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Faker
+  class Stripe < Base
+    class << self
+      def valid_card(card_type: nil)
+        valid_cards = translate('faker.stripe.valid_cards').keys
+
+        if card_type.nil?
+          card_type = sample(valid_cards).to_s
+        else
+          unless valid_cards.include?(card_type.to_sym)
+            raise ArgumentError,
+                  "Valid credit cards argument can be left blank or include #{valid_cards.join(', ')}"
+          end
+        end
+
+        fetch('stripe.valid_cards.' + card_type)
+      end
+
+      def valid_token(card_type: nil)
+        valid_tokens = translate('faker.stripe.valid_tokens').keys
+
+        if card_type.nil?
+          card_type = sample(valid_tokens).to_s
+        else
+          unless valid_tokens.include?(card_type.to_sym)
+            raise ArgumentError,
+                  "Valid credit cards argument can be left blank or include #{valid_tokens.join(', ')}"
+          end
+        end
+
+        fetch('stripe.valid_tokens.' + card_type)
+      end
+
+      def invalid_card(card_error: nil)
+        invalid_cards = translate('faker.stripe.invalid_cards').keys
+
+        if card_error.nil?
+          card_error = sample(invalid_cards).to_s
+        else
+          unless invalid_cards.include?(card_error.to_sym)
+            raise ArgumentError,
+                  "Invalid credit cards argument can be left blank or include #{invalid_cards.join(', ')}"
+          end
+        end
+
+        fetch('stripe.invalid_cards.' + card_error)
+      end
+
+      def month
+        format('%02d', rand_in_range(1, 12))
+      end
+
+      def year
+        start_year = ::Time.new.year + 1
+        rand_in_range(start_year, start_year + 5).to_s
+      end
+
+      def ccv(card_type: nil)
+        (card_type.to_s == 'amex' ? rand_in_range(1000, 9999) : rand_in_range(100, 999)).to_s
+      end
+    end
+  end
+end

data/lib/faker/default/subscription.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Faker
+  class Subscription < Base
+    def self.plan
+      fetch('subscription.plans')
+    end
+
+    def self.status
+      fetch('subscription.statuses')
+    end
+
+    def self.payment_method
+      fetch('subscription.payment_methods')
+    end
+
+    def self.subscription_term
+      fetch('subscription.subscription_terms')
+    end
+
+    def self.payment_term
+      fetch('subscription.payment_terms')
+    end
+  end
+end

data/lib/faker/default/superhero.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Faker
+  class Superhero < Base
+    class << self
+      def power
+        fetch('superhero.power')
+      end
+
+      def prefix
+        fetch('superhero.prefix')
+      end
+
+      def suffix
+        fetch('superhero.suffix')
+      end
+
+      def descriptor
+        fetch('superhero.descriptor')
+      end
+
+      def name
+        parse('superhero.name')
+      end
+    end
+  end
+end

data/lib/faker/default/team.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Faker
+  class Team < Base
+    flexible :team
+
+    class << self
+      def name
+        parse('team.name')
+      end
+
+      def creature
+        fetch('team.creature')
+      end
+
+      def state
+        fetch('address.state')
+      end
+
+      def sport
+        fetch('team.sport')
+      end
+
+      def mascot
+        fetch('team.mascot')
+      end
+    end
+  end
+end

data/lib/faker/default/time.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Faker
+  class Time < Base
+    TIME_RANGES = {
+      all: (0..23),
+      day: (9..17),
+      night: (18..23),
+      morning: (6..11),
+      afternoon: (12..17),
+      evening: (17..21),
+      midnight: (0..4)
+    }.freeze
+
+    class << self
+      def between(from:, to:, format: nil)
+        from = get_time_object(from)
+        to = get_time_object(to)
+
+        time = Faker::Base.rand_in_range(from, to)
+        time_with_format(time, format)
+      end
+
+      def between_dates(from:, to:, period: :all, format: nil)
+        date = Faker::Date.between(from: from, to: to)
+        time = date_with_random_time(date, period)
+        time_with_format(time, format)
+      end
+
+      def forward(days: 365, period: :all, format: nil)
+        time_with_format(date_with_random_time(Faker::Date.forward(days: days), period), format)
+      end
+
+      def backward(days: 365, period: :all, format: nil)
+        time_with_format(date_with_random_time(Faker::Date.backward(days: days), period), format)
+      end
+
+      private
+
+      def date_with_random_time(date, period)
+        ::Time.local(date.year, date.month, date.day, hours(period), minutes, seconds)
+      end
+
+      def time_with_format(time, format)
+        format.nil? ? time : I18n.localize(time, format: format)
+      end
+
+      def hours(period)
+        raise ArgumentError, 'invalid period' unless TIME_RANGES.key? period
+
+        sample(TIME_RANGES[period].to_a)
+      end
+
+      def minutes
+        seconds
+      end
+
+      def seconds
+        sample((0..59).to_a)
+      end
+
+      def get_time_object(time)
+        time = ::Time.parse(time) if time.is_a? String
+        time = time.to_time if time.respond_to?(:to_time)
+        time
+      end
+    end
+  end
+end