random-words 1.0.12 → 1.0.13

data/lib/random-words/html2markdown.rb

@@ -42,16 +42,16 @@ module RandomWords
         EOMETA
         case @meta_type
         when :multimarkdown
-          meta = <<~EOF
+          meta = <<~EOMMD
             #{meta}
 
-          EOF
+          EOMMD
         when :yaml
-          meta = <<~EOF
+          meta = <<~EOYAML
             ---
             #{meta}
             ---
-          EOF
+          EOYAML
         end
       end
       i = 0
@@ -140,7 +140,7 @@ module RandomWords
         @title = node.content
         ''
       when 'head'
-        children = output_for_children(node)
+        output_for_children(node)
         ''
       when 'style', 'script'
         ''

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

@@ -14,10 +14,26 @@ module RandomWords
 
     # 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,
@@ -58,31 +74,32 @@ module RandomWords
 
       @output = ''
       strong = @options[:decorate]
-      em = @options[:decorate]
+      italic = @options[:decorate]
       links = @options[:link]
       code = @options[:code]
       mark = @options[:mark]
       footnotes = @options[:footnote]
-      hr = @options[:hr]
-      image = @options[:image]
+      @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, footnotes: footnotes,
+        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 << :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)
-        em = Random.rand(0..3).zero? && @options[:decorate]
+        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]
 
-        if 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 << :strong if !@added[:strong] && @options[:decorate]
-        end
         @output += "\n\n"
       end
 
@@ -90,57 +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 horizontal rule if specified.
+    def handle_basic_elements
       inject_block(1, -> { "<hr>\n\n" }) if @options[:hr]
 
-      # Add image if specified.
-      if @options[:image]
-        inject_block(1, lambda {
-          "<img src=\"https://picsum.photos/400/200\" alt=\"#{fragment(1, 4).cap_first}\" />\n\n"
-        })
-      end
+      return unless @options[:image]
 
-      # Add definition list if specified.
-      inject_block(1, -> { list(items, :dl) }) if @options[:dl]
+      inject_block(1, lambda {
+        "<img src=\"https://picsum.photos/400/200\" alt=\"#{fragment(1, 4).cap_first}\" />\n\n"
+      })
+    end
 
-      # Add blockquote if specified.
-      inject_block(1, -> { blockquote(items / 2) }) if @options[:bq]
+    def handle_content_blocks
+      items = { short: 4, medium: 8, long: 10, very_long: 12 }[@options[:length]]
 
-      # Add headers 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]
-
-      # Add code block if specified.
       inject_block(1, -> { code }) if @options[:code]
-
-      # Add table if specified.
       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
@@ -154,29 +175,36 @@ 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
@@ -195,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
@@ -208,12 +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]).squeeze("\n")
-      quote += blockquote(level2, true).strip if level2.positive?
+      quote += blockquote(level2, nested: true).strip if level2.positive?
       "#{quote}#{cite}</blockquote>#{newline}"
     end
 
@@ -320,7 +349,7 @@ 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
@@ -370,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?
@@ -390,29 +419,30 @@ 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, footnotes: 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_footnote = force.include?(:footnote) || (footnotes && 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
         fn = should_footnote ? footnote.restore_spaces : ''
         output += "<p>#{p.restore_spaces.cap_first.term('.')}#{fn}</p>\n\n"

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RandomWords
   # Terminal methods for testing
   class Terminal
@@ -47,13 +49,13 @@ module RandomWords
       "\e[#{color_code}m#{text}\e[0m"
     end
 
-    def header_1(text)
+    def header1(text)
       puts colorize_text("\n\n#{text}", :boldgreen)
       puts colorize_text('=' * text.length, :boldgreen)
       puts "\n"
     end
 
-    def header_2(text)
+    def header2(text)
       puts colorize_text("\n\n#{text}", :boldyellow)
       puts colorize_text('-' * text.length, :boldyellow)
       puts "\n"
@@ -64,14 +66,14 @@ module RandomWords
       @sentence_generator.paragraph_length = count
       @sentence_generator.source = @sources.sample
 
-      header_2("Random Paragraph (#{@sentence_generator.paragraph_length} #{@sentence_generator.sentence_length} sentences)")
+      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)
-      header_2("Random #{length} sentence")
+      header2("Random #{length} sentence")
       @sentence_generator.sentence_length = length
       s = @sentence_generator.sentence
       puts text(s)
@@ -82,7 +84,7 @@ module RandomWords
     def combined_sentences(length = nil)
       number_of_sentences = length || 2
 
-      header_1('Random Combined Sentences:')
+      header1('Random Combined Sentences:')
       @sources.count.times do |i|
         @sentence_generator.source = @sources[i - 1]
         @sentence_generator.sentence_length = :medium
@@ -96,7 +98,7 @@ module RandomWords
     end
 
     def random_sentences
-      header_1('Random Sentences')
+      header1('Random Sentences')
       @sentence_generator.lengths.keys.each_with_index do |length, index|
         @sentence_generator.source = @sources[index]
         sentence(length)
@@ -104,7 +106,7 @@ module RandomWords
     end
 
     def random_paragraphs
-      header_1('Random Paragraphs')
+      header1('Random Paragraphs')
       @sentence_generator.lengths.keys.each_with_index do |length, index|
         @sentence_generator.source = @sources[index]
         paragraphs(length, 3)
@@ -118,9 +120,9 @@ module RandomWords
         number_of_words << (((i * i) * 5) + 10)
       end
 
-      header_1("#{number_of_words} Random Words")
+      header1("#{number_of_words} Random Words")
       @sources.each_with_index do |source, index|
-        header_2("#{number_of_words[index]} Random Words")
+        header2("#{number_of_words[index]} Random Words")
         @sentence_generator.source = source
         s = @sentence_generator.words(number_of_words[index])
         puts "#{marker} #{text(s)}  "
@@ -130,7 +132,7 @@ module RandomWords
 
     # Generate and print specified number of characters
     def random_characters
-      header_1('Random Characters (exact length)')
+      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)
@@ -141,7 +143,7 @@ module RandomWords
       max_characters = [15, 25, 53, 110, 600]
       min_characters = [10, 20, 50, 100, 500]
 
-      header_1('Random Characters (length range)')
+      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)
@@ -160,14 +162,14 @@ module RandomWords
 
     def language
       "#{colorize_text('(',
-                       @colors[:bracket])}#{colorize_text("#{@sentence_generator.source}",
+                       @colors[:bracket])}#{colorize_text(@sentence_generator.source,
                                                           @colors[:language])}#{colorize_text(')',
                                                                                               @colors[:bracket])}"
     end
 
     def counter(length)
       "#{colorize_text('[',
-                       @colors[:bracket])}#{colorize_text("#{length}",
+                       @colors[:bracket])}#{colorize_text(length.to_s,
                                                           @colors[:counter])}#{colorize_text(']',
                                                                                              @colors[:bracket])} #{language}"
     end

data/lib/random-words/version.rb

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

data/lib/random-words/words/walken/adjectives.txt

@@ -0,0 +1,139 @@
+absurd
+aggressive
+aloof
+ambitious
+anxious
+artistic
+assertive
+astute
+authentic
+awkward
+bold
+brave
+brilliant
+calm
+candid
+captivating
+chaotic
+charming
+clever
+cold
+compelling
+confident
+conventional
+corrupt
+courageous
+creative
+curious
+dangerous
+dark
+decisive
+deceptive
+delicate
+demanding
+desperate
+difficult
+diverse
+dramatic
+dynamic
+eccentric
+empathetic
+enigmatic
+enthusiastic
+epic
+erratic
+exciting
+exotic
+expressive
+fearless
+fiery
+fragile
+funny
+generous
+genuine
+graceful
+gritty
+hardcore
+harmonious
+harsh
+honest
+hopeful
+humorous
+imaginative
+impulsive
+incredible
+independent
+intense
+intriguing
+ironic
+jovial
+keen
+laid-back
+lavish
+legendary
+logical
+lovable
+loyal
+luminous
+magnificent
+manipulative
+mature
+meaningful
+mellow
+meticulous
+mischievous
+mysterious
+naive
+nervous
+noble
+obscure
+optimistic
+outlandish
+passionate
+patient
+peculiar
+playful
+poignant
+polarizing
+powerful
+prescient
+provocative
+quirky
+radiant
+raw
+realistic
+rebellious
+refined
+relentless
+remarkable
+resilient
+resourceful
+respectful
+restless
+risky
+romantic
+sardonic
+satirical
+sincere
+skilled
+sophisticated
+spontaneous
+strange
+subtle
+surreal
+tactful
+tense
+thoughtful
+turbulent
+unconventional
+unique
+unsettling
+unstable
+vibrant
+vivid
+vulnerable
+witty
+xenophobic
+youthful
+zealous
+zany