random-words 1.0.11 → 1.0.13

data/lib/random-words/{lorem-markdown.rb → lorem_html.rb}

@@ -2,23 +2,44 @@
 
 module RandomWords
   # Generates random Lorem Ipsum text in Markdown format.
-  class LoremMarkdown
+  class LoremHTML
     # Stores the output
     attr_accessor :output
 
     # Stores the RandomWords::Generator
     attr_accessor :generator
 
+    # Stores the title
+    attr_reader :title
+
     # Generates random Lorem Ipsum text.
     # @param options [Hash] Options for generating Lorem Ipsum text.
+    #
+    # @option options [Symbol] :source The source of the words (:latin, :english, :french, etc.).
+    # @option options [Integer] :grafs The number of paragraphs to generate.
+    # @option options [Integer] :sentences The number of sentences per paragraph.
+    # @option options [Symbol] :length The length of the text (:short, :medium, :long, :very_long).
+    # @option options [Boolean] :decorate Whether to include emphasis and strong tags.
+    # @option options [Boolean] :link Whether to include links.
+    # @option options [Boolean] :ul Whether to include unordered lists.
+    # @option options [Boolean] :ol Whether to include ordered lists.
+    # @option options [Boolean] :dl Whether to include definition lists.
+    # @option options [Boolean] :bq Whether to include blockquotes.
+    # @option options [Boolean] :code Whether to include code blocks.
+    # @option options [Boolean] :mark Whether to include mark tags.
+    # @option options [Boolean] :headers Whether to include headers.
+    # @option options [Boolean] :table Whether to include tables.
+    # @option options [Boolean] :extended Whether to use extended punctuation.
     # @return [String] A string of random Lorem Ipsum text.
     def initialize(options = {})
       @added = {
-        em: false,
+        italic: false,
         strong: false,
         link: false,
         code: false,
-        mark: false
+        mark: false,
+        footnote: false,
+        hr: false
       }
 
       defaults = {
@@ -36,7 +57,10 @@ module RandomWords
         mark: false,
         headers: false,
         table: false,
-        extended: false
+        extended: false,
+        footnote: false,
+        hr: false,
+        image: false
       }
 
       @options = defaults.merge(options)
@@ -46,28 +70,36 @@ module RandomWords
                                                 paragraph_length: @options[:sentences],
                                                 use_extended_punctuation: @options[:extended]
                                               })
+      @title = fragment(2, 5).cap_first
 
       @output = ''
       strong = @options[:decorate]
-      em = @options[:decorate]
+      italic = @options[:decorate]
       links = @options[:link]
       code = @options[:code]
       mark = @options[:mark]
+      footnotes = @options[:footnote]
+      @options[:hr]
+      @options[:image]
       force = []
       # Generate the specified number of paragraphs.
       @options[:grafs].times.with_index do |_, i|
-        @output += paragraph(1, em: em, strong: strong, links: links, code: code, mark: mark, force: force)
-        em = Random.rand(0..3).zero? && @options[:decorate]
-        strong = Random.rand(0..3).zero? && @options[:decorate]
-        links = Random.rand(0..3).zero? && @options[:link]
-        code = Random.rand(0..3).zero? && @options[:code]
-
-        if i == @options[:grafs] - 2
+        if @options[:grafs] == 1 || i == @options[:grafs] - 2
+          force << :footnote if !@added[:footnote] && @options[:footnote]
           force << :code if !@added[:code] && @options[:code]
           force << :link if !@added[:link] && @options[:link]
-          force << :em if !@added[:em] && @options[:decorate]
+          force << :italic if !@added[:italic] && @options[:decorate]
           force << :strong if !@added[:strong] && @options[:decorate]
         end
+
+        @output += paragraph(1, italic: italic, strong: strong, links: links, code: code, mark: mark, footnotes: footnotes,
+                                force: force)
+        italic = Random.rand(0..3).zero? && @options[:decorate]
+        strong = Random.rand(0..3).zero? && @options[:decorate]
+        links = Random.rand(0..3).zero? && @options[:link]
+        code = Random.rand(0..3).zero? && @options[:code]
+        footnotes = Random.rand(0..3).zero? && @options[:footnote]
+
         @output += "\n\n"
       end
 
@@ -75,47 +107,61 @@ module RandomWords
     end
 
     # Use the RandomWords class to generate the Lorem Ipsum text.
+    #
+    # @return [String] The generated Lorem Ipsum HTML.
     def generate
       compress_newlines
+      handle_lists
+      handle_basic_elements
+      handle_content_blocks
+      finalize_output
+      @output
+    end
+
+    private
 
+    def handle_lists
       items = { short: 4, medium: 8, long: 10, very_long: 12 }[@options[:length]]
 
       if @options[:ul] && @options[:ol]
-        # If both unordered and ordered lists are specified, add them both.
         inject_block(1, -> { list(items, :ul) })
         inject_block(1, -> { list(items, :ol) })
       elsif @options[:ul]
-        # If only unordered list is specified, add it.
         inject_block(2, -> { list(items, :ul) })
       elsif @options[:ol]
-        # If only ordered list is specified, add it.
         inject_block(2, -> { list(items, :ol) })
       end
+    end
 
-      # Add definition list if specified.
-      inject_block(1, -> { list(items, :dl) }) if @options[:dl]
+    def handle_basic_elements
+      inject_block(1, -> { "<hr>\n\n" }) if @options[:hr]
 
-      # Add blockquote if specified.
-      inject_block(1, -> { blockquote(items / 2) }) if @options[:bq]
+      return unless @options[:image]
 
-      # Add headers if specified.
-      inject_headers if @options[:headers]
+      inject_block(1, lambda {
+        "<img src=\"https://picsum.photos/400/200\" alt=\"#{fragment(1, 4).cap_first}\" />\n\n"
+      })
+    end
 
-      # Add code block if specified.
-      inject_block(1, -> { code }) if @options[:code]
+    def handle_content_blocks
+      items = { short: 4, medium: 8, long: 10, very_long: 12 }[@options[:length]]
 
-      # Add table if specified.
+      inject_block(1, -> { list(items, :dl) }) if @options[:dl]
+      inject_block(1, -> { blockquote(items / 2) }) if @options[:bq]
+      inject_headers if @options[:headers]
+      inject_block(1, -> { code }) if @options[:code]
       inject_block(1, -> { table }) if @options[:table]
+    end
 
+    def finalize_output
       ensure_block_newlines
       compress_newlines
       convert_punctuation
     end
 
-    private
-
     # Convert non-ascii punctuation to Markdown equivalents.
     # @param [String] text The text to convert.
+    #
     # @return [String] The converted text.
     def convert_punctuation
       text = @output
@@ -129,31 +175,40 @@ module RandomWords
       @output = text
     end
 
-    # Rolls for zero with the specified odds.
-    def roll(odds)
-      Random.rand(0..odds).zero?
+    # Roll a random number to determine if an action should occur
+    # @param percent [Integer] 1-100 percent chance of the action occurring (1-100)
+    #
+    # @return [Boolean] True if the action occurs, false otherwise
+    #
+    # @example
+    #   roll(50) # 50% chance of returning true
+    def roll(percent)
+      rand(1..100) <= percent
     end
 
     # Generates a list of items.
     # @param [Integer] count The number of items to generate.
     # @param [Symbol] type The type of list to generate (:ul, :ol, :dl).
+    #
     # @return [String] The generated list.
     def list(count, type)
       ul = "\n\n<#{type}>\n"
 
       count.times do
-        links = roll(4) && @options[:link]
-        em = roll(2) && @options[:decorate]
-        strong = roll(2) && @options[:decorate]
-        code = roll(4) && @options[:code]
-        mark = roll(6) && @options[:mark]
+        links = roll(20) && @options[:link]
+        italic = roll(50) && @options[:decorate]
+        strong = roll(50) && @options[:decorate]
+        code = roll(10) && @options[:code]
+        mark = roll(10) && @options[:mark]
+
         frag = fragment(1, 4).cap_first
         long_frag = fragment(4, 8).cap_first
         long_frag = inject_inline(long_frag, -> { link }) if links
-        long_frag = inject_inline(long_frag, -> { emphasis(:em) }) if em
+        long_frag = inject_inline(long_frag, -> { emphasis(:em) }) if italic
         long_frag = inject_inline(long_frag, -> { emphasis(:strong) }) if strong
         long_frag = inject_inline(long_frag, -> { code_span }, 1) if code
         long_frag = inject_inline(long_frag, -> { emphasis(:mark) }, 1) if mark
+
         long_frag = long_frag.restore_spaces if links
         if type == :dl
           ul += "\t<dt>#{frag}</dt>\n"
@@ -168,8 +223,9 @@ module RandomWords
     # Generates a blockquote.
     # @param [Integer] count The number of items to generate.
     # @param [Boolean] nested Whether the blockquote is nested.
+    #
     # @return [String] The generated blockquote.
-    def blockquote(count, nested = false)
+    def blockquote(count, nested: false)
       if count > 1 && !nested
         level1 = Random.rand(1..count - 1).to_i
         level2 = count - level1
@@ -181,14 +237,12 @@ module RandomWords
       newline = nested ? '' : "\n\n"
       quote = "#{newline}<blockquote>\n"
       quote += paragraph(level1,
-                         em: @options[:decorate],
+                         italic: @options[:decorate],
                          strong: @options[:decorate],
                          links: @options[:link],
                          code: @options[:code],
-                         mark: @options[:mark]).gsub(
-                           /\n+/, "\n"
-                         )
-      quote += blockquote(level2, true).strip if level2.positive?
+                         mark: @options[:mark]).squeeze("\n")
+      quote += blockquote(level2, nested: true).strip if level2.positive?
       "#{quote}#{cite}</blockquote>#{newline}"
     end
 
@@ -295,7 +349,17 @@ module RandomWords
       path = "/#{path_string(4, 8)}/#{path_string(4, 8)}"
       title = fragment(4, 8).cap_first
       "<a%%href=\"https://example.com#{path}\"%%title=\"#{title.preserve_spaces}\">#{fragment(1,
-                                                                                              8).cap_first}</a>"
+                                                                                              8)}</a>"
+    end
+
+    # Generates a random footnote
+    # @return [String] The generated footnote.
+    def footnote
+      @added[:footnote] = true
+      @counter ||= 0
+      @counter += 1
+      %(<a%%href="#fn:#{@counter}"%%id="fnref:#{@counter}"%%title="#{fragment(10,
+                                                                              20)}"%%class="footnote"><sup>#{@counter}</sup></a>)
     end
 
     # Injects a block of text into the output.
@@ -335,7 +399,7 @@ module RandomWords
     def inject_inline(text, block, max = nil)
       max ||= { short: 1, medium: 2, long: 3, very_long: 4 }[@options[:length]]
 
-      words = text.split(' ')
+      words = text.split
       out = []
       count = 0
       while words.any?
@@ -355,30 +419,33 @@ module RandomWords
     # Generates a paragraph of Lorem Ipsum text.
     # The `words` method generates a specified number of words.
     # @param [Integer] count The number of paragraphs to generate.
-    # @param [Boolean] em Whether to include emphasis tags.
+    # @param [Boolean] italic Whether to include italic tags.
     # @param [Boolean] strong Whether to include strong tags.
     # @param [Boolean] links Whether to include links.
     # @param [Boolean] code Whether to include code tags.
     # @param [Boolean] mark Whether to include mark tags.
     # @param [Array] force An array of tags to force.
     # @return [String] The generated paragraph.
-    def paragraph(count, em: false, strong: false, links: false, code: false, mark: false, force: [])
+    def paragraph(count, italic: false, strong: false, links: false, code: false, mark: false, footnotes: false, force: [])
       output = ''
+
       s = { short: 2, medium: 4, long: 6, very_long: 8 }[@options[:length]]
       count.times do
         p = @generator.sentences(s).join(' ')
-        should_em = force.include?(:em) || (em && roll(1))
-        should_strong = force.include?(:strong) || (strong && roll(1))
-        should_code = force.include?(:code) || (code && roll(6))
-        should_link = force.include?(:links) || (links && roll(4))
-        should_mark = force.include?(:mark) || (mark && roll(8))
+        should_em = force.include?(:italic) || (italic && roll(60))
+        should_strong = force.include?(:strong) || (strong && roll(60))
+        should_code = force.include?(:code) || (code && roll(40))
+        should_link = force.include?(:link) || (links && roll(40))
+        should_mark = force.include?(:mark) || (mark && roll(40))
+        should_footnote = force.include?(:footnote) || (footnotes && roll(40))
+
         p = inject_inline(p, -> { link }) if should_link
-        p = inject_inline(p, -> { emphasis('em') }) if should_em
-        p = inject_inline(p, -> { emphasis('strong') }) if should_strong
-        p = inject_inline(p, -> { emphasis('mark') }, 1) if should_mark
+        p = inject_inline(p, -> { emphasis(:em) }) if should_em
+        p = inject_inline(p, -> { emphasis(:strong) }) if should_strong
+        p = inject_inline(p, -> { emphasis(:mark) }, 1) if should_mark
         p = inject_inline(p, -> { code_span }, 1) if should_code
-
-        output += "<p>#{p.restore_spaces.cap_first.term('.')}</p>\n\n"
+        fn = should_footnote ? footnote.restore_spaces : ''
+        output += "<p>#{p.restore_spaces.cap_first.term('.')}#{fn}</p>\n\n"
       end
       output
     end

data/lib/random-words/{number-to-word.rb → number_to_word.rb}

@@ -33,10 +33,10 @@ module RandomWords
     #  126620.to_word # => "one hundred twenty six thousand six hundred twenty"
     def to_word(numbers)
       tmp = self / 1000
-      final = (self % 1000).hundred_to_word(2, numbers)
+      final = (self % 1000).hundred_to_word(numbers, 2)
       place = 3 # special-case the tens and below
       until tmp.zero?
-        final = (tmp % 1000).hundred_to_word(place, numbers) + ' ' + final
+        final = "#{(tmp % 1000).hundred_to_word(numbers, place)} #{final}"
         place += 1
         tmp /= 1000
       end
@@ -54,7 +54,7 @@ module RandomWords
     protected
 
     # Convert a number to its word representation for the hundreds place.
-    def hundred_to_word(place = 0, numbers)
+    def hundred_to_word(numbers, place = 0)
       if zero?
         ''
       elsif self < 10
@@ -83,7 +83,7 @@ module RandomWords
     def append_place(word, place, numbers)
       places = numbers[:places]
       if place > 2
-        word + ' ' + places[place]
+        "#{word} #{places[place]}"
       else
         word
       end
@@ -100,7 +100,7 @@ module RandomWords
         tens = self / 10
         ones = self % 10
         ten = numbers[:tens][tens - 2]
-        ten + (ones.zero? ? '' : ' ' + ones.digit_to_word(numbers))
+        "#{ten} #{ones.zero? ? '' : ones.digit_to_word(numbers)}"
       else
         teen_to_word(numbers)
       end

data/lib/random-words/numeric.rb

@@ -6,8 +6,8 @@ module RandomWords
     def to_commas
       num = to_s.reverse.scan(/(?:\d*\.)?\d{1,3}-?/).join(',').reverse
       dec = num.split('.')
-      num = dec[0].to_s + '.' + dec[1].to_s.ljust(2, '0')[0,2] if dec[1]
+      num = "#{dec[0]}.#{dec[1].to_s.ljust(2, '0')[0, 2]}" if dec[1]
       num
     end
   end
-end
+end

data/lib/random-words/string.rb

@@ -280,7 +280,7 @@ module RandomWords
     # @return [String] The colorized text.
     # @example
     #  colorize_text("Hello, World!", :red) # => "\e[31mHello, World!\e[0m"
-    def colorize_text(text, color, testing = false)
+    def colorize_text(text, color, testing: false)
       return text if !$stdout.isatty && !testing
 
       return text unless colors.key?(color)
@@ -321,13 +321,20 @@ module RandomWords
 
     # Expand abbreviated debug statements in the string.
     # @return [String] The expanded debug string.
-    def expand_debug(testing = false)
+    def expand_debug(testing: false)
       gsub(/%(#{Regexp.union(expansions.keys)})%?/) do
         match = Regexp.last_match
 
         return match unless expansions.key?(match[1])
 
-        colorize_text("[#{expansions[match[1]][0] || match}]", expansions[match[1]][1] || :white, testing)
+        colorize_text("[#{expansions[match[1]][0] || match}]", expansions[match[1]][1] || :white, testing: testing)
+      end
+    end
+
+    def article_agree
+      gsub(/\ban? (\w)/i) do |match|
+        word = match[1]
+        /\A[aeiou]/i.match?(word) ? "an #{word}" : "a #{word}"
       end
     end
   end

data/lib/random-words/terminal.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RandomWords
+  # Terminal methods for testing
+  class Terminal
+    def initialize(source = :english)
+      # Create an instance of the generator
+      @sentence_generator = RandomWords::Generator.new(source)
+      @sentence_generator.use_extended_punctuation = true
+      @colors = {
+        text: :yellow,
+        counter: :boldcyan,
+        marker: :boldgreen,
+        bracket: :cyan,
+        language: :boldmagenta
+      }
+      @sources = @sentence_generator.sources.keys.map(&:to_s)
+    end
+
+    def colors
+      {
+        black: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        magenta: 35,
+        cyan: 36,
+        white: 37,
+        boldblack: '1;30',
+        boldred: '1;31',
+        boldgreen: '1;32',
+        boldyellow: '1;33',
+        boldblue: '1;34',
+        boldmagenta: '1;35',
+        boldcyan: '1;36',
+        boldwhite: '1;37',
+        reset: 0
+      }
+    end
+
+    def colorize_text(text, color)
+      return text unless $stdout.isatty
+
+      return text unless colors.key?(color)
+
+      color_code = colors[color]
+
+      "\e[#{color_code}m#{text}\e[0m"
+    end
+
+    def header1(text)
+      puts colorize_text("\n\n#{text}", :boldgreen)
+      puts colorize_text('=' * text.length, :boldgreen)
+      puts "\n"
+    end
+
+    def header2(text)
+      puts colorize_text("\n\n#{text}", :boldyellow)
+      puts colorize_text('-' * text.length, :boldyellow)
+      puts "\n"
+    end
+
+    def paragraphs(length, count = 3)
+      @sentence_generator.sentence_length = length
+      @sentence_generator.paragraph_length = count
+      @sentence_generator.source = @sources.sample
+
+      header2("Random Paragraph (#{@sentence_generator.paragraph_length} #{@sentence_generator.sentence_length} sentences)")
+      graf = @sentence_generator.paragraph
+      puts text(graf)
+      puts counter("#{graf.split(/ /).count} words, #{graf.length} characters")
+    end
+
+    def sentence(length)
+      header2("Random #{length} sentence")
+      @sentence_generator.sentence_length = length
+      s = @sentence_generator.sentence
+      puts text(s)
+      puts counter("#{s.split(/ /).count} words, #{s.length} characters")
+    end
+
+    # Generate and print random combined sentences
+    def combined_sentences(length = nil)
+      number_of_sentences = length || 2
+
+      header1('Random Combined Sentences:')
+      @sources.count.times do |i|
+        @sentence_generator.source = @sources[i - 1]
+        @sentence_generator.sentence_length = :medium
+        @sentence_generator.paragraph_length = number_of_sentences
+        @sentence_generator.sentences(number_of_sentences)
+        s = @sentence_generator.sentence
+        puts "#{marker} #{text(s)}"
+        puts counter("#{s.split(/ /).count} words, #{s.length} characters")
+        puts colorize_text(' ' * 2, :boldwhite)
+      end
+    end
+
+    def random_sentences
+      header1('Random Sentences')
+      @sentence_generator.lengths.keys.each_with_index do |length, index|
+        @sentence_generator.source = @sources[index]
+        sentence(length)
+      end
+    end
+
+    def random_paragraphs
+      header1('Random Paragraphs')
+      @sentence_generator.lengths.keys.each_with_index do |length, index|
+        @sentence_generator.source = @sources[index]
+        paragraphs(length, 3)
+      end
+    end
+
+    # Generate and print specified number of words
+    def random_words
+      number_of_words = []
+      @sources.count.times do |i|
+        number_of_words << (((i * i) * 5) + 10)
+      end
+
+      header1("#{number_of_words} Random Words")
+      @sources.each_with_index do |source, index|
+        header2("#{number_of_words[index]} Random Words")
+        @sentence_generator.source = source
+        s = @sentence_generator.words(number_of_words[index])
+        puts "#{marker} #{text(s)}  "
+        puts counter("#{s.split(/ /).count} words, #{s.length} characters")
+      end
+    end
+
+    # Generate and print specified number of characters
+    def random_characters
+      header1('Random Characters (exact length)')
+      [20, 50, 120, 200, 500].each_with_index do |i, index|
+        @sentence_generator.source = @sources[index]
+        chars = @sentence_generator.characters(i, whole_words: true)
+        puts "#{marker} #{colorize_text("#{i}:", :boldwhite)} #{text(chars)} #{counter(chars.length)}"
+      end
+
+      # Generate and print specified number of characters
+      max_characters = [15, 25, 53, 110, 600]
+      min_characters = [10, 20, 50, 100, 500]
+
+      header1('Random Characters (length range)')
+      max_characters.count.times do |i|
+        @sentence_generator.source = @sources[i]
+        chars = @sentence_generator.characters(min_characters[i], max_characters[i], whole_words: true)
+        range = "#{marker} #{colorize_text("[#{min_characters[i]}-#{max_characters[i]}]: ", :boldwhite)}"
+        puts "#{range}#{text(chars)} #{counter(chars.length)}"
+      end
+    end
+
+    def marker
+      colorize_text('•', @colors[:marker])
+    end
+
+    def text(text)
+      colorize_text(text, @colors[:text])
+    end
+
+    def language
+      "#{colorize_text('(',
+                       @colors[:bracket])}#{colorize_text(@sentence_generator.source,
+                                                          @colors[:language])}#{colorize_text(')',
+                                                                                              @colors[:bracket])}"
+    end
+
+    def counter(length)
+      "#{colorize_text('[',
+                       @colors[:bracket])}#{colorize_text(length.to_s,
+                                                          @colors[:counter])}#{colorize_text(']',
+                                                                                             @colors[:bracket])} #{language}"
+    end
+
+    def print_test
+      combined_sentences(3)
+      random_sentences
+      random_paragraphs
+      random_words
+      random_characters
+    end
+  end
+end

data/lib/random-words/version.rb

@@ -1,4 +1,4 @@
 module RandomWords
   # The version of the RandomWords gem.
-  VERSION = '1.0.11'
+  VERSION = '1.0.13'
 end