faker 1.8.7 → 2.17.0

data/lib/faker/markdown.rb

@@ -1,67 +0,0 @@
-module Faker
-  class Markdown < Base
-    class << self
-
-      def headers
-        "#{fetch('markdown.headers')} #{Lorem.word.capitalize}"
-      end
-
-      def emphasis
-        paragraph = Faker::Lorem.paragraph(3)
-        words = paragraph.split(' ')
-        position = rand(0..words.length - 1)
-        formatting = fetch('markdown.emphasis')
-        words[position] = "#{formatting}#{words[position]}#{formatting}"
-        words.join(' ')
-      end
-
-      def ordered_list
-        number = rand(1..10)
-
-        result = []
-        number.times do |i|
-          result << "#{i.to_s}. #{Faker::Lorem.sentence(1)} \n"
-        end
-        result.join('')
-      end
-
-      def unordered_list
-        number = rand(1..10)
-
-        result = []
-        number.times do |i|
-          result << "* #{Faker::Lorem.sentence(1)} \n"
-        end
-        result.join('')
-      end
-
-      def inline_code
-        "`#{Faker::Lorem.sentence(1)}`"
-      end
-
-      def block_code
-        "```ruby\n#{Lorem.sentence(1)}\n```"
-      end
-
-      def table
-        table = []
-        3.times do
-          table << "#{Lorem.word} | #{Lorem.word} | #{Lorem.word}"
-        end
-        table.insert(1, '---- | ---- | ----')
-        table.join("\n")
-      end
-
-      def random
-        send(available_methods[rand(0..available_methods.length - 1)])
-      end
-
-      private
-
-      def available_methods
-        Markdown.public_methods(false) - Base.methods
-      end
-
-    end
-  end
-end

data/lib/faker/matz.rb

@@ -1,9 +0,0 @@
-module Faker
-  class Matz < Base
-    class << self
-      def quote
-        fetch('matz.quotes')
-      end
-    end
-  end
-end

data/lib/faker/measurement.rb

@@ -1,127 +0,0 @@
-module Faker
-  class Measurement < Base
-    class << self
-      ALL = "all"
-      NONE = "none"
-
-      def height(amount = rand(10))
-        ensure_valid_amount(amount)
-        if amount == ALL
-          make_plural(fetch('measurement.height'))
-        elsif amount == NONE
-          fetch('measurement.height')
-        else
-          "#{amount.to_s} #{check_for_plural(fetch('measurement.height'), amount)}"
-        end
-      end
-
-      def length(amount = rand(10))
-        ensure_valid_amount(amount)
-        if amount == ALL
-          make_plural(fetch('measurement.length'))
-        elsif amount == NONE
-          fetch('measurement.length')
-        else
-          "#{amount.to_s} #{check_for_plural(fetch('measurement.length'), amount)}"
-        end
-      end
-
-      def volume(amount = rand(10))
-        ensure_valid_amount(amount)
-        if amount == ALL
-          make_plural(fetch('measurement.volume'))
-        elsif amount == NONE
-          fetch('measurement.volume')
-        else
-          "#{amount.to_s} #{check_for_plural(fetch('measurement.volume'), amount)}"
-        end
-      end
-
-      def weight(amount = rand(10))
-        ensure_valid_amount(amount)
-        if amount == ALL
-          make_plural(fetch('measurement.weight'))
-        elsif amount == NONE
-          fetch('measurement.weight')
-        else
-          "#{amount.to_s} #{check_for_plural(fetch('measurement.weight'), amount)}"
-        end
-      end
-
-      def metric_height(amount = rand(10))
-        ensure_valid_amount(amount)
-        if amount == ALL
-          make_plural(fetch('measurement.height'))
-        elsif amount == NONE
-          fetch('measurement.height')
-        else
-          "#{amount.to_s} #{check_for_plural(fetch('measurement.height'), amount)}"
-        end
-      end
-
-      def metric_length(amount = rand(10))
-        ensure_valid_amount(amount)
-        if amount == ALL
-          make_plural(fetch('measurement.length'))
-        elsif amount == NONE
-          fetch('measurement.length')
-        else
-          "#{amount.to_s} #{check_for_plural(fetch('measurement.length'), amount)}"
-        end
-      end
-
-      def metric_volume(amount = rand(10))
-        ensure_valid_amount(amount)
-        if amount == ALL
-          make_plural(fetch('measurement.volume'))
-        elsif amount == NONE
-          fetch('measurement.volume')
-        else
-          "#{amount.to_s} #{check_for_plural(fetch('measurement.volume'), amount)}"
-        end
-      end
-
-      def metric_weight(amount = rand(10))
-        ensure_valid_amount(amount)
-        if amount == ALL
-          make_plural(fetch('measurement.weight'))
-        elsif amount == NONE
-          fetch('measurement.weight')
-        else
-          "#{amount.to_s} #{check_for_plural(fetch('measurement.weight'), amount)}"
-        end
-      end
-
-      private
-
-      def ensure_valid_amount(amount)
-        unless amount == NONE || amount == ALL || amount.is_a?(Integer) || amount.is_a?(Float)
-          raise ArgumentError, 'invalid amount'
-        end
-      end
-
-      def check_for_plural(text, number)
-        if number && number != 1
-          make_plural(text)
-        else
-          text
-        end
-      end
-
-      def make_plural(text)
-        case text
-        when "foot"
-          "feet"
-        when "inch"
-          "inches"
-        when "fluid ounce"
-          "fluid ounces"
-        when "metric ton"
-          "metric tons"
-        else
-          "#{text}s"
-        end
-      end
-    end
-  end
-end

data/lib/faker/most_interesting_man_in_the_world.rb

@@ -1,9 +0,0 @@
-module Faker
-  class MostInterestingManInTheWorld < Base
-    class << self
-      def quote
-        fetch('most_interesting_man_in_the_world.quotes')
-      end
-    end
-  end
-end

data/lib/faker/movie.rb

@@ -1,9 +0,0 @@
-module Faker
-  class Movie < Base
-    class << self
-      def quote
-        fetch('movie.quote')
-      end
-    end
-  end
-end

data/lib/faker/music.rb

@@ -1,33 +0,0 @@
-module Faker
-  class Music < Base
-    class << self
-      def key
-        sample(keys) + sample(key_variants)
-      end
-
-      def chord
-        key + sample(chord_types)
-      end
-
-      def instrument
-        fetch('music.instruments')
-      end
-
-      def keys
-        ['C', 'D', 'E', 'F', 'G', 'A', 'B']
-      end
-
-      def key_variants
-        ['b', '#', '']
-      end
-
-      def key_types
-        ['', 'm']
-      end
-
-      def chord_types
-        ['', 'maj', '6', 'maj7', 'm', 'm7', '-7', '7', 'dom7', 'dim', 'dim7', 'm7b5']
-      end
-    end
-  end
-end

data/lib/faker/name.rb

@@ -1,46 +0,0 @@
-module Faker
-  class Name < Base
-    flexible :name
-
-    class << self
-
-      def name
-        parse('name.name')
-      end
-
-      def name_with_middle
-        parse('name.name_with_middle')
-      end
-
-      def first_name
-        fetch('name.first_name')
-      end
-
-      def last_name
-        fetch('name.last_name')
-      end
-
-      def prefix
-        fetch('name.prefix')
-      end
-
-      def suffix
-        fetch('name.suffix')
-      end
-
-      # Generate a buzzword-laden job title
-      # Wordlist from http://www.bullshitjob.com/title/
-      def title
-        "#{fetch('name.title.descriptor')} #{fetch('name.title.level')} #{fetch('name.title.job')}"
-      end
-
-      def initials(character_count=3)
-        (0...character_count).map { (65 + rand(26)).chr }.join
-      end
-
-      def job_titles
-        fetch_all('name.title.job')
-      end
-    end
-  end
-end

data/lib/faker/number.rb

@@ -1,86 +0,0 @@
-module Faker
-  class Number < Base
-    class << self
-      def number(digits=10)
-        num = ''
-        if digits > 1
-          num = non_zero_digit
-          digits -= 1
-        end
-        num + leading_zero_number(digits)
-      end
-
-      def leading_zero_number(digits=10)
-        (1..digits).collect {digit}.join
-      end
-
-      def decimal_part(digits=10)
-        num = ''
-        if digits > 1
-          num = non_zero_digit
-          digits -= 1
-        end
-        leading_zero_number(digits) + num
-      end
-
-      def decimal(l_digits=5, r_digits=2)
-        l_d = self.number(l_digits)
-        r_d = self.decimal_part(r_digits)
-        "#{l_d}.#{r_d}"
-      end
-
-      def non_zero_digit
-        (rand(9) + 1).to_s
-      end
-
-      def digit
-        rand(10).to_s
-      end
-
-      def hexadecimal(digits=6)
-        hex = ""
-        digits.times { hex += rand(15).to_s(16) }
-        hex
-      end
-
-      def normal(mean=1, standard_deviation=1)
-        theta = 2 * Math::PI * rand
-        rho = Math.sqrt(-2 * Math.log(1 - rand))
-        scale = standard_deviation * rho
-        mean + scale * Math.cos(theta)
-      end
-
-      def between(from = 1.00, to = 5000.00)
-        Faker::Base::rand_in_range(from, to)
-      end
-
-      def positive(from = 1.00, to = 5000.00)
-        random_number = between(from, to)
-        greater_than_zero(random_number)
-      end
-
-      def negative(from = -5000.00, to = -1.00)
-        random_number = between(from, to)
-        less_than_zero(random_number)
-      end
-
-      private
-
-      def greater_than_zero(number)
-        should_be(number, :>)
-      end
-
-      def less_than_zero(number)
-        should_be(number, :<)
-      end
-
-      def should_be(number, method_to_compare)
-        if number.send(method_to_compare, 0)
-          number
-        else
-          number * -1
-        end
-      end
-    end
-  end
-end

data/lib/faker/omniauth.rb

@@ -1,340 +0,0 @@
-module Faker
-  class Omniauth < Base
-    require 'time'
-    attr_reader :name,
-                :first_name,
-                :last_name
-
-    def initialize
-      @name = "#{Name.first_name} #{Name.last_name}"
-      @first_name = name.split(' ').first
-      @last_name = name.split(' ').last
-    end
-
-    class << self
-      def google
-        uid = Number.number(9)
-        auth = Omniauth.new()
-        email = "#{auth.first_name.downcase}@example.com"
-        {
-          provider: "google_oauth2",
-          uid: uid,
-          info: {
-            name: auth.name,
-            first_name: auth.first_name,
-            last_name: auth.last_name,
-            email: 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: email,
-              email_verified: random_boolean,
-              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(36400).strftime("%Y-%m-%d"),
-              local: "en",
-              hd: "#{Company.name.downcase}.com"
-            },
-          },
-          id_info: {
-            "iss" => "accounts.google.com",
-            "at_hash" => Crypto.md5,
-            "email_verified" => "true",
-            "sub" => Number.number(28).to_s,
-            "azp" => "APP_ID",
-            "email" => email,
-            "aud" => "APP_ID",
-            "iat" => Number.number(10),
-            "exp" => Time.forward.to_i.to_s,
-            "openid_id" => "https://www.google.com/accounts/o8/id?id=#{uid}"
-          }
-        }
-      end
-
-      def facebook
-        uid = Number.number(7)
-        auth = Omniauth.new()
-        username = "#{auth.first_name.downcase[0]}#{auth.last_name.downcase}"
-        email = "#{auth.first_name.downcase}@#{auth.last_name.downcase}.com"
-        {
-          provider: "facebook",
-          uid: uid,
-          info: {
-            email: 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(9),
-                name: city_state
-              },
-              gender: gender,
-              email: email,
-              timezone: timezone,
-              locale: 'en_US',
-              verified: random_boolean,
-              updated_time: Time.backward.iso8601
-            }
-          }
-        }
-      end
-
-      def twitter
-        uid = Number.number(6)
-        auth = Omniauth.new()
-        location = city_state
-        description = Lorem.sentence
-        {
-          provider: "twitter",
-          uid: uid,
-          info: {
-            nickname: auth.name.downcase.gsub(' ', ''),
-            name: auth.name,
-            location: location,
-            image: image,
-            description: description,
-            urls: {
-              Website: nil,
-              Twitter: "https://twitter.com/#{auth.name.downcase.gsub(' ', '')}"
-            }
-          },
-          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..10000),
-              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..10000),
-              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
-
-      def linkedin
-        uid = Number.number(6)
-        auth = Omniauth.new()
-        first_name = auth.first_name.downcase
-        last_name = auth.last_name.downcase
-        email = "#{first_name}@#{last_name}.com"
-        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" => 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
-
-      def github
-        uid = Number.number(8)
-        auth = Omniauth.new()
-        first_name = auth.first_name.downcase
-        last_name  = auth.last_name.downcase
-        login = "#{first_name}-#{last_name}"
-        html_url = "https://github.com/#{login}"
-        api_url = "https://api.github.com/users/#{login}"
-        email = "#{first_name}@example.com"
-
-        {
-          provider: "github",
-          uid: uid,
-          info: {
-            nickname: login,
-            email: 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: 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(36400).iso8601,
-              updated_at: Time.backward(2).iso8601
-            }
-          }
-        }
-
-      end
-
-      private
-
-        def gender
-          shuffle(["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