faker 2.13.0 → 3.8.0

data/lib/faker/default/types.rb

@@ -16,17 +16,11 @@ module Faker
       #   Faker::Types.rb_string #=> "foobar"
       #
       # @faker.version 1.8.6
-      def rb_string(legacy_words = NOT_GIVEN, words: 1)
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :words if legacy_words != NOT_GIVEN
-        end
-
+      def rb_string(words: 1)
         resolved_num = resolve(words)
-        word_list =
-          translate('faker.lorem.words')
-
+        word_list = translate('faker.lorem.words')
         word_list *= ((resolved_num / word_list.length) + 1)
-        shuffle(word_list)[0, resolved_num].join(' ')
+        sample(word_list, resolved_num).join(' ')
       end
 
       ##
@@ -51,12 +45,7 @@ module Faker
       #   Faker::Types.rb_integer #=> 1
       #
       # @faker.version 1.8.6
-      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
-
+      def rb_integer(from: 0, to: 100)
         rand(from..to).to_i
       end
 
@@ -72,15 +61,11 @@ module Faker
       #   Faker::Types.rb_hash(number: 2) #=> {name: "bob", last: "marley"}
       #
       # @faker.version 1.8.6
-      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
-
+      def rb_hash(number: 1, type: -> { random_type })
         {}.tap do |hsh|
           Lorem.words(number: number * 2).uniq.first(number).each do |s|
-            hsh.merge!(s.to_sym => type)
+            value = type.is_a?(Proc) ? type.call : type
+            hsh.merge!(s.to_sym => value)
           end
         end
       end
@@ -97,12 +82,8 @@ module Faker
       #   Faker::Types.complex_rb_hash(number: 2) #=> {user: {first: "bob", last: "marley"}, son: ["damien", "marley"]}
       #
       # @faker.version 1.8.6
-      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)
+      def complex_rb_hash(number: 1)
+        rb_hash(number: number, type: -> { random_complex_type })
       end
 
       ##
@@ -114,16 +95,13 @@ module Faker
       # @example
       #   Faker::Types.rb_array #=> ["a"]
       #   Faker::Types.rb_array(len: 4) #=> ["a", 1, 2, "bob"]
+      #   Faker::Types.rb_array(len: 2, type: -> { Faker::Types.rb_string }) #=> ["cat", "foo"]
       #
       # @faker.version 1.8.6
-      def rb_array(legacy_len = NOT_GIVEN, len: 1)
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :len if legacy_len != NOT_GIVEN
-        end
-
+      def rb_array(len: 1, type: -> { random_type })
         [].tap do |ar|
           len.times do
-            ar.push random_type
+            ar.push type.is_a?(Proc) ? type.call : type
           end
         end
       end
@@ -138,7 +116,7 @@ module Faker
       #
       # @faker.version 1.8.6
       def random_type
-        type_to_use = SIMPLE_TYPES[rand(0..SIMPLE_TYPES.length - 1)]
+        type_to_use = SIMPLE_TYPES[rand(0..(SIMPLE_TYPES.length - 1))]
         case type_to_use
         when :string
           rb_string
@@ -158,7 +136,7 @@ module Faker
       # @faker.version 1.8.6
       def random_complex_type
         types = SIMPLE_TYPES + COMPLEX_TYPES
-        type_to_use = types[rand(0..types.length - 1)]
+        type_to_use = types[rand(0..(types.length - 1))]
         case type_to_use
         when :string
           rb_string

data/lib/faker/default/vehicle.rb

@@ -6,10 +6,9 @@ module Faker
 
     MILEAGE_MIN = 10_000
     MILEAGE_MAX = 90_000
-    VIN_LETTERS = 'ABCDEFGHJKLMNPRSTUVWXYZ'
-    VIN_MAP = '0123456789X'
-    VIN_WEIGHTS = '8765432X098765432'
-    VIN_REGEX = /^[A-Z0-9]{3}[A-Z0-9]{5}[A-Z0-9]{1}[A-Z0-9]{1}[A-Z0-0]{1}[A-Z0-9]{1}\d{5}$/.freeze
+    VIN_KEYSPACE = %w[A B C D E F G H J K L M N P R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9].freeze
+    VIN_TRANSLITERATION = { A: 1, B: 2, C: 3, D: 4, E: 5, F: 6, G: 7, H: 8, J: 1, K: 2, L: 3, M: 4, N: 5, P: 7, R: 9, S: 2, T: 3, U: 4, V: 5, W: 6, X: 7, Y: 8, Z: 9 }.freeze
+    VIN_WEIGHT = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2].freeze
     SG_CHECKSUM_WEIGHTS = [3, 14, 2, 12, 2, 11, 1].freeze
     SG_CHECKSUM_CHARS = 'AYUSPLJGDBZXTRMKHEC'
 
@@ -23,7 +22,25 @@ module Faker
       #
       # @faker.version 1.6.4
       def vin
-        regexify(VIN_REGEX)
+        generate(:string) do |g|
+          g.letter(name: :wmi, ranges: ['100'..'199', '400'..'499', '500'..'599', '700'..'799', '7A0'..'7F9'])
+          g.letter(name: :vds, length: 5, ranges: [VIN_KEYSPACE])
+          g.computed(name: :checksum, deps: %i[wmi vds model_year plant_code vis]) do |wmi, vds, model_year, plant_code, vis|
+            checksum = "#{wmi}#{vds}0#{model_year}#{plant_code}#{vis}".chars.each_with_index.map do |char, i|
+              value = (char =~ /\A\d\z/ ? char.to_i : VIN_TRANSLITERATION[char.to_sym])
+              value * VIN_WEIGHT[i]
+            end.inject(:+) % 11
+
+            if checksum == 10
+              'X'
+            else
+              checksum
+            end
+          end
+          g.letter(name: :model_year, length: 1, ranges: [VIN_KEYSPACE - %w[U Z 0]])
+          g.letter(name: :plant_code, length: 1, ranges: [VIN_KEYSPACE])
+          g.int(name: :vis, length: 6)
+        end
       end
 
       # Produces a random vehicle manufacturer.
@@ -31,12 +48,13 @@ module Faker
       # @return [String]
       #
       # @example
-      #   Faker::Vehicle.manufacture #=> "Lamborghini"
+      #   Faker::Vehicle.manufacturer #=> "Lamborghini"
       #
       # @faker.version 1.6.4
-      def manufacture
-        fetch('vehicle.manufacture')
+      def manufacturer
+        fetch('vehicle.manufacturer')
       end
+      alias manufacture manufacturer
 
       ##
       # Produces a random vehicle make.
@@ -62,11 +80,7 @@ module Faker
       #   Faker::Vehicle.model(make_of_model: 'Toyota') #=> "Prius"
       #
       # @faker.version 1.6.4
-      def model(legacy_make_of_model = NOT_GIVEN, make_of_model: '')
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :make_of_model if legacy_make_of_model != NOT_GIVEN
-        end
-
+      def model(make_of_model: '')
         return fetch("vehicle.models_by_make.#{make}") if make_of_model.empty?
 
         fetch("vehicle.models_by_make.#{make_of_model}")
@@ -249,12 +263,7 @@ module Faker
       #   Faker::Vehicle.kilometrage #=> 35378
       #
       # @faker.version 1.6.4
-      def mileage(legacy_min = NOT_GIVEN, legacy_max = NOT_GIVEN, min: MILEAGE_MIN, max: MILEAGE_MAX)
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :min if legacy_min != NOT_GIVEN
-          keywords << :max if legacy_max != NOT_GIVEN
-        end
-
+      def mileage(min: MILEAGE_MIN, max: MILEAGE_MAX)
         rand_in_range(min, max)
       end
 
@@ -271,14 +280,10 @@ module Faker
       #   Faker::Vehicle.license_plate(state_abbreviation: 'FL') #=> "977 UNU"
       #
       # @faker.version 1.6.4
-      def license_plate(legacy_state_abreviation = NOT_GIVEN, state_abbreviation: '')
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :state_abbreviation if legacy_state_abreviation != NOT_GIVEN
-        end
-
+      def license_plate(state_abbreviation: '')
         return regexify(bothify(fetch('vehicle.license_plate'))) if state_abbreviation.empty?
 
-        key = 'vehicle.license_plate_by_state.' + state_abbreviation
+        key = "vehicle.license_plate_by_state.#{state_abbreviation}"
         regexify(bothify(fetch(key)))
       end
 
@@ -297,45 +302,30 @@ module Faker
         "#{plate_number}#{singapore_checksum(plate_number)}"
       end
 
-      private
-
-      def first_eight(number)
-        return number[0...8] unless number.nil?
-
-        regexify(VIN_REGEX)
-      end
-      alias last_eight first_eight
-
-      def calculate_vin_check_digit(vin)
-        sum = 0
-
-        vin.each_char.with_index do |c, i|
-          n = vin_char_to_number(c).to_i
-          weight = VIN_WEIGHTS[i].to_i
-          sum += weight * n
-        end
-
-        mod = sum % 11
-        mod == 10 ? 'X' : mod
+      ##
+      # Produces a car version
+      #
+      # @return [String]
+      #
+      # @example
+      #  Faker::Vehicle.version #=> "40 TFSI Premium"
+      #
+      # @faker.version next
+      def version
+        fetch('vehicle.version')
       end
 
-      def vin_char_to_number(char)
-        index = VIN_LETTERS.split('').index(char)
-
-        return char.to_i if index.nil?
-
-        VIN_MAP[index]
-      end
+      private
 
       def singapore_checksum(plate_number)
-        padded_alphabets = format('%3s', plate_number[/^[A-Z]+/]).tr(' ', '-').split('')
-        padded_digits = format('%04d', plate_number[/\d+/]).split('').map(&:to_i)
+        padded_alphabets = format('%3s', plate_number[/^[A-Z]+/]).tr(' ', '-').chars
+        padded_digits = format('%04d', plate_number[/\d+/]).chars.map(&:to_i)
         sum = [*padded_alphabets, *padded_digits].each_with_index.reduce(0) do |memo, (char, i)|
           value = char.is_a?(Integer) ? char : char.ord - 64
           memo + (SG_CHECKSUM_WEIGHTS[i] * value)
         end
 
-        SG_CHECKSUM_CHARS.split('')[sum % 19]
+        SG_CHECKSUM_CHARS.chars[sum % 19]
       end
     end
   end

data/lib/faker/default/vulnerability_identifier.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Faker
+  class VulnerabilityIdentifier < Base
+    class << self
+      ##
+      # Produces a Common Vulnerabilities and Exposures (CVE) identifier.
+      #
+      # @param year [Integer] The year-part of the CVE identifier (defaults to the current year)
+      # @return [String]
+      #
+      # @example
+      #   Faker::VulnerabilityIdentifier.cve #=> "CVE-2021-1337"
+      #   Faker::VulnerabilityIdentifier.cve(year: 1999) #=> "CVE-1999-0523"
+      #
+      # @faker.version next
+      def cve(year: ::Date.today.year)
+        index = rand_in_range(1, 99_999).to_s.rjust(4, '0')
+        "CVE-#{year}-#{index}"
+      end
+    end
+  end
+end

data/lib/faker/default/world_cup.rb

@@ -53,11 +53,7 @@ module Faker
       #   Faker::WorldCup.group #=> "Russia"
       #
       # @faker.version 2.13.0
-      def group(legacy_group = NOT_GIVEN, group: 'group_A')
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :group if legacy_group != NOT_GIVEN
-        end
-
+      def group(group: 'group_A')
         fetch("world_cup.groups.#{group}")
       end
 
@@ -73,12 +69,7 @@ module Faker
       #   Faker::WorldCup.roster(country: 'Spain', type: 'forwards') #=> "Diego Costa"
       #
       # @faker.version 2.13.0
-      def roster(legacy_country = NOT_GIVEN, legacy_type = NOT_GIVEN, country: 'Egypt', type: 'coach')
-        warn_for_deprecated_arguments do |keywords|
-          keywords << :country if legacy_country != NOT_GIVEN
-          keywords << :type if legacy_type != NOT_GIVEN
-        end
-
+      def roster(country: 'Egypt', type: 'coach')
         fetch("world_cup.rosters.#{country}.#{type}")
       end
     end

data/lib/faker/default/x.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Faker
+  class X < Base
+    class << self
+      ##
+      # Produces a random X user based on X's v2 API.
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   Faker::X.user #=>  { data: [{:id=>"8821452687517076614", :name=>"Lincoln Paucek", :screen_name=>"cody"...
+      #
+      # @faker.version 1.7.3
+      def user
+        author_id = Faker::Number.between(from: 1, to: 9_223_372_036_854_775_807)
+
+        {
+          data: [
+            {
+              author_id: author_id.to_s,
+              id: id.to_s,
+              text: Faker::Lorem.sentence
+            }
+          ],
+          includes: {
+            users: [
+              {
+                public_metrics: {
+                  followers_count: Faker::Number.between(to: 1, from: 1_000),
+                  following_count: Faker::Number.between(to: 1, from: 200),
+                  tweet_count: Faker::Number.between(to: 1, from: 10_000),
+                  listed_count: Faker::Number.between(to: 1, from: 1_000)
+                },
+                username: screen_name,
+                pinned_tweet_id: Faker::Number.between(from: 1, to: 9_223_372_036_854_775_807).to_s,
+                entities: user_entities,
+                description: Faker::Lorem.sentence,
+                name: Faker::Name.name,
+                verified: Faker::Boolean.boolean(true_ratio: 0.1),
+                location: Faker::Internet.public_ip_v4_address,
+                id: author_id.to_s,
+                protected: Faker::Boolean.boolean(true_ratio: 0.1),
+                url: url,
+                profile_image_url: Faker::Avatar.image(slug: id, size: '48x48'),
+                created_at: created_at
+              }
+            ]
+          }
+        }
+      end
+
+      ##
+      # Produces a random X tweet with default attributes.
+      #
+      # @param include_user [Boolean] Include user details
+      # @param include_media [Boolean] Include user media (photo) details
+      # @return [Hash]
+      #
+      # @example
+      #   Faker::X.tweet #=> { data: [{:id=>"8821452687517076614", :text=>"Ea et laboriosam vel non."...
+      #   Faker::X.tweet(include_media: true) # Get a tweet object with a photo media attachment
+      #   Faker::X.tweet(include_user: true) # Get a tweet object with an user details
+      #
+      # @faker.version 1.7.3
+      def tweet(include_media: false, include_user: false)
+        tweet = {}
+        tweet_object = tweet_item
+        includes = {}
+
+        if include_media
+          media_key = Faker::Number.between(from: 1, to: 9_223_372_036_854_775_807).to_s
+
+          includes[:media] = media(media_key)
+          tweet_object[:attachments] = { media_keys: [media_key] }
+        end
+
+        includes[:users] = user[:includes][:users] if include_user
+
+        tweet[:data] = [
+          tweet_object
+        ]
+
+        unless includes.empty?
+          tweet[:includes] = includes
+        end
+
+        tweet
+      end
+
+      ##
+      # Produces a random screen_name.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::X.screen_name #=> "audreanne_hackett"
+      #
+      # @faker.version 1.7.3
+      def screen_name
+        Faker::Internet.username(specifier: nil, separators: ['_'])[0...20]
+      end
+
+      private
+
+      def id
+        Faker::Number.between(from: 1, to: 9_223_372_036_854_775_807)
+      end
+
+      def created_at
+        Faker::Date.between(from: '2006-03-21', to: ::Date.today).to_time.utc.iso8601(3)
+      end
+
+      def url
+        "https://t.co/#{Faker::Lorem.characters(number: 10)}"
+      end
+
+      def user_entities
+        entities = tweet_entities
+
+        {
+          url: {
+            urls: entities[:urls]
+          },
+          description: {
+            hashtags: entities[:hashtags]
+          }
+        }
+      end
+
+      def tweet_entities
+        display_url = Faker::Internet.url(host: 'example.com')
+
+        {
+          urls: [
+            {
+              start: 0,
+              end: 5,
+              url: url,
+              expanded_url: display_url,
+              display_url: display_url.sub('http://', '')
+            }
+          ],
+          hashtags: [
+            {
+              start: 0,
+              end: 5,
+              tag: Faker::Lorem.word.capitalize
+            }
+          ]
+        }
+      end
+
+      def media(media_key)
+        expanded_url = Faker::LoremFlickr.image(size: '1064x600')
+
+        [{
+          height: Faker::Number.between(to: 1, from: 1000),
+          media_key: media_key,
+          type: 'photo',
+          preview_image_url: expanded_url,
+          width: Faker::Number.between(to: 1, from: 2000),
+          alt_text: Faker::Lorem.sentence
+        }]
+      end
+
+      def tweet_item
+        conversation_id = id.to_s
+
+        {
+          id: conversation_id,
+          text: Faker::Lorem.sentence,
+          lang: sample(%w[en fr es pt it ja]),
+          conversation_id: conversation_id,
+          created_at: created_at,
+          author_id: Faker::Number.between(from: 1, to: 9_223_372_036_854_775_807).to_s,
+          public_metrics: {
+            retweet_count: Faker::Number.between(to: 1, from: 100),
+            reply_count: Faker::Number.between(to: 1, from: 20),
+            like_count: Faker::Number.between(to: 1, from: 25),
+            quote_count: Faker::Number.between(to: 1, from: 10)
+          },
+          possibly_sensitive: Faker::Boolean.boolean(true_ratio: 0.1),
+          entities: tweet_entities
+        }
+      end
+    end
+  end
+end

data/lib/faker/default.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Faker
+  class Default
+    if Faker::Config.lazy_loading?
+      Faker.lazy_load(self)
+    end
+  end
+end

data/lib/faker/fantasy/tolkien.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Faker
+  class Fantasy
+    class Tolkien < Base
+      flexible :tolkien
+
+      class << self
+        ##
+        # Produces a character from Tolkien's legendarium
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Fantasy::Tolkien.character
+        #    #=> "Goldberry"
+        #
+        # @faker.version next
+        def character
+          fetch('tolkien.characters')
+        end
+
+        ##
+        # Produces a location from Tolkien's legendarium
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Fantasy::Tolkien.location
+        #    #=> "Helm's Deep"
+        #
+        # @faker.version next
+        def location
+          fetch('tolkien.locations')
+        end
+
+        ##
+        # Produces a race from Tolkien's legendarium
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Fantasy::Tolkien.race
+        #     #=> "Uruk-hai"
+        #
+        # @faker.version next
+        def race
+          fetch('tolkien.races')
+        end
+
+        ##
+        # Produces the name of a poem from Tolkien's legendarium
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Fantasy::Tolkien.poem
+        #     #=> "Chip the glasses and crack the plates"
+        #
+        # @faker.version next
+        def poem
+          fetch('tolkien.poems')
+        end
+      end
+    end
+  end
+end

data/lib/faker/fantasy.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Faker
+  class Fantasy
+    if Faker::Config.lazy_loading?
+      Faker.lazy_load(self)
+    end
+  end
+end

data/lib/faker/games/clash_of_clans.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Faker
+  class Games
+    class ClashOfClans < Base
+      class << self
+        ##
+        # Produces the name of a troop from Clash of Clans.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Games::ClashOfClans.troop #=> "Barbarian"
+        #
+        # @faker.version next
+        def troop
+          fetch('games.clash_of_clans.troops')
+        end
+
+        ##
+        # Produces the name of a rank from Clash Of Clans.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Games::ClashOfClans.rank #=> "Legend"
+        #
+        # @faker.version next
+        def rank
+          fetch('games.clash_of_clans.ranks')
+        end
+
+        ##
+        # Produces the name of a defensive building from Clash Of Clans.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Games::ClashOfClans.defensive_building #=> "Cannon"
+        #
+        # @faker.version next
+        def defensive_building
+          fetch('games.clash_of_clans.defensive_buildings')
+        end
+      end
+    end
+  end
+end

data/lib/faker/games/control.rb

@@ -23,7 +23,7 @@ module Faker
         # @return [String]
         #
         # @example
-        #   Faker::Games::Control.character #=> "Dimensional Research"
+        #   Faker::Games::Control.location #=> "Dimensional Research"
         #
         # @faker.version 2.13.0
         def location