faker 1.9.6 → 2.7.0

data/lib/faker/default/time.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Faker
-  class Time < Faker::Date
+  class Time < Base
     TIME_RANGES = {
       all: (0..23),
       day: (9..17),
@@ -13,19 +13,138 @@ module Faker
     }.freeze
 
     class << self
-      def between(from, to, period = :all, format = nil)
-        time = period == :between ? rand(from..to) : date_with_random_time(super(from, to), period)
+      # 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
 
-      def forward(days = 365, period = :all, format = nil)
-        time_with_format(date_with_random_time(super(days), period), format)
+      ##
+      # 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
 
-      def backward(days = 365, period = :all, format = nil)
-        time_with_format(date_with_random_time(super(days), period), format)
+      ##
+      # 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)
@@ -33,7 +152,7 @@ module Faker
       end
 
       def time_with_format(time, format)
-        format.nil? ? time : I18n.l(DateTime.parse(time.to_s), format: format)
+        format.nil? ? time : I18n.localize(time, format: format)
       end
 
       def hours(period)
@@ -49,6 +168,12 @@ module Faker
       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

data/lib/faker/default/twitter.rb

@@ -3,58 +3,68 @@
 module Faker
   class Twitter < Base
     class << self
-      def user(include_status: true, include_email: false)
+      def user(legacy_include_status = NOT_GIVEN, legacy_include_email = NOT_GIVEN, include_status: true, include_email: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :include_status if legacy_include_status != NOT_GIVEN
+          keywords << :include_email if legacy_include_email != NOT_GIVEN
+        end
+
         user_id = id
-        background_image_url = Faker::LoremPixel.image('600x400') # TODO: Make the dimensions change
-        profile_image_url = Faker::Avatar.image(user_id, '48x48')
+        background_image_url = Faker::LoremPixel.image(size: '600x400') # TODO: Make the dimensions change
+        profile_image_url = Faker::Avatar.image(slug: user_id, size: '48x48')
         user = {
           id: user_id,
           id_str: user_id.to_s,
-          contributors_enabled: Faker::Boolean.boolean(0.1),
+          contributors_enabled: Faker::Boolean.boolean(true_ratio: 0.1),
           created_at: created_at,
-          default_profile_image: Faker::Boolean.boolean(0.1),
-          default_profile: Faker::Boolean.boolean(0.1),
+          default_profile_image: Faker::Boolean.boolean(true_ratio: 0.1),
+          default_profile: Faker::Boolean.boolean(true_ratio: 0.1),
           description: Faker::Lorem.sentence,
-          entities:  user_entities,
-          favourites_count: Faker::Number.between(1, 100_000),
+          entities: user_entities,
+          favourites_count: Faker::Number.between(to: 1, from: 100_000),
           follow_request_sent: false,
-          followers_count: Faker::Number.between(1, 10_000_000),
+          followers_count: Faker::Number.between(to: 1, from: 10_000_000),
           following: false,
-          friends_count: Faker::Number.between(1, 100_000),
-          geo_enabled: Faker::Boolean.boolean(0.1),
-          is_translation_enabled: Faker::Boolean.boolean(0.1),
-          is_translator: Faker::Boolean.boolean(0.1),
+          friends_count: Faker::Number.between(to: 1, from: 100_000),
+          geo_enabled: Faker::Boolean.boolean(true_ratio: 0.1),
+          is_translation_enabled: Faker::Boolean.boolean(true_ratio: 0.1),
+          is_translator: Faker::Boolean.boolean(true_ratio: 0.1),
           lang: Faker::Address.country_code,
-          listed_count: Faker::Number.between(1, 1000),
+          listed_count: Faker::Number.between(to: 1, from: 1000),
           location: "#{Faker::Address.city}, #{Faker::Address.state_abbr}, #{Faker::Address.country_code}",
           name: Faker::Name.name,
           notifications: false,
           profile_background_color: Faker::Color.hex_color,
           profile_background_image_url_https: background_image_url,
           profile_background_image_url: background_image_url.sub('https://', 'http://'),
-          profile_background_tile: Faker::Boolean.boolean(0.1),
-          profile_banner_url: Faker::LoremPixel.image('1500x500'),
+          profile_background_tile: Faker::Boolean.boolean(true_ratio: 0.1),
+          profile_banner_url: Faker::LoremPixel.image(size: '1500x500'),
           profile_image_url_https: profile_image_url,
           profile_image_url: profile_image_url.sub('https://', 'http://'),
           profile_link_color: Faker::Color.hex_color,
           profile_sidebar_border_color: Faker::Color.hex_color,
           profile_sidebar_fill_color: Faker::Color.hex_color,
           profile_text_color: Faker::Color.hex_color,
-          profile_use_background_image: Faker::Boolean.boolean(0.4),
-          protected: Faker::Boolean.boolean(0.1),
+          profile_use_background_image: Faker::Boolean.boolean(true_ratio: 0.4),
+          protected: Faker::Boolean.boolean(true_ratio: 0.1),
           screen_name: screen_name,
-          statuses_count: Faker::Number.between(1, 100_000),
+          statuses_count: Faker::Number.between(to: 1, from: 100_000),
           time_zone: Faker::Address.time_zone,
-          url: Faker::Internet.url('example.com'),
+          url: Faker::Internet.url(host: 'example.com'),
           utc_offset: utc_offset,
-          verified: Faker::Boolean.boolean(0.1)
+          verified: Faker::Boolean.boolean(true_ratio: 0.1)
         }
         user[:status] = Faker::Twitter.status(include_user: false) if include_status
         user[:email] = Faker::Internet.safe_email if include_email
         user
       end
 
-      def status(include_user: true, include_photo: false)
+      def status(legacy_include_user = NOT_GIVEN, legacy_include_photo = NOT_GIVEN, include_user: true, include_photo: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :include_user if legacy_include_user != NOT_GIVEN
+          keywords << :include_photo if legacy_include_photo != NOT_GIVEN
+        end
+
         status_id = id
         status = {
           id: status_id,
@@ -62,8 +72,8 @@ module Faker
           contributors: nil,
           coordinates: nil,
           created_at: created_at,
-          entities:  status_entities(include_photo: include_photo),
-          favorite_count: Faker::Number.between(1, 10_000),
+          entities: status_entities(include_photo: include_photo),
+          favorite_count: Faker::Number.between(to: 1, from: 10_000),
           favorited: false,
           geo: nil,
           in_reply_to_screen_name: nil,
@@ -74,11 +84,11 @@ module Faker
           lang: Faker::Address.country_code,
           nil: nil,
           place: nil,
-          possibly_sensitive: Faker::Boolean.boolean(0.1),
-          retweet_count: Faker::Number.between(1, 10_000),
-          retweeted_status:  nil,
+          possibly_sensitive: Faker::Boolean.boolean(true_ratio: 0.1),
+          retweet_count: Faker::Number.between(to: 1, from: 10_000),
+          retweeted_status: nil,
           retweeted: false,
-          source: "<a href=\"#{Faker::Internet.url('example.com')}\" rel=\"nofollow\">#{Faker::Company.name}</a>",
+          source: "<a href=\"#{Faker::Internet.url(host: 'example.com')}\" rel=\"nofollow\">#{Faker::Company.name}</a>",
           text: Faker::Lorem.sentence,
           truncated: false
         }
@@ -88,40 +98,44 @@ module Faker
       end
 
       def screen_name
-        Faker::Internet.username(nil, ['_'])[0...20]
+        Faker::Internet.username(specifier: nil, separators: ['_'])[0...20]
       end
 
       private
 
       def id
-        Faker::Number.between(1, 9_223_372_036_854_775_807)
+        Faker::Number.between(from: 1, to: 9_223_372_036_854_775_807)
       end
 
       def created_at
-        Faker::Date.between('2006-03-21', ::Date.today).strftime('%a %b %d %H:%M:%S %z %Y')
+        Faker::Date.between(from: '2006-03-21', to: ::Date.today).strftime('%a %b %d %H:%M:%S %z %Y')
       end
 
       def utc_offset
-        Faker::Number.between(-43_200, 50_400)
+        Faker::Number.between(to: -43_200, from: 50_400)
       end
 
       def user_entities
         {
-          url:  {
+          url: {
             urls: []
           },
-          description:  {
+          description: {
             urls: []
           }
         }
       end
 
-      def status_entities(include_photo: false)
+      def status_entities(legacy_include_photo = NOT_GIVEN, include_photo: false)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :include_photo if legacy_include_photo != NOT_GIVEN
+        end
+
         entities = {
-          hashtags:  [],
-          symbols:  [],
-          user_mentions:  [],
-          urls:  []
+          hashtags: [],
+          symbols: [],
+          user_mentions: [],
+          urls: []
         }
         entities[:media] = [photo_entity] if include_photo
         entities
@@ -130,38 +144,38 @@ module Faker
       def photo_entity
         # TODO: Dynamic image sizes
         # TODO: Return accurate indices
-        media_url = Faker::LoremPixel.image('1064x600')
+        media_url = Faker::LoremPixel.image(size: '1064x600')
         media_id = id
         {
           id: media_id,
           id_str: media_id.to_s,
-          indices:  [
+          indices: [
             103,
             126
           ],
           media_url: media_url.sub('https://', 'http://'),
           media_url_https: media_url,
-          url: Faker::Internet.url('example.com'),
+          url: Faker::Internet.url(host: 'example.com'),
           display_url: 'example.com',
-          expanded_url: Faker::Internet.url('example.com'),
+          expanded_url: Faker::Internet.url(host: 'example.com'),
           type: 'photo',
-          sizes:  {
-            medium:  {
+          sizes: {
+            medium: {
               w: 1064,
               h: 600,
               resize: 'fit'
             },
-            large:  {
+            large: {
               w: 1064,
               h: 600,
               resize: 'fit'
             },
-            small:  {
+            small: {
               w: 680,
               h: 383,
               resize: 'fit'
             },
-            thumb:  {
+            thumb: {
               w: 150,
               h: 150,
               resize: 'crop'

data/lib/faker/default/types.rb

@@ -7,7 +7,11 @@ module Faker
     COMPLEX_TYPES = %i[hash array].freeze
 
     class << self
-      def rb_string(words = 1)
+      def rb_string(legacy_words = NOT_GIVEN, words: 1)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :words if legacy_words != NOT_GIVEN
+        end
+
         resolved_num = resolve(words)
         word_list =
           translate('faker.lorem.words')
@@ -20,23 +24,41 @@ module Faker
         sample(CHARACTERS)
       end
 
-      def rb_integer(from = 0, to = 100)
+      def rb_integer(legacy_from = NOT_GIVEN, legacy_to = NOT_GIVEN, from: 0, to: 100)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :from if legacy_from != NOT_GIVEN
+          keywords << :to if legacy_to != NOT_GIVEN
+        end
+
         rand(from..to).to_i
       end
 
-      def rb_hash(key_count = 1, type = random_type)
+      def rb_hash(legacy_number = NOT_GIVEN, legacy_type = NOT_GIVEN, number: 1, type: random_type)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+          keywords << :type if legacy_type != NOT_GIVEN
+        end
+
         {}.tap do |hsh|
-          Lorem.words(key_count * 2).uniq.first(key_count).each do |s|
+          Lorem.words(number: number * 2).uniq.first(number).each do |s|
             hsh.merge!(s.to_sym => type)
           end
         end
       end
 
-      def complex_rb_hash(key_count = 1)
-        rb_hash(key_count, random_complex_type)
+      def complex_rb_hash(legacy_number = NOT_GIVEN, number: 1)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :number if legacy_number != NOT_GIVEN
+        end
+
+        rb_hash(number: number, type: random_complex_type)
       end
 
-      def rb_array(len = 1)
+      def rb_array(legacy_len = NOT_GIVEN, len: 1)
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :len if legacy_len != NOT_GIVEN
+        end
+
         [].tap do |ar|
           len.times do
             ar.push random_type