faker 1.8.6 → 3.0.0

data/lib/faker/league_of_legends.rb

@@ -1,29 +0,0 @@
-module Faker
-  class LeagueOfLegends < Base
-    class << self
-      def champion
-        fetch('league_of_legends.champion')
-      end
-
-      def location
-        fetch('league_of_legends.location')
-      end
-
-      def quote
-        fetch('league_of_legends.quote')
-      end
-
-      def summoner_spell
-        fetch('league_of_legends.summoner_spell')
-      end
-
-      def masteries
-        fetch('league_of_legends.masteries')
-      end
-
-      def rank
-        fetch('league_of_legends.rank')
-      end
-    end
-  end
-end

data/lib/faker/lebowski.rb

@@ -1,17 +0,0 @@
-module Faker
-  class Lebowski < Base
-    class << self
-      def actor
-        fetch('lebowski.actors')
-      end
-      
-      def character
-        fetch('lebowski.characters')
-      end
-
-      def quote
-        fetch('lebowski.quotes')
-      end
-    end
-  end
-end

data/lib/faker/lord_of_the_rings.rb

@@ -1,13 +0,0 @@
-module Faker
-  class LordOfTheRings < Base
-    class << self
-      def character
-        fetch('lord_of_the_rings.characters')
-      end
-
-      def location
-        fetch('lord_of_the_rings.locations')
-      end
-    end
-  end
-end

data/lib/faker/lorem.rb

@@ -1,68 +0,0 @@
-module Faker
-  # Based on Perl's Text::Lorem
-  class Lorem < Base
-    CHARACTERS = ('0'..'9').to_a + ('a'..'z').to_a
-
-    class << self
-      def word
-        sample(translate('faker.lorem.words'))
-      end
-
-      def words(num = 3, supplemental = false)
-        resolved_num = resolve(num)
-        word_list = (
-          translate('faker.lorem.words') +
-          (supplemental ? translate('faker.lorem.supplemental') : [])
-        )
-        word_list = word_list * ((resolved_num / word_list.length) + 1)
-        shuffle(word_list)[0, resolved_num]
-      end
-
-      def character
-        sample(CHARACTERS)
-      end
-
-      def characters(char_count = 255)
-        char_count = resolve(char_count)
-        return '' if char_count.to_i < 1
-        Array.new(char_count) { sample(CHARACTERS) }.join
-      end
-
-      def sentence(word_count = 4, supplemental = false, random_words_to_add = 6)
-        words(word_count + rand(random_words_to_add.to_i), supplemental).join(' ').capitalize + '.'
-      end
-
-      def sentences(sentence_count = 3, supplemental = false)
-        1.upto(resolve(sentence_count)).collect { sentence(3, supplemental) }
-      end
-
-      def paragraph(sentence_count = 3, supplemental = false, random_sentences_to_add = 3)
-        sentences(resolve(sentence_count) + rand(random_sentences_to_add.to_i), supplemental).join(' ')
-      end
-
-      def paragraphs(paragraph_count = 3, supplemental = false)
-        1.upto(resolve(paragraph_count)).collect { paragraph(3, supplemental) }
-      end
-
-      def question(word_count = 4, supplemental = false, random_words_to_add = 6)
-        words(word_count + rand(random_words_to_add.to_i), supplemental).join(' ').capitalize + '?'
-      end
-
-      def questions(question_count = 3, supplemental = false)
-        1.upto(resolve(question_count)).collect { question(3, supplemental) }
-      end
-
-    private
-
-      # If an array or range is passed, a random value will be selected.
-      # All other values are simply returned.
-      def resolve(value)
-        case value
-        when Array then sample(value)
-        when Range then rand value
-        else value
-        end
-      end
-    end
-  end
-end

data/lib/faker/lorem_pixel.rb

@@ -1,21 +0,0 @@
-module Faker
-  class LoremPixel < Base
-    class << self
-      SUPPORTED_CATEGORIES = %w(abstract animals business cats city food nightlife fashion people nature sports technics transport)
-
-      def image(size = '300x300', is_gray = false, category = nil, number = nil, text = nil)
-        raise ArgumentError, 'Size should be specified in format 300x300' unless size.match(/^[0-9]+x[0-9]+$/)
-        raise ArgumentError, "Supported categories are #{SUPPORTED_CATEGORIES.join(', ')}" unless category.nil? || SUPPORTED_CATEGORIES.include?(category)
-        raise ArgumentError, 'Category required when number is passed' if !number.nil? && category.nil?
-        raise ArgumentError, 'Number must be between 1 and 10' unless number.nil? || (1..10).include?(number)
-        raise ArgumentError, 'Category and number must be passed when text is passed' if !text.nil? && number.nil? && category.nil?
-
-        url_parts = ['http://lorempixel.com']
-        url_parts << 'g' if is_gray
-        url_parts += size.split('x')
-        url_parts += [category, number, text].compact
-        url_parts.join('/')
-      end
-    end
-  end
-end

data/lib/faker/lovecraft.rb

@@ -1,73 +0,0 @@
-module Faker
-  class Lovecraft < Base
-    class << self
-      def location
-        fetch('lovecraft.location')
-      end
-
-      def fhtagn(number_of = 1)
-        number_of.times.collect { fetch('lovecraft.fhtagn') }.join(". ")
-      end
-
-      def deity
-        fetch('lovecraft.deity')
-      end
-
-      def tome
-        fetch('lovecraft.tome')
-      end
-
-      def sentence(word_count = 4, random_words_to_add = 6)
-        words(word_count + rand(random_words_to_add.to_i).to_i, true).join(' ').capitalize + '.'
-      end
-
-      def word
-        random_word = sample(translate('faker.lovecraft.words'))
-        random_word.match(/\s/) ? word : random_word
-      end
-
-      def words(num = 3, spaces_allowed = false)
-        resolved_num = resolve(num)
-        word_list = translate('faker.lovecraft.words')
-        word_list = word_list * ((resolved_num / word_list.length) + 1)
-
-        return shuffle(word_list)[0, resolved_num] if spaces_allowed
-        words = shuffle(word_list)[0, resolved_num]
-        words.each_with_index { |w, i| words[i] = word if w.match(/\s/) }
-      end
-
-
-      def sentences(sentence_count = 3)
-        [].tap do |sentences|
-          1.upto(resolve(sentence_count)) do
-            sentences << sentence(3)
-          end
-        end
-      end
-
-      def paragraph(sentence_count = 3, random_sentences_to_add = 3)
-        sentences(resolve(sentence_count) + rand(random_sentences_to_add.to_i).to_i).join(' ')
-      end
-
-      def paragraphs(paragraph_count = 3)
-        [].tap do |paragraphs|
-          1.upto(resolve(paragraph_count)) do
-            paragraphs << paragraph(3)
-          end
-        end
-      end
-
-      private
-
-      # If an array or range is passed, a random value will be selected.
-      # All other values are simply returned.
-      def resolve(value)
-        case value
-        when Array then sample(value)
-        when Range then rand value
-        else value
-        end
-      end
-    end
-  end
-end

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