faker 1.8.6 → 3.0.0

data/lib/faker/default/time.rb

@@ -0,0 +1,149 @@
+# 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
+      ##
+      # 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(from:, to:, format: nil)
+        from = get_time_object(from)
+        to = get_time_object(to)
+
+        time = Faker::Base.rand_in_range(from, to)
+        time_with_format(time, format)
+      end
+
+      ##
+      # 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(from:, to:, period: :all, format: nil)
+        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(days: 365, period: :all, format: nil)
+        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(days: 365, period: :all, format: nil)
+        time_with_format(date_with_random_time(Faker::Date.backward(days: days), period), format)
+      end
+
+      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

data/lib/faker/default/twitter.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Faker
+  class Twitter < Base
+    class << self
+      ##
+      # Produces a random Twitter user.
+      #
+      # @param include_status [Boolean] Include or exclude user status details
+      # @param include_email [Boolean] Include or exclude user email details
+      # @return [Hash]
+      #
+      # @example
+      #   Faker::Twitter.user #=>  {:id=>8821452687517076614, :name=>"Lincoln Paucek", :screen_name=>"cody"...
+      #   Faker::Twitter.user(include_status: false) # Just get a user object with no embed status
+      #   Faker::Twitter.user(include_email: true) # Simulate an authenticated user with the email permission
+      #
+      # @faker.version 1.7.3
+      def user(include_status: true, include_email: false)
+        user_id = id
+        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(true_ratio: 0.1),
+          created_at: created_at,
+          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(to: 1, from: 100_000),
+          follow_request_sent: false,
+          followers_count: Faker::Number.between(to: 1, from: 10_000_000),
+          following: false,
+          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(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(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(true_ratio: 0.4),
+          protected: Faker::Boolean.boolean(true_ratio: 0.1),
+          screen_name: screen_name,
+          statuses_count: Faker::Number.between(to: 1, from: 100_000),
+          time_zone: Faker::Address.time_zone,
+          url: Faker::Internet.url(host: 'example.com'),
+          utc_offset: utc_offset,
+          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
+
+      ##
+      # Produces a random Twitter user.
+      #
+      # @param include_user [Boolean] Include or exclude user details
+      # @param include_photo [Boolean] Include or exclude user photo
+      # @return [Hash]
+      #
+      # @example
+      #   Faker::Twitter.status #=> {:id=>8821452687517076614, :text=>"Ea et laboriosam vel non."...
+      #   Faker::Twitter.status(include_user: false) # Just get a status object with no embed user
+      #   Faker::Twitter.status(include_photo: true) # Includes entities for an attached image
+      #
+      # @faker.version 1.7.3
+      def status(include_user: true, include_photo: false)
+        status_id = id
+        status = {
+          id: status_id,
+          id_str: status_id.to_s,
+          contributors: nil,
+          coordinates: nil,
+          created_at: created_at,
+          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,
+          in_reply_to_status_id: nil,
+          in_reply_to_user_id_str: nil,
+          in_reply_to_user_id: nil,
+          is_quote_status: false,
+          lang: Faker::Address.country_code,
+          nil: nil,
+          place: 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(host: 'example.com')}\" rel=\"nofollow\">#{Faker::Company.name}</a>",
+          text: Faker::Lorem.sentence,
+          truncated: false
+        }
+        status[:user] = Faker::Twitter.user(include_status: false) if include_user
+        status[:text] = "#{status[:text]} #{status[:entities][:media].first[:url]}" if include_photo
+        status
+      end
+
+      ##
+      # Produces a random screen name.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Twitter.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).strftime('%a %b %d %H:%M:%S %z %Y')
+      end
+
+      def utc_offset
+        Faker::Number.between(to: -43_200, from: 50_400)
+      end
+
+      def user_entities
+        {
+          url: {
+            urls: []
+          },
+          description: {
+            urls: []
+          }
+        }
+      end
+
+      def status_entities(include_photo: false)
+        entities = {
+          hashtags: [],
+          symbols: [],
+          user_mentions: [],
+          urls: []
+        }
+        entities[:media] = [photo_entity] if include_photo
+        entities
+      end
+
+      def photo_entity
+        # TODO: Dynamic image sizes
+        # TODO: Return accurate indices
+        media_url = Faker::LoremPixel.image(size: '1064x600')
+        media_id = id
+        {
+          id: media_id,
+          id_str: media_id.to_s,
+          indices: [
+            103,
+            126
+          ],
+          media_url: media_url.sub('https://', 'http://'),
+          media_url_https: media_url,
+          url: Faker::Internet.url(host: 'example.com'),
+          display_url: 'example.com',
+          expanded_url: Faker::Internet.url(host: 'example.com'),
+          type: 'photo',
+          sizes: {
+            medium: {
+              w: 1064,
+              h: 600,
+              resize: 'fit'
+            },
+            large: {
+              w: 1064,
+              h: 600,
+              resize: 'fit'
+            },
+            small: {
+              w: 680,
+              h: 383,
+              resize: 'fit'
+            },
+            thumb: {
+              w: 150,
+              h: 150,
+              resize: 'crop'
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/faker/default/types.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Faker
+  class Types < Base
+    CHARACTERS = ('0'..'9').to_a + ('a'..'z').to_a
+    SIMPLE_TYPES = %i[string fixnum].freeze
+    COMPLEX_TYPES = %i[hash array].freeze
+
+    class << self
+      ##
+      # Produces a random String created from word (Faker::Lorem.word)
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Types.rb_string #=> "foobar"
+      #
+      # @faker.version 1.8.6
+      def rb_string(words: 1)
+        resolved_num = resolve(words)
+        word_list =
+          translate('faker.lorem.words')
+
+        word_list *= ((resolved_num / word_list.length) + 1)
+        shuffle(word_list)[0, resolved_num].join(' ')
+      end
+
+      ##
+      # Produces a random character from the a-z, 0-9 ranges.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::Types.character #=> "n"
+      #
+      # @faker.version 1.8.6
+      def character
+        sample(CHARACTERS)
+      end
+
+      ##
+      # Produces a random integer.
+      #
+      # @return [Integer]
+      #
+      # @example
+      #   Faker::Types.rb_integer #=> 1
+      #
+      # @faker.version 1.8.6
+      def rb_integer(from: 0, to: 100)
+        rand(from..to).to_i
+      end
+
+      ##
+      # Produces a random hash with random keys and values.
+      #
+      # @param number [Integer] Specifies the number of key-value pairs.
+      # @return [Hash]
+      #
+      # @example
+      #   Faker::Types.rb_hash #=> {name: "bob"}
+      #   Faker::Types.rb_hash(number: 1) #=> {name: "bob"}
+      #   Faker::Types.rb_hash(number: 2) #=> {name: "bob", last: "marley"}
+      #
+      # @faker.version 1.8.6
+      def rb_hash(number: 1, type: -> { random_type })
+        {}.tap do |hsh|
+          Lorem.words(number: number * 2).uniq.first(number).each do |s|
+            value = type.is_a?(Proc) ? type.call : type
+            hsh.merge!(s.to_sym => value)
+          end
+        end
+      end
+
+      ##
+      # Produces a random complex hash with random keys and values where the values may include other hashes and arrays.
+      #
+      # @param number [Integer] Specifies the number of key-value pairs.
+      # @return [Hash]
+      #
+      # @example
+      #   Faker::Types.complex_rb_hash #=> {user: {first: "bob", last: "marley"}}
+      #   Faker::Types.complex_rb_hash(number: 1) #=> {user: {first: "bob", last: "marley"}}
+      #   Faker::Types.complex_rb_hash(number: 2) #=> {user: {first: "bob", last: "marley"}, son: ["damien", "marley"]}
+      #
+      # @faker.version 1.8.6
+      def complex_rb_hash(number: 1)
+        rb_hash(number: number, type: -> { random_complex_type })
+      end
+
+      ##
+      # Produces a random array.
+      #
+      # @param len [Integer] Specifies the number of elements in the array.
+      # @return [Array]
+      #
+      # @example
+      #   Faker::Types.rb_array #=> ["a"]
+      #   Faker::Types.rb_array(len: 4) #=> ["a", 1, 2, "bob"]
+      #
+      # @faker.version 1.8.6
+      def rb_array(len: 1)
+        [].tap do |ar|
+          len.times do
+            ar.push random_type
+          end
+        end
+      end
+
+      ##
+      # Produces a random type that's either a String or an Integer.
+      #
+      # @return [String, Integer]
+      #
+      # @example
+      #   Faker::Types.random_type #=> 1 or "a" or "bob"
+      #
+      # @faker.version 1.8.6
+      def random_type
+        type_to_use = SIMPLE_TYPES[rand(0..SIMPLE_TYPES.length - 1)]
+        case type_to_use
+        when :string
+          rb_string
+        when :fixnum
+          rb_integer
+        end
+      end
+
+      ##
+      # Produces a random complex type that's either a String, an Integer, an array or a hash.
+      #
+      # @return [String, Integer]
+      #
+      # @example
+      #   Faker::Types.random_complex_type #=> 1 or "a" or "bob" or {foo: "bar"}
+      #
+      # @faker.version 1.8.6
+      def random_complex_type
+        types = SIMPLE_TYPES + COMPLEX_TYPES
+        type_to_use = types[rand(0..types.length - 1)]
+        case type_to_use
+        when :string
+          rb_string
+        when :fixnum
+          rb_integer
+        when :hash
+          rb_hash
+        when :array
+          rb_array
+        end
+      end
+
+      private
+
+      def titleize(word)
+        word.split(/(\W)/).map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/faker/default/university.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Faker
+  class University < Base
+    flexible :university
+
+    class << self
+      ##
+      # Produces a random university name.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::University.name #=> "Eastern Mississippi Academy"
+      #
+      # @faker.version 1.5.0
+      def name
+        parse('university.name')
+      end
+
+      ##
+      # Produces a random university prefix.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::University.prefix #=> "Western"
+      #
+      # @faker.version 1.5.0
+      def prefix
+        fetch('university.prefix')
+      end
+
+      ##
+      # Produces a random university suffix.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::University.suffix #=> "Academy"
+      #
+      # @faker.version 1.5.0
+      def suffix
+        fetch('university.suffix')
+      end
+
+      ##
+      # Produces a random greek organization.
+      #
+      # @return [String]
+      #
+      # @example
+      #   Faker::University.greek_organization #=> "BEX"
+      #
+      # @faker.version 1.5.0
+      def greek_organization
+        Array.new(3) { |_| sample(greek_alphabet) }.join
+      end
+
+      ##
+      # Produces a greek alphabet.
+      #
+      # @return [Array]
+      #
+      # @example
+      #   Faker::University.greek_alphabet #=> ["Α", "B", "Γ", "Δ", ...]
+      #
+      # @faker.version 1.5.0
+      def greek_alphabet
+        %w[Α B Γ Δ E Z H Θ I K Λ M N Ξ
+           O Π P Σ T Y Φ X Ψ Ω]
+      end
+    end
+  end
+end