faker 1.8.7 → 2.17.0

data/lib/faker/default/stripe.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Faker
+  class Stripe < Base
+    class << self
+      ##
+      # Produces a random valid card number.
+      #
+      # @param card_type [String] Specific valid card type.
+      # @return [String]
+      #
+      # @example
+      #   Faker::Stripe.valid_card #=> "4242424242424242"
+      #   Faker::Stripe.valid_card(card_type: "visa_debit") #=> "4000056655665556"
+      #
+      # @faker.version 1.9.0
+      def valid_card(legacy_card_type = NOT_GIVEN, card_type: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :card_type if legacy_card_type != NOT_GIVEN
+        end
+
+        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
+
+      ##
+      # Produces a random valid Stripe token.
+      #
+      # @param card_type [String] Specific valid card type.
+      # @return [String]
+      #
+      # @example
+      #   Faker::Stripe.valid_token #=> "tok_visa"
+      #   Faker::Stripe.valid_token(card_type: "mc_debit") #=> "tok_mastercard_debit"
+      #
+      # @faker.version 1.9.0
+      def valid_token(legacy_card_type = NOT_GIVEN, card_type: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :card_type if legacy_card_type != NOT_GIVEN
+        end
+
+        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
+
+      ##
+      # Produces a random invalid card number.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Stripe.invalid_card #=> "4000000000000002"
+      #   Faker::Stripe.invalid_card(card_error: "addressZipFail") #=> "4000000000000010"
+      #
+      # @faker.version 1.9.0
+      def invalid_card(legacy_card_error = NOT_GIVEN, card_error: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :card_error if legacy_card_error != NOT_GIVEN
+        end
+
+        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
+
+      ##
+      # Produces a random month in two digits format.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Stripe.month #=> "10"
+      #
+      # @faker.version 1.9.0
+      def month
+        format('%02d', rand_in_range(1, 12))
+      end
+
+      ##
+      # Produces a random year that is always in the future.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Stripe.year #=> "2018" # This will always be a year in the future
+      #
+      # @faker.version 1.9.0
+      def year
+        start_year = ::Time.new.year + 1
+        rand_in_range(start_year, start_year + 5).to_s
+      end
+
+      ##
+      # Produces a random ccv number.
+      #
+      # @param card_type [String] Specific valid card type.
+      # @return [String]
+      #
+      # @example
+      #   Faker::Stripe.ccv #=> "123"
+      #   Faker::Stripe.ccv(card_type: "amex") #=> "1234"
+      #
+      # @faker.version 1.9.0
+      def ccv(legacy_card_type = NOT_GIVEN, card_type: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :card_type if legacy_card_type != NOT_GIVEN
+        end
+
+        (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,70 @@
+# frozen_string_literal: true
+
+module Faker
+  class Subscription < Base
+    ##
+    # Produces the name of a subscription plan.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Faker::Subscription.plan #=> "Platinum"
+    #
+    # @faker.version 1.9.2
+    def self.plan
+      fetch('subscription.plans')
+    end
+
+    ##
+    # Produces a subscription status.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Faker::Subscription.status #=> "Active"
+    #
+    # @faker.version 1.9.2
+    def self.status
+      fetch('subscription.statuses')
+    end
+
+    ##
+    # Produces the name of a payment method.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Faker::Subscription.payment_method #=> "PayPal"
+    #
+    # @faker.version 1.9.2
+    def self.payment_method
+      fetch('subscription.payment_methods')
+    end
+
+    ##
+    # Produces the name of a subscription term.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Faker::Subscription.subscription_term #=> "Annual"
+    #
+    # @faker.version 1.9.2
+    def self.subscription_term
+      fetch('subscription.subscription_terms')
+    end
+
+    ##
+    # Produces the name of a payment term.
+    #
+    # @return [String]
+    #
+    # @example
+    #   Faker::Subscription.payment_term #=> "Monthly"
+    #
+    # @faker.version 1.9.2
+    def self.payment_term
+      fetch('subscription.payment_terms')
+    end
+  end
+end

data/lib/faker/default/superhero.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Faker
+  class Superhero < Base
+    class << self
+      ##
+      # Produces a superpower.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Superhero.power #=> "Photokinesis"
+      #
+      # @faker.version 1.6.2
+      def power
+        fetch('superhero.power')
+      end
+
+      ##
+      # Produces a superhero name prefix.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Superhero.prefix #=> "the Fated"
+      #
+      # @faker.version 1.6.2
+      def prefix
+        fetch('superhero.prefix')
+      end
+
+      ##
+      # Produces a superhero name suffix.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Superhero.suffix #=> "Captain"
+      #
+      # @faker.version 1.6.2
+      def suffix
+        fetch('superhero.suffix')
+      end
+
+      ##
+      # Produces a superhero descriptor.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Superhero.descriptor #=> "Bizarro"
+      #
+      # @faker.version 1.6.2
+      def descriptor
+        fetch('superhero.descriptor')
+      end
+
+      ##
+      # Produces a random superhero name.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Superhero.name #=> "Magnificent Shatterstar"
+      #
+      # @faker.version 1.6.2
+      def name
+        parse('superhero.name')
+      end
+    end
+  end
+end

data/lib/faker/default/team.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Faker
+  class Team < Base
+    flexible :team
+
+    class << self
+      ##
+      # Produces a team name from a state and a creature.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Team.name #=> "Oregon vixens"
+      #
+      # @faker.version 1.3.0
+      def name
+        parse('team.name')
+      end
+
+      ##
+      # Produces a team creature.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Team.creature #=> "geese"
+      #
+      # @faker.version 1.3.0
+      def creature
+        fetch('team.creature')
+      end
+
+      ##
+      # Produces a team state.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Team.state #=> "Oregon"
+      #
+      # @faker.version 1.3.0
+      def state
+        fetch('address.state')
+      end
+
+      ##
+      # Produces a team sport.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Team.sport #=> "Lacrosse"
+      #
+      # @faker.version 1.5.0
+      def sport
+        fetch('team.sport')
+      end
+
+      ##
+      # Produces the name of a team mascot.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Team.mascot #=> "Hugo"
+      #
+      # @faker.version 1.8.1
+      def mascot
+        fetch('team.mascot')
+      end
+    end
+  end
+end

data/lib/faker/default/time.rb

@@ -0,0 +1,179 @@
+# 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
+      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Style/AsciiComments
+
+      ##
+      # Produce a random time between two times.
+      #
+      # @param from [Time, Date, DateTime] The start of the usable time range.
+      # @param to [Time, Date, DateTime] The end of the usable time range.
+      # @param format [Symbol] The name of a DateTime format to use.
+      # @return [Time]
+      #
+      # @example
+      #   # Random Stringified time between two times, formatted to the specified I18n format
+      #   # (Examples are from a Rails console with rails-i18n 5.1.1 defaults loaded)
+      #   I18n.locale = 'en-US'
+      #   Faker::Time.between(from: DateTime.now - 1, to: DateTime.now, format: :default) #=> "Tue, 16 Oct 2018 10:48:27 AM -05:00"
+      #   Faker::Time.between(from: DateTime.now - 1, to: DateTime.now, format: :short) #=> "15 Oct 10:48 AM"
+      #   Faker::Time.between(from: DateTime.now - 1, to: DateTime.now, format: :long) #=> "October 15, 2018 10:48 AM"
+      #
+      #   I18n.locale = 'ja'
+      #   Faker::Time.between(from: DateTime.now - 1, to: DateTime.now, format: :default) #=> "2018/10/15 10:48:27"
+      #   Faker::Time.between(from: DateTime.now - 1, to: DateTime.now, format: :short) #=> "18/10/15 10:48"
+      #   Faker::Time.between(from: DateTime.now - 1, to: DateTime.now, format: :long) #=> "2018年10月16日(火) 10時48分27秒 -0500"
+      #
+      # @faker.version 1.5.0
+      def between(legacy_from = NOT_GIVEN, legacy_to = NOT_GIVEN, legacy_format = NOT_GIVEN, from:, to:, format: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :from if legacy_from != NOT_GIVEN
+          keywords << :to if legacy_to != NOT_GIVEN
+          keywords << :format if legacy_format != NOT_GIVEN
+        end
+
+        from = get_time_object(from)
+        to = get_time_object(to)
+
+        time = Faker::Base.rand_in_range(from, to)
+        time_with_format(time, format)
+      end
+      # rubocop:enable Style/AsciiComments
+
+      ##
+      # Produce a random time between two dates.
+      #
+      # @param from [Date] The start of the usable time range.
+      # @param to [Date] The end of the usable time range.
+      # @param period [Symbol] The time of day, if any. See {TIME_RANGES}.
+      # @param format [Symbol] The name of a DateTime format to use.
+      # @return [Time]
+      #
+      # @example
+      #   Faker::Time.between_dates(from: Date.today - 1, to: Date.today, period: :all)
+      #     #=> "2014-09-19 07:03:30 -0700"
+      #   Faker::Time.between_dates(from: Date.today - 1, to: Date.today, period: :day)
+      #     #=> "2014-09-18 16:28:13 -0700"
+      #   Faker::Time.between_dates(from: Date.today - 1, to: Date.today, period: :night)
+      #     #=> "2014-09-20 19:39:38 -0700"
+      #   Faker::Time.between_dates(from: Date.today - 1, to: Date.today, period: :morning)
+      #     #=> "2014-09-19 08:07:52 -0700"
+      #   Faker::Time.between_dates(from: Date.today - 1, to: Date.today, period: :afternoon)
+      #     #=> "2014-09-18 12:10:34 -0700"
+      #   Faker::Time.between_dates(from: Date.today - 1, to: Date.today, period: :evening)
+      #     #=> "2014-09-19 20:21:03 -0700"
+      #   Faker::Time.between_dates(from: Date.today - 1, to: Date.today, period: :midnight)
+      #     #=> "2014-09-20 00:40:14 -0700"
+      #   Faker::Time.between_dates(from: Date.today - 5, to: Date.today + 5, period: :afternoon, format: :default)
+      #     #=> "Fri, 19 Oct 2018 15:17:46 -0500"
+      #
+      # @faker.version 1.0.0
+      def between_dates(legacy_from = NOT_GIVEN, legacy_to = NOT_GIVEN, legacy_period = NOT_GIVEN, legacy_format = NOT_GIVEN, from:, to:, period: :all, format: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :from if legacy_from != NOT_GIVEN
+          keywords << :to if legacy_to != NOT_GIVEN
+          keywords << :period if legacy_period != NOT_GIVEN
+          keywords << :format if legacy_format != NOT_GIVEN
+        end
+
+        date = Faker::Date.between(from: from, to: to)
+        time = date_with_random_time(date, period)
+        time_with_format(time, format)
+      end
+
+      ##
+      # Produce a random time in the future (up to N days).
+      #
+      # @param days [Integer] The maximum number of days to go into the future.
+      # @param period [Symbol] The time of day, if any. See {TIME_RANGES}.
+      # @param format [Symbol] The name of a DateTime format to use.
+      # @return [Time]
+      #
+      # @example
+      #   Faker::Time.forward(days: 23, period: :morning)
+      #     # => "2014-09-26 06:54:47 -0700"
+      #   Faker::Time.forward(days: 5,  period: :evening, format: :long)
+      #     #=> "October 21, 2018 20:47"
+      #
+      # @faker.version 1.5.0
+      def forward(legacy_days = NOT_GIVEN, legacy_period = NOT_GIVEN, legacy_format = NOT_GIVEN, days: 365, period: :all, format: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :days if legacy_days != NOT_GIVEN
+          keywords << :period if legacy_period != NOT_GIVEN
+          keywords << :format if legacy_format != NOT_GIVEN
+        end
+
+        time_with_format(date_with_random_time(Faker::Date.forward(days: days), period), format)
+      end
+
+      ##
+      # Produce a random time in the past (up to N days).
+      #
+      # @param days [Integer] The maximum number of days to go into the past.
+      # @param period [Symbol] The time of day, if any. See {TIME_RANGES}.
+      # @param format [Symbol] The name of a DateTime format to use.
+      # @return [Time]
+      #
+      # @example
+      #   Faker::Time.backward(days: 14, period: :evening)
+      #     #=> "2014-09-17 19:56:33 -0700"
+      #   Faker::Time.backward(days: 5, period: :morning, format: :short)
+      #     #=> "14 Oct 07:44"
+      #
+      # @faker.version 1.5.0
+      def backward(legacy_days = NOT_GIVEN, legacy_period = NOT_GIVEN, legacy_format = NOT_GIVEN, days: 365, period: :all, format: nil)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :days if legacy_days != NOT_GIVEN
+          keywords << :period if legacy_period != NOT_GIVEN
+          keywords << :format if legacy_format != NOT_GIVEN
+        end
+
+        time_with_format(date_with_random_time(Faker::Date.backward(days: days), period), format)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      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