faker 2.7.0

data/lib/faker/default/twitter.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Faker
+  class Twitter < Base
+    class << self
+      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(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
+
+      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,
+          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
+
+      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(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: []
+        }
+        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,101 @@
+# 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
+      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')
+
+        word_list *= ((resolved_num / word_list.length) + 1)
+        shuffle(word_list)[0, resolved_num].join(' ')
+      end
+
+      def character
+        sample(CHARACTERS)
+      end
+
+      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(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(number: number * 2).uniq.first(number).each do |s|
+            hsh.merge!(s.to_sym => type)
+          end
+        end
+      end
+
+      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(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
+          end
+        end
+      end
+
+      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
+
+      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,30 @@
+# frozen_string_literal: true
+
+module Faker
+  class University < Base
+    flexible :university
+
+    class << self
+      def name
+        parse('university.name')
+      end
+
+      def prefix
+        fetch('university.prefix')
+      end
+
+      def suffix
+        fetch('university.suffix')
+      end
+
+      def greek_organization
+        Array.new(3) { |_| sample(greek_alphabet) }.join
+      end
+
+      def greek_alphabet
+        %w[Α B Γ Δ E Z H Θ I K Λ M N Ξ
+           O Π P Σ T Y Φ X Ψ Ω]
+      end
+    end
+  end
+end

data/lib/faker/default/vehicle.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Faker
+  class Vehicle < Base
+    flexible :vehicle
+
+    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
+    SG_CHECKSUM_WEIGHTS = [3, 14, 2, 12, 2, 11, 1].freeze
+    SG_CHECKSUM_CHARS = 'AYUSPLJGDBZXTRMKHEC'
+
+    class << self
+      def vin
+        regexify(VIN_REGEX)
+      end
+
+      def manufacture
+        fetch('vehicle.manufacture')
+      end
+
+      def make
+        fetch('vehicle.makes')
+      end
+
+      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
+
+        return fetch("vehicle.models_by_make.#{make}") if make_of_model.empty?
+
+        fetch("vehicle.models_by_make.#{make_of_model}")
+      end
+
+      def make_and_model
+        m = make
+
+        "#{m} #{model(make_of_model: m)}"
+      end
+
+      def style
+        fetch('vehicle.styles')
+      end
+
+      def color
+        fetch('vehicle.colors')
+      end
+
+      def transmission
+        fetch('vehicle.transmissions')
+      end
+
+      def drive_type
+        fetch('vehicle.drive_types')
+      end
+
+      def fuel_type
+        fetch('vehicle.fuel_types')
+      end
+
+      def car_type
+        fetch('vehicle.car_types')
+      end
+
+      def engine
+        "#{sample(fetch_all('vehicle.doors'))} #{fetch('vehicle.cylinder_engine')}"
+      end
+
+      alias engine_size engine
+
+      def car_options
+        Array.new(rand(5...10)) { fetch('vehicle.car_options') }
+      end
+
+      def standard_specs
+        Array.new(rand(5...10)) { fetch('vehicle.standard_specs') }
+      end
+
+      def doors
+        sample(fetch_all('vehicle.doors'))
+      end
+      alias door_count doors
+
+      def year
+        Faker::Time.backward(days: rand_in_range(365, 5475), period: :all, format: '%Y').to_i
+      end
+
+      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
+
+        rand_in_range(min, max)
+      end
+
+      alias kilometrage mileage
+
+      def license_plate(legacy_state_abreviation = NOT_GIVEN, state_abreviation: '')
+        warn_for_deprecated_arguments do |keywords|
+          keywords << :state_abreviation if legacy_state_abreviation != NOT_GIVEN
+        end
+
+        return regexify(bothify(fetch('vehicle.license_plate'))) if state_abreviation.empty?
+
+        key = 'vehicle.license_plate_by_state.' + state_abreviation
+        regexify(bothify(fetch(key)))
+      end
+
+      def singapore_license_plate
+        key = 'vehicle.license_plate'
+        plate_number = regexify(bothify(fetch(key)))
+        "#{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
+      end
+
+      def vin_char_to_number(char)
+        index = VIN_LETTERS.split('').index(char)
+
+        return char.to_i if index.nil?
+
+        VIN_MAP[index]
+      end
+
+      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)
+        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]
+      end
+    end
+  end
+end