faker 3.5.2 → 3.6.1

data/lib/faker/default/lorem.rb

@@ -194,7 +194,7 @@ module Faker
 
         paragraph += " #{paragraph(sentence_count: 3, supplemental: supplemental)}" while paragraph.length < number
 
-        "#{paragraph[0...number - 1]}."
+        "#{paragraph[0...(number - 1)]}."
       end
 
       ##

data/lib/faker/default/lorem_flickr.rb

@@ -96,7 +96,7 @@ module Faker
       private
 
       def build_url(size, format, search_terms, match_all)
-        raise ArgumentError, 'Size should be specified in format 300x300' unless size =~ /^[0-9]+x[0-9]+$/
+        raise ArgumentError, 'Size should be specified in format 300x300' unless size =~ /\A[0-9]+x[0-9]+\z/
 
         url_parts = ['https://loremflickr.com']
         url_parts << format

data/lib/faker/default/markdown.rb

@@ -28,7 +28,7 @@ module Faker
       def emphasis
         paragraph = Faker::Lorem.paragraph(sentence_count: 3)
         words = paragraph.split
-        position = rand(0..words.length - 1)
+        position = rand(0..(words.length - 1))
         formatting = fetch('markdown.emphasis')
         words[position] = "#{formatting}#{words[position]}#{formatting}"
         words.join(' ')
@@ -133,7 +133,7 @@ module Faker
       def random(*args)
         method_list = available_methods
         args&.each { |ex| method_list.delete_if { |meth| meth == ex.to_sym } }
-        send(method_list[Faker::Config.random.rand(0..method_list.length - 1)])
+        send(method_list[Faker::Config.random.rand(0..(method_list.length - 1))])
       end
 
       ##

data/lib/faker/default/placeholdit.rb

@@ -30,7 +30,7 @@ module Faker
         background_color = generate_color if background_color == :random
         text_color = generate_color if text_color == :random
 
-        raise ArgumentError, 'Size should be specified in format 300x300' unless size =~ /^[0-9]+x[0-9]+$/
+        raise ArgumentError, 'Size should be specified in format 300x300' unless size =~ /\A[0-9]+x[0-9]+\z$/
         raise ArgumentError, "Supported formats are #{SUPPORTED_FORMATS.join(', ')}" unless SUPPORTED_FORMATS.include?(format)
         raise ArgumentError, "background_color must be a hex value without '#'" unless background_color.nil? || background_color =~ /((?:^\h{3}$)|(?:^\h{6}$)){1}(?!.*\H)/
         raise ArgumentError, "text_color must be a hex value without '#'" unless text_color.nil? || text_color =~ /((?:^\h{3}$)|(?:^\h{6}$)){1}(?!.*\H)/

data/lib/faker/default/string.rb

@@ -24,7 +24,7 @@ module Faker
       private
 
       def select_a(length)
-        if length.class.included_modules.include? Enumerable
+        if length.class.include?(Enumerable)
           select_a sample(length.to_enum.to_a)
         else
           length # recursive base case

data/lib/faker/default/types.rb

@@ -116,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
@@ -136,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/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/music/bossa_nova.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'music'
+
+module Faker
+  class Music
+    class BossaNova < Base
+      class << self
+        ##
+        # Produces the name of a bossa nova artist.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Music::BossaNova.artist #=> "Tom Jobin"
+        #
+        # @faker.version 1.8.3
+        def artist
+          fetch('bossa_nova.artists')
+        end
+
+        ##
+        # Produces a bossa nova song.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::Music::BossaNova.song #=> "Chega de Saudade"
+        #
+        # @faker.version 1.8.3
+        def song
+          fetch('bossa_nova.songs')
+        end
+      end
+    end
+  end
+end

data/lib/faker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faker # :nodoc:
-  VERSION = '3.5.2'
+  VERSION = '3.6.1'
 end

data/lib/faker.rb

@@ -5,6 +5,8 @@ mydir = __dir__
 require 'psych'
 require 'i18n'
 
+autoload(:OpenSSL, 'openssl')
+
 Dir.glob(File.join(mydir, 'helpers', '*.rb')).each { |file| require file }
 
 I18n.load_path += Dir[File.join(mydir, 'locales', '**/*.yml')]
@@ -65,8 +67,8 @@ module Faker
         letterify(numerify(string))
       end
 
-      def generate(as_type, &block)
-        PositionalGenerator.new(as_type, &block).generate
+      def generate(as_type, &)
+        PositionalGenerator.new(as_type, &).generate
       end
 
       # Given a regular expression, attempt to generate a string
@@ -93,12 +95,12 @@ module Faker
         reg
           .gsub(%r{^/?\^?}, '').gsub(%r{\$?/?$}, '') # Ditch the anchors
           .gsub(/\{(\d+)\}/, '{\1,\1}').gsub('?', '{0,1}') # All {2} become {2,2} and ? become {0,1}
-          .gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # [12]{1,2} becomes [12] or [12][12]
-          .gsub(/(\([^)]+\))\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                 # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
-          .gsub(/(\\?.)\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                      # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
-          .gsub(/\((.*?)\)/) { |match| sample(match.gsub(/[()]/, '').split('|')) } # (this|that) becomes 'this' or 'that'
-          .gsub(/\[([^\]]+)\]/) { |match| match.gsub(/(\w-\w)/) { |range| sample(Array(Range.new(*range.split('-')))) } } # All A-Z inside of [] become C (or X, or whatever)
-          .gsub(/\[([^\]]+)\]/) { |_match| sample(Regexp.last_match(1).chars) } # All [ABC] become B (or A or C)
+          .gsub(/(\[[^\]]++\])\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # [12]{1,2} becomes [12] or [12][12]
+          .gsub(/(\([^)]++\))\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                 # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
+          .gsub(/(\\?.)\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                       # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
+          .gsub(/\((.*?)\)/) { |match| sample(match.gsub(/[()]/, '').split('|')) }                                                                                                # (this|that) becomes 'this' or 'that'
+          .gsub(/\[([^\]]++)\]/) { |match| match.gsub(/(\w-\w)/) { |range| sample(Array(Range.new(*range.split('-')))) } }                                                        # All A-Z inside of [] become C (or X, or whatever)
+          .gsub(/\[([^\]]++)\]/) { |_match| sample(Regexp.last_match(1).chars) }                                                                                                  # All [ABC] become B (or A or C)
           .gsub('\d') { |_match| sample(Numbers) }
           .gsub('\w') { |_match| sample(Letters) }
       end
@@ -131,7 +133,8 @@ module Faker
       # formatted translation: e.g., "#{first_name} #{last_name}".
       def parse(key)
         fetched = fetch(key)
-        parts = fetched.scan(/(\(?)#\{([A-Za-z]+\.)?([^}]+)\}([^#]+)?/).map do |prefix, kls, meth, etc|
+
+        parts = fetched.scan(/(\(?)#\{([A-Za-z]+\.)?([^}]+)\}([^#]++)?/).map do |prefix, kls, meth, etc|
           # If the token had a class Prefix (e.g., Name.first_name)
           # grab the constant, otherwise use self
           cls = kls ? Faker.const_get(kls.chop) : self
@@ -195,7 +198,7 @@ module Faker
       #   name:
       #     girls_name: ["Alice", "Cheryl", "Tatiana"]
       # Then you can call Faker::Name.girls_name and it will act like #first_name
-      def method_missing(mth, *args, &block)
+      def method_missing(mth, *args, &)
         super unless flexible_key
 
         if (translation = translate("faker.#{flexible_key}.#{mth}"))

data/lib/helpers/unique_generator.rb

@@ -30,7 +30,7 @@ module Faker
       method_name.to_s.start_with?('faker_') || super
     end
 
-    RetryLimitExceeded = Class.new(StandardError)
+    class RetryLimitExceeded < StandardError; end
 
     def previous_results
       Thread.current[:faker_unique_generator_previous_results] ||= {}

data/lib/locales/README.md

@@ -20,7 +20,7 @@ Faker::Hipster.word #=> "kogi"
 
 ## How to update a locale with more translations
 
-To update a locale with more translation features, simply add a new field to the .yml file that corresponds to an existing piece of functionality in the "en.yml" file. In this example, that would mean providing Chinese hipster words.
+To update a locale with more translation features, simply add a new field to the `.yml` file that corresponds to an existing piece of functionality in the "en.yml" file. In this example, that would mean providing Chinese hipster words.
 
 ```yaml
 # /lib/locales/zh-CN.yml
@@ -52,5 +52,5 @@ Faker::Config.default_locale = :pt
 In threaded server environments, e.g., Puma, locale per thread can be set as the following:
 
 ```ruby
-  Faker::Config.locale = :es
+Faker::Config.locale = :es
 ```