faker 1.1.2 → 3.2.0

data/lib/faker/default/omniauth.rb

@@ -0,0 +1,471 @@
+# frozen_string_literal: true
+
+module Faker
+  class Omniauth < Base
+    require 'time'
+    attr_reader :name,
+                :first_name,
+                :last_name,
+                :email
+
+    def initialize(name: nil, email: nil)
+      super()
+
+      @name = name || "#{Name.first_name} #{Name.last_name}"
+      @email = email || Internet.email(name: self.name)
+      @first_name, @last_name = self.name.split
+    end
+
+    class << self
+      ##
+      # Generate a mock Omniauth response from Google.
+      #
+      # @param name [String] A specific name to return in the response.
+      # @param email [String] A specific email to return in the response.
+      # @param uid [String] A specific UID to return in the response.
+      #
+      # @return [Hash] An auth hash in the format provided by omniauth-google.
+      #
+      # @faker.version 1.8.0
+      def google(name: nil, email: nil, uid: Number.number(digits: 9).to_s)
+        auth = Omniauth.new(name: name, email: email)
+        {
+          provider: 'google_oauth2',
+          uid: uid,
+          info: {
+            name: auth.name,
+            first_name: auth.first_name,
+            last_name: auth.last_name,
+            email: auth.email,
+            image: image
+          },
+          credentials: {
+            token: Crypto.md5,
+            refresh_token: Crypto.md5,
+            expires_at: Time.forward.to_i,
+            expires: true
+          },
+          extra: {
+            raw_info: {
+              sub: uid,
+              email: auth.email,
+              email_verified: random_boolean.to_s,
+              name: auth.name,
+              given_name: auth.first_name,
+              family_name: auth.last_name,
+              profile: "https://plus.google.com/#{uid}",
+              picture: image,
+              gender: gender,
+              birthday: Date.backward(days: 36_400).strftime('%Y-%m-%d'),
+              locale: 'en',
+              hd: "#{Company.name.downcase}.com"
+            },
+            id_info: {
+              iss: 'accounts.google.com',
+              at_hash: Crypto.md5,
+              email_verified: true,
+              sub: Number.number(digits: 28).to_s,
+              azp: 'APP_ID',
+              email: auth.email,
+              aud: 'APP_ID',
+              iat: Time.forward.to_i,
+              exp: Time.forward.to_i,
+              openid_id: "https://www.google.com/accounts/o8/id?id=#{uid}"
+            }
+          }
+        }
+      end
+
+      ##
+      # Generate a mock Omniauth response from Facebook.
+      #
+      # @param name [String] A specific name to return in the response.
+      # @param email [String] A specific email to return in the response.
+      # @param username [String] A specific username to return in the response.
+      # @param uid [String] A specific UID to return in the response.
+      #
+      # @return [Hash] An auth hash in the format provided by omniauth-facebook.
+      #
+      # @faker.version 1.8.0
+      def facebook(name: nil, email: nil, username: nil, uid: Number.number(digits: 7).to_s)
+        auth = Omniauth.new(name: name, email: email)
+        username ||= "#{auth.first_name.downcase[0]}#{auth.last_name.downcase}"
+        {
+          provider: 'facebook',
+          uid: uid,
+          info: {
+            email: auth.email,
+            name: auth.name,
+            first_name: auth.first_name,
+            last_name: auth.last_name,
+            image: image,
+            verified: random_boolean
+          },
+          credentials: {
+            token: Crypto.md5,
+            expires_at: Time.forward.to_i,
+            expires: true
+          },
+          extra: {
+            raw_info: {
+              id: uid,
+              name: auth.name,
+              first_name: auth.first_name,
+              last_name: auth.last_name,
+              link: "http://www.facebook.com/#{username}",
+              username: username,
+              location: {
+                id: Number.number(digits: 9).to_s,
+                name: city_state
+              },
+              gender: gender,
+              email: auth.email,
+              timezone: timezone,
+              locale: 'en_US',
+              verified: random_boolean,
+              updated_time: Time.backward.iso8601
+            }
+          }
+        }
+      end
+
+      ##
+      # Generate a mock Omniauth response from Twitter.
+      #
+      # @param name [String] A specific name to return in the response.
+      # @param nickname [String] A specific nickname to return in the response.
+      # @param uid [String] A specific UID to return in the response.
+      #
+      # @return [Hash] An auth hash in the format provided by omniauth-twitter.
+      #
+      # @faker.version 1.8.0
+      def twitter(name: nil, nickname: nil, uid: Number.number(digits: 6).to_s)
+        auth = Omniauth.new(name: name)
+        nickname ||= auth.name.downcase.delete(' ')
+        location = city_state
+        description = Lorem.sentence
+        {
+          provider: 'twitter',
+          uid: uid,
+          info: {
+            nickname: nickname,
+            name: auth.name,
+            location: location,
+            image: image,
+            description: description,
+            urls: {
+              Website: nil,
+              Twitter: "https://twitter.com/#{nickname}"
+            }
+          },
+          credentials: {
+            token: Crypto.md5,
+            secret: Crypto.md5
+          },
+          extra: {
+            access_token: '',
+            raw_info: {
+              name: auth.name,
+              listed_count: random_number_from_range(1..10),
+              profile_sidebar_border_color: Color.hex_color,
+              url: nil,
+              lang: 'en',
+              statuses_count: random_number_from_range(1..1000),
+              profile_image_url: image,
+              profile_background_image_url_https: image,
+              location: location,
+              time_zone: Address.city,
+              follow_request_sent: random_boolean,
+              id: uid,
+              profile_background_tile: random_boolean,
+              profile_sidebar_fill_color: Color.hex_color,
+              followers_count: random_number_from_range(1..10_000),
+              default_profile_image: random_boolean,
+              screen_name: '',
+              following: random_boolean,
+              utc_offset: timezone,
+              verified: random_boolean,
+              favourites_count: random_number_from_range(1..10),
+              profile_background_color: Color.hex_color,
+              is_translator: random_boolean,
+              friends_count: random_number_from_range(1..10_000),
+              notifications: random_boolean,
+              geo_enabled: random_boolean,
+              profile_background_image_url: image,
+              protected: random_boolean,
+              description: description,
+              profile_link_color: Color.hex_color,
+              created_at: Time.backward.strftime('%a %b %d %H:%M:%S %z %Y'),
+              id_str: uid,
+              profile_image_url_https: image,
+              default_profile: random_boolean,
+              profile_use_background_image: random_boolean,
+              entities: {
+                description: {
+                  urls: []
+                }
+              },
+              profile_text_color: Color.hex_color,
+              contributors_enabled: random_boolean
+            }
+          }
+        }
+      end
+
+      ##
+      # Generate a mock Omniauth response from LinkedIn.
+      #
+      # @param name [String] A specific name to return in the response.
+      # @param email [String] A specific email to return in the response.
+      # @param uid [String] A specific UID to return in the response.
+      #
+      # @return [Hash] An auth hash in the format provided by omniauth-linkedin.
+      #
+      # @faker.version 1.8.0
+      def linkedin(name: nil, email: nil, uid: Number.number(digits: 6).to_s)
+        auth = Omniauth.new(name: name, email: email)
+        first_name = auth.first_name.downcase
+        last_name = auth.last_name.downcase
+        location = city_state
+        description = Lorem.sentence
+        token = Crypto.md5
+        secret = Crypto.md5
+        industry = Commerce.department
+        url = "http://www.linkedin.com/in/#{first_name}#{last_name}"
+        {
+          provider: 'linkedin',
+          uid: uid,
+          info: {
+            name: auth.name,
+            email: auth.email,
+            nickname: auth.name,
+            first_name: auth.first_name,
+            last_name: auth.last_name,
+            location: location,
+            description: description,
+            image: image,
+            phone: PhoneNumber.phone_number,
+            headline: description,
+            industry: industry,
+            urls: {
+              public_profile: url
+            }
+          },
+          credentials: {
+            token: token,
+            secret: secret
+          },
+          extra: {
+            access_token: {
+              token: token,
+              secret: secret,
+              consumer: nil,
+              params: {
+                oauth_token: token,
+                oauth_token_secret: secret,
+                oauth_expires_in: Time.forward.to_i,
+                oauth_authorization_expires_in: Time.forward.to_i
+              },
+              response: nil
+            },
+            raw_info: {
+              firstName: auth.first_name,
+              headline: description,
+              id: uid,
+              industry: industry,
+              lastName: auth.last_name,
+              location: {
+                country: { code: Address.country_code.downcase },
+                name: city_state.split(', ').first
+              },
+              pictureUrl: image,
+              publicProfileUrl: url
+            }
+          }
+        }
+      end
+
+      ##
+      # Generate a mock Omniauth response from Github.
+      #
+      # @param name [String] A specific name to return in the response.
+      # @param email [String] A specific email to return in the response.
+      # @param uid [String] A specific UID to return in the response.
+      #
+      # @return [Hash] An auth hash in the format provided by omniauth-github.
+      #
+      # @faker.version 1.8.0
+      def github(name: nil, email: nil, uid: Number.number(digits: 8).to_s)
+        auth = Omniauth.new(name: name, email: email)
+        login = auth.name.downcase.tr(' ', '-')
+        html_url = "https://github.com/#{login}"
+        api_url = "https://api.github.com/users/#{login}"
+        {
+          provider: 'github',
+          uid: uid,
+          info: {
+            nickname: login,
+            email: auth.email,
+            name: auth.name,
+            image: image,
+            urls: {
+              GitHub: html_url
+            }
+          },
+          credentials: {
+            token: Crypto.md5,
+            expires: false
+          },
+          extra: {
+            raw_info: {
+              login: login,
+              id: uid,
+              avatar_url: image,
+              gravatar_id: '',
+              url: api_url,
+              html_url: html_url,
+              followers_url: "#{api_url}/followers",
+              following_url: "#{api_url}/following{/other_user}",
+              gists_url: "#{api_url}/gists{/gist_id}",
+              starred_url: "#{api_url}/starred{/owner}{/repo}",
+              subscriptions_url: "#{api_url}/subscriptions",
+              organizations_url: "#{api_url}/orgs",
+              repos_url: "#{api_url}/repos",
+              events_url: "#{api_url}/events{/privacy}",
+              received_events_url: "#{api_url}/received_events",
+              type: 'User',
+              site_admin: random_boolean,
+              name: auth.name,
+              company: nil,
+              blog: nil,
+              location: city_state,
+              email: auth.email,
+              hireable: nil,
+              bio: nil,
+              public_repos: random_number_from_range(1..1000),
+              public_gists: random_number_from_range(1..1000),
+              followers: random_number_from_range(1..1000),
+              following: random_number_from_range(1..1000),
+              created_at: Time.backward(days: 36_400).iso8601,
+              updated_at: Time.backward(days: 2).iso8601
+            }
+          }
+        }
+      end
+
+      ##
+      # Generate a mock Omniauth response from Apple.
+      #
+      # @param name [String] A specific name to return in the response.
+      # @param email [String] A specific email to return in the response.
+      # @param uid [String] A specific UID to return in the response.
+      #
+      # @return [Hash] An auth hash in the format provided by omniauth-apple.
+      #
+      # @faker.version 2.3.0
+      def apple(name: nil, email: nil, uid: nil)
+        uid ||= "#{Number.number(digits: 6)}.#{Number.hexadecimal(digits: 32)}.#{Number.number(digits: 4)}"
+        auth = Omniauth.new(name: name, email: email)
+        {
+          provider: 'apple',
+          uid: uid,
+          info: {
+            sub: uid,
+            email: auth.email,
+            first_name: auth.first_name,
+            last_name: auth.last_name
+          },
+          credentials: {
+            token: Crypto.md5,
+            refresh_token: Crypto.md5,
+            expires_at: Time.forward.to_i,
+            expires: true
+          },
+          extra: {
+            raw_info: {
+              iss: 'https://appleid.apple.com',
+              aud: 'CLIENT_ID',
+              exp: Time.forward.to_i,
+              iat: Time.forward.to_i,
+              sub: uid,
+              at_hash: Crypto.md5,
+              auth_time: Time.forward.to_i,
+              email: auth.email,
+              email_verified: true
+            }
+          }
+        }
+      end
+
+      ##
+      # Generate a mock Omniauth response from Auth0.
+      #
+      # @param name [String] A specific name to return in the response.
+      # @param email [String] A specific email to return in the response.
+      # @param uid [String] A specific UID to return in the response.
+      #
+      # @return [Hash] An auth hash in the format provided by omniauth-auth0.
+      #
+      # @faker.version next
+      def auth0(name: nil, email: nil, uid: nil)
+        uid ||= "auth0|#{Number.hexadecimal(digits: 24)}"
+        auth = Omniauth.new(name: name, email: email)
+        {
+          provider: 'auth0',
+          uid: uid,
+          info: {
+            name: uid,
+            nickname: auth.name,
+            email: auth.email,
+            image: image
+          },
+          credentials: {
+            expires_at: Time.forward.to_i,
+            expires: true,
+            token_type: 'Bearer',
+            id_token: Crypto.sha256,
+            token: Crypto.md5,
+            refresh_token: Crypto.md5
+          },
+          extra: {
+            raw_info: {
+              email: auth.email,
+              email_verified: true,
+              iss: 'https://auth0.com/',
+              sub: uid,
+              aud: 'Auth012345',
+              iat: Time.forward.to_i,
+              exp: Time.forward.to_i
+            }
+          }
+        }
+      end
+
+      private
+
+      def gender
+        shuffle(%w[male female]).pop
+      end
+
+      def timezone
+        shuffle((-12..12).to_a).pop
+      end
+
+      def image
+        Placeholdit.image
+      end
+
+      def city_state
+        "#{Address.city}, #{Address.state}"
+      end
+
+      def random_number_from_range(range)
+        shuffle(range.to_a).pop
+      end
+
+      def random_boolean
+        shuffle([true, false]).pop
+      end
+    end
+  end
+end

data/lib/faker/default/phone_number.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Faker
+  class PhoneNumber < Base
+    class << self
+      ##
+      # Produces a random phone number in a random format (may or may not have a country code, extension and can have different dividers).
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.phone_number #=> "397.693.1309 x4321"
+      #
+      # @faker.version 0.3.0
+      def phone_number
+        parse('phone_number.formats')
+      end
+
+      ##
+      # Produces a random cell phone number in a random format (may or may not have a country code and can have different dividers).
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.cell_phone #=> "(186)285-7925"
+      #
+      # @faker.version 1.0.0
+      def cell_phone
+        parse('cell_phone.formats')
+      end
+
+      ##
+      # Produces a random country code.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.country_code #=> "+20"
+      #
+      # @faker.version 1.9.2
+      def country_code
+        "+#{fetch('country_code')}"
+      end
+
+      ##
+      # Produces a random phone number with country code.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.phone_number_with_country_code #=> "+95 1-672-173-8153"
+      #
+      # @faker.version 1.9.2
+      def phone_number_with_country_code
+        "#{country_code} #{phone_number}"
+      end
+
+      ##
+      # Produces a random cell phone number with country code.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.cell_phone_with_country_code #=> "+974 (190) 987-9034"
+      #
+      # @faker.version 1.9.2
+      def cell_phone_with_country_code
+        "#{country_code} #{cell_phone}"
+      end
+
+      ##
+      # Produces a random phone number in e164 format.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.cell_phone_in_e164 #=> "+944937040625"
+      #
+      # @faker.version 1.9.2
+      def cell_phone_in_e164
+        cell_phone_with_country_code.delete('^+0-9')
+      end
+
+      ##
+      # Produces a random US or Canada-based area code.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.area_code #=> "201"
+      #
+      # @faker.version 1.3.0
+      def area_code
+        fetch('phone_number.area_code')
+      rescue I18n::MissingTranslationData
+        nil
+      end
+
+      ##
+      # Produces a random US or Canada-based exchange code.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.exchange_code #=> "208"
+      #
+      # @faker.version 1.3.0
+      def exchange_code
+        fetch('phone_number.exchange_code')
+      rescue I18n::MissingTranslationData
+        nil
+      end
+
+      ##
+      # Produces a random US or Canada-based extension / subscriber number. Can be used for both extensions and last four digits of phone number.
+      #
+      # @param length [Integer] Specifies the length of the return value.
+      # @return [String]
+      #
+      # @example
+      #   Faker::PhoneNumber.subscriber_number #=> "3873"
+      #   Faker::PhoneNumber.subscriber_number(length: 2) #=> "39"
+      #   Faker::PhoneNumber.extension #=> "3764"
+      #
+      # @faker.version 1.3.0
+      def subscriber_number(length: 4)
+        rand.to_s[2..(1 + length)]
+      end
+
+      alias extension subscriber_number
+    end
+  end
+end

data/lib/faker/default/placeholdit.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Faker
+  class Placeholdit < Base
+    class << self
+      SUPPORTED_FORMATS = %w[png jpg gif jpeg].freeze
+
+      ##
+      # Produces a random placeholder image from https://via.placeholder.com.
+      #
+      # @param size [String] Specifies the image's size, dimensions separated by 'x'.
+      # @param format [String] Specifies the image's extension.
+      # @param background_color [String, Symbol] Specifies the background color, either in hexadecimal format (without #) or as :random.
+      # @param text_color [String, Symbol] Specifies the text color, either in hexadecimal format (without #) or as :random.
+      # @param text [String] Specifies a custom text to be used.
+      # @return [String]
+      #
+      # @example
+      #     # Keyword arguments: size, format, background_color, text_color, text
+      #   Faker::Placeholdit.image #=> "https://via.placeholder.com/300x300.png"
+      #   Faker::Placeholdit.image(size: '50x50') #=> "https://via.placeholder.com/50x50.png"
+      #   Faker::Placeholdit.image(size: '50x50', format: 'jpg') #=> "https://via.placeholder.com/50x50.jpg"
+      #   Faker::Placeholdit.image(size: '50x50', format: 'gif', background_color: 'ffffff') #=> "https://via.placeholder.com/50x50.gif/ffffff"
+      #   Faker::Placeholdit.image(size: '50x50', format: 'jpeg', background_color: :random) #=> "https://via.placeholder.com/50x50.jpeg/39eba7"
+      #   Faker::Placeholdit.image(size: '50x50', format: 'jpeg', background_color: 'ffffff', text_color: '000') #=> "https://via.placeholder.com/50x50.jpeg/ffffff/000"
+      #   Faker::Placeholdit.image(size: '50x50', format: 'jpg', background_color: 'ffffff', text_color: '000', text: 'Some Custom Text') #=> "https://via.placeholder.com/50x50.jpg/ffffff/000?text=Some Custom Text"
+      #
+      # @faker.version 1.6.0
+      def image(size: '300x300', format: 'png', background_color: nil, text_color: nil, text: nil)
+        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, "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)/
+
+        image_url = "https://via.placeholder.com/#{size}.#{format}"
+        image_url += "/#{background_color}" if background_color
+        image_url += "/#{text_color}" if text_color
+        image_url += "?text=#{text}" if text
+        image_url
+      end
+
+      private
+
+      def generate_color
+        format('%06x', (rand * 0xffffff))
+      end
+    end
+  end
+end

data/lib/faker/default/programming_language.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Faker
+  class ProgrammingLanguage < Base
+    class << self
+      ##
+      # Produces the name of a programming language.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::ProgrammingLanguage.name #=> "Ruby"
+      #
+      # @faker.version 1.8.5
+      def name
+        fetch('programming_language.name')
+      end
+
+      ##
+      # Produces the name of a programming language's creator.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::ProgrammingLanguage.creator #=> "Yukihiro Matsumoto"
+      #
+      # @faker.version 1.8.5
+      def creator
+        fetch('programming_language.creator')
+      end
+    end
+  end
+end