random-words 1.0.8 → 1.0.10

data/lib/random-words/generator.rb

@@ -12,6 +12,9 @@ module RandomWords
                 :terminators, :numbers, :plural_nouns, :plural_verbs, :plural_articles, :prepositions, :coordinating_conjunctions,
                 :all_words, :extended_punctuation, :phrases, :names
 
+    # return [Hash] configuration
+    attr_reader :config
+
     # Whether to use extended punctuation
     # @return [Boolean] true if extended punctuation is used, false otherwise
     attr_reader :use_extended_punctuation
@@ -28,6 +31,10 @@ module RandomWords
     # @return [Hash<String, RandomWords::Source>] List of available sources
     attr_reader :sources
 
+    # Debug mode
+    # @return [Boolean] true if debug mode is enabled, false otherwise
+    attr_accessor :debug
+
     # Define the default sentence parts
     # These parts will be used to generate random sentences and character strings
     SENTENCE_PARTS = %w[random_article random_adjective random_noun random_adverb random_verb random_adjective
@@ -43,6 +50,7 @@ module RandomWords
     #   generator.sentence_length = :long
     #   generator.paragraph_length = 3
     def initialize(source = :english, options = {})
+      @debug = options[:debug] || false
       @tested = []
       @config = RandomWords::Config.new(source)
       @source = source
@@ -79,9 +87,17 @@ module RandomWords
       @use_extended_punctuation = @options[:use_extended_punctuation]
 
       @terminators.concat(@config.dictionary[:extended_punctuation]) if @use_extended_punctuation
+
       lengths
     end
 
+    # Display debug message
+    def debug(msg)
+      return unless @debug
+
+      "%#{msg}%"
+    end
+
     # Shortcut for RandomWords::Config.create_user_dictionary
     # @param title [String] The title of the user dictionary
     # @return [Symbol] The symbolized name of the dictionary
@@ -145,6 +161,7 @@ module RandomWords
     # @!visibility private
     def test_random
       RandomWords.testing = true
+      @debug = true
       @use_extended_punctuation = true
       res = []
       res << random_noun
@@ -158,11 +175,13 @@ module RandomWords
       res << random_article_for_word('bananas')
       res << random_plural_article
       res << random_clause
+      res << random_separator
       res << random_subordinate_conjunction
       res << random_coordinating_conjunction
       res << random_number_with_plural
       res << random_phrase
       res << random_conjunction
+      res << random_name
       res << random_passive_verb
       res << random_plural_noun
       res << random_plural_verb
@@ -285,7 +304,7 @@ module RandomWords
     def generate_combined_sentence(length = nil)
       length ||= define_length(@sentence_length)
       sentence = generate_sentence
-      return sentence.to_sent(random_terminator).fix_caps(terminators) if sentence.length > length
+      return sentence.to_sent(random_terminator).fix_caps(terminators).expand_debug if sentence.length > length
 
       while sentence.length < length
         # Generate a random number of sentences to combine
@@ -295,7 +314,7 @@ module RandomWords
         sentence = "#{sentence.strip.no_term(terminators)}, #{random_coordinating_conjunction} #{new_sentence.no_term(terminators)}"
       end
 
-      sentence.to_sent(random_terminator).fix_caps(terminators)
+      sentence.to_sent(random_terminator).fix_caps(terminators).expand_debug
     end
 
     # Generate a random paragraph
@@ -312,12 +331,6 @@ module RandomWords
       sentences.join(' ').strip.compress
     end
 
-    # Generate a random name
-    # @return [String] A randomly generated name
-    def name
-      random_name
-    end
-
     # Generate a random code language
     # @return [Symbol] A randomly selected code language
     def code_lang
@@ -360,6 +373,12 @@ module RandomWords
       RandomWords::LoremMarkdown.new(settings).output
     end
 
+    # Generate a random name
+    # @return [String] A randomly generated name
+    def name
+      "#{debug('NAM')}#{random_name}"
+    end
+
     private
 
     # Struct for overflow configuration
@@ -425,21 +444,25 @@ module RandomWords
         additional_clauses = generate_additional_clauses
         sentence_components.concat(additional_clauses)
         sentence_components.map!(&:strip)
-        break if sentence_components.join(' ').length >= length
-
-        conjunction = if roll(50) || (RandomWords.testing && !RandomWords.tested.include?('subordinate_conjunction'))
-                        RandomWords.tested << 'subordinate_conjunction' if RandomWords.testing
-                        random_subordinate_conjunction.strip
-                      else
-                        RandomWords.tested << 'coordinating_conjunction' if RandomWords.testing
-                        random_coordinating_conjunction.strip
-                      end
-        # sentence_components.unshift(conjunction.capitalize) # Place conjunction at the start
-        sentence_components << conjunction unless conjunction.empty?
+        # break if sentence_components.join(' ').length >= length
+
+        # conjunction = if roll(50) || (RandomWords.testing && !RandomWords.tested.include?('subordinate_conjunction'))
+        #                 RandomWords.tested << 'subordinate_conjunction' if RandomWords.testing
+        #                 random_subordinate_conjunction.strip
+        #               else
+        #                 RandomWords.tested << 'coordinating_conjunction' if RandomWords.testing
+        #                 random_coordinating_conjunction.strip
+        #               end
+        # # sentence_components.unshift(conjunction.capitalize) # Place conjunction at the start
+        # sentence_components << conjunction unless conjunction.empty?
       end
 
       # Join all parts into a single sentence
-      sentence_components.join(" #{roll(50) ? random_coordinating_conjunction : random_subordinate_conjunction} ").strip.compress
+      output = sentence_components.shift
+      sentence_components.each do |part|
+        output << " #{roll(50) ? random_coordinating_conjunction : random_subordinate_conjunction} #{part}"
+      end
+      output.strip.compress
     end
 
     # Convert a length symbol to a specific length value
@@ -486,7 +509,7 @@ module RandomWords
     # @example
     #  random_conjunction # Returns a random conjunction
     def random_conjunction
-      coordinating_conjunctions.sample
+      "#{debug('COC')}#{coordinating_conjunctions.sample}"
     end
 
     # Generate a random number with a plural noun
@@ -496,68 +519,72 @@ module RandomWords
     #   random_number_with_plural # Returns a string like "three cats"
     def random_number_with_plural
       num = rand(1000)
-      number = num.to_word(@numbers)
+      number = if roll(50)
+                 num.to_word(@numbers)
+               else
+                 num.to_commas
+               end
       if num == 1 || (RandomWords.testing && !RandomWords.tested.include?('random_noun'))
         RandomWords.tested << 'random_noun' if RandomWords.testing
-        "#{number} #{random_noun}"
+        "#{debug('NUM')}#{number} #{random_noun}"
       else
         RandomWords.tested << 'random_plural_noun' if RandomWords.testing
-        "#{number} #{random_plural_noun}"
+        "#{debug('NUM')}#{number} #{random_plural_noun}"
       end
     end
 
     # Generate a random phrase
     # @return [String] A randomly selected phrase
     def random_phrase
-      phrases.sample
+      "#{debug('PHR')}#{phrases.sample}"
     end
 
     # Generate a random noun
     # @return [String] A randomly selected noun
     def random_noun
-      nouns.sample
+      "#{debug('NOU')}#{nouns.sample}"
     end
 
     # Generate a random plural noun
     # @return [String] A randomly selected plural noun
     def random_plural_noun
-      plural_nouns.sample
+      "#{debug('PLN')}#{plural_nouns.sample}"
     end
 
     # Generate a random verb
     # @return [String] A randomly selected verb
     def random_verb
-      verbs.sample
+      "#{debug('VER')}#{verbs.sample}"
     end
 
     # Generate a random plural verb
     # @return [String] A randomly selected plural verb
     def random_plural_verb
-      plural_verbs.sample
+      "#{debug('PLV')}#{plural_verbs.sample}"
     end
 
     # Generate a random passive verb
     # @return [String] A randomly selected passive verb
     def random_passive_verb
-      passive_verbs.sample
+      "#{debug('PAV')}#{passive_verbs.sample}"
     end
 
     # Generate a random adverb
     # @return [String] A randomly selected adverb
     def random_adverb
-      adverbs.sample
+      "#{debug('ADV')}#{adverbs.sample}"
     end
 
     # Generate a random adjective
     # @return [String] A randomly selected adjective
     def random_adjective
-      adjectives.sample
+      "#{debug('ADJ')}#{adjectives.sample}"
     end
 
     # Generate a random article
     # @return [String] A randomly selected article
     def random_article
-      articles.sample
+      "#{debug('ART')}#{articles.rotate[0]}"
     end
 
     # Generate a random article for a noun
@@ -574,7 +601,7 @@ module RandomWords
       RandomWords.tested << 'random_article_for_word' if RandomWords.testing
       if word.start_with?(/[aeiou]/i) && article =~ /^an?$/i
         article = 'an'
-      elsif article =~ /^an$/i
+      elsif /^an$/i.match?(article)
         article = 'a'
       end
       article
@@ -583,31 +610,42 @@ module RandomWords
     # Generate a random plural article
     # @return [String] A randomly selected plural article
     def random_plural_article
-      plural_articles.sample
+      "#{debug('PLA')}#{plural_articles.rotate[0]}"
     end
 
     # Generate a random clause
     # @return [String] A randomly selected clause
     def random_clause
-      clauses.sample
+      "#{debug('CLA')}#{clauses.sample}"
+    end
+
+    # Generate a random set of separators
+    def random_separators
+      [',', ',', ',', ';', ':', ' —']
+    end
+
+    # Generate a random separator
+    # @return [String] A randomly selected separator
+    def random_separator
+      "#{debug('SEP')}#{random_separators.sample}"
     end
 
     # Generate a random subordinate conjunction
     # @return [String] A randomly selected subordinate conjunction
     def random_subordinate_conjunction
-      subordinate_conjunctions.sample
+      "#{debug('SUC')}#{subordinate_conjunctions.rotate[0]}"
     end
 
     # Generate a random coordinating conjunction
     # @return [String] A randomly selected coordinating conjunction
     def random_coordinating_conjunction
-      coordinating_conjunctions.sample
+      "#{debug('COC')}#{coordinating_conjunctions.rotate[0]}"
     end
 
     # Generate a random preposition
     # @return [String] A randomly selected preposition
     def random_preposition
-      prepositions.sample
+      "#{debug('PRE')}#{prepositions.rotate[0]}"
     end
 
     # Generate a random prepositional phrase
@@ -624,7 +662,7 @@ module RandomWords
                  "#{random_article_for_word(noun)} #{noun}"
                end
 
-      "#{preposition} #{phrase}"
+      "#{debug('PRP')}#{preposition} #{phrase}"
     end
 
     # Generate a random terminator
@@ -653,20 +691,25 @@ module RandomWords
     # @example
     #   generate_main_clause # Returns a random main clause
     def generate_main_clause
-      start_with_phrase = roll(20)
-      start_with_plural = roll(20)
-      beginning = if start_with_phrase
+      beginning = case rand(10)
+                  when 0..1
                     random_phrase
-                  elsif start_with_plural
+                  when 2..3
                     "#{random_number_with_plural} #{random_adverb} #{random_plural_verb}"
+                  when 4..5
+                    random_name
+                  when 6..7
+                    noun = random_noun
+                    "#{random_adverb}, #{random_article_for_word(noun)} #{noun} #{random_verb}"
                   else
                     noun = random_noun
                     adjective = random_adjective
                     "#{random_article_for_word(adjective)} #{adjective} #{noun} #{random_adverb} #{random_verb}"
                   end
       tail = roll(50) ? " #{random_prepositional_phrase}" : ''
-      tail += roll(10) ? ", #{random_clause}" : ''
-      "#{beginning.strip.sub(/,?$/, ', ')}#{tail}"
+      separator = random_separator
+      tail += roll(10) ? "#{separator} #{random_clause}" : ''
+      "#{beginning.strip.sub(/[#{Regexp.escape(separator)}]*$/, separator)}#{tail}"
     end
 
     # Simplified generate_additional_clauses

data/lib/random-words/lorem-markdown.rb

@@ -35,14 +35,16 @@ module RandomWords
         code: false,
         mark: false,
         headers: false,
-        table: false
+        table: false,
+        extended: false
       }
 
       @options = defaults.merge(options)
 
       @generator = RandomWords::Generator.new(@options[:source], {
                                                 sentence_length: @options[:length],
-                                                paragraph_length: @options[:sentences]
+                                                paragraph_length: @options[:sentences],
+                                                use_extended_punctuation: @options[:extended]
                                               })
 
       @output = ''
@@ -107,10 +109,26 @@ module RandomWords
 
       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
+      text.gsub!(/“|”/, '"')
+      text.gsub!(/‘|’/, "'")
+      text.gsub!(/–/, '-')
+      text.gsub!(/—/, '--')
+      text.gsub!(/—/, '---')
+      text.gsub!(/•/, '*')
+      text.gsub!(/…/, '...')
+      @output = text
+    end
+
     # Rolls for zero with the specified odds.
     def roll(odds)
       Random.rand(0..odds).zero?
@@ -349,7 +367,6 @@ module RandomWords
       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))

data/lib/random-words/number-to-word.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Original code by Mike Burns
+# Original code by Mike Burns 2007, updated by Brett Terpstra 2025
 
 # Copyright 2007 Mike Burns
 
@@ -40,7 +40,7 @@ module RandomWords
         place += 1
         tmp /= 1000
       end
-      final == '' ? 'zero' : final.sub(/\s+$/, '')
+      final == '' ? 'zero' : final.sub(/ and *$/, '').sub(/\s+$/, '')
     end
 
     # For testing edge cases
@@ -67,9 +67,9 @@ module RandomWords
         hundreds = self / 100
         tens = self % 100
         if tens.zero?
-          append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]}", place, numbers)
+          append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]} and ", place, numbers)
         else
-          append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]} " + tens.tens_place_to_word(numbers), place,
+          append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]} and " + tens.tens_place_to_word(numbers), place,
                        numbers)
         end
       end

data/lib/random-words/numeric.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RandomWords
+  # Number helpers
+  class ::Numeric
+    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
+    end
+  end
+end

data/lib/random-words/string.rb

@@ -23,7 +23,7 @@ module RandomWords
       gsub(/[^-a-zA-Z0-9\s]/, '').strip
     end
 
-    # Captialize instances of "i" in a string.
+    # Capitalize instances of "i" in a string.
     # @return [String] The string with "i" capitalized.
     # @example
     #   "this is an i".capitalize_i # => "this is an I"
@@ -41,12 +41,20 @@ module RandomWords
     def capitalize
       return self if empty?
 
-      letters = split('')
+      str = dup
+
+      debug = ''
+      str.sub!(/^%[A-Z]+%/) do |match|
+        debug = match
+        ''
+      end
+
+      letters = str.split('')
       string = []
       string << letters.shift while letters[0] !~ /[[:word:]]/
       string << letters.shift.upcase
       string.concat(letters)
-      string.join('')
+      debug + string.join('')
     end
 
     # Downcase the first letter of a string, respecting punctuation.
@@ -76,26 +84,26 @@ module RandomWords
       return capitalize if terminator_ends.empty?
 
       terminator_regex = Regexp.new("[#{Regexp.escape(terminator_ends.join)}]")
-      return capitalize unless self =~ terminator_regex
+      return capitalize unless match?(terminator_regex)
 
       split(/(?<=#{terminator_regex}) /).map do |sentence|
         sentence.capitalize
       end.join(' ')
     end
 
-    # Remove duplicate commas
-    # @return [String] The string with duplicate commas removed.
+    # Remove duplicate punctuation
+    # @return [String] The string with duplicate punctuation removed.
     # @example
-    #  "Hello, , World!".remove_duplicate_commas # => "Hello, World!"
-    def dedup_commas
-      gsub(/(, *)+/, ',').gsub(',', ', ')
+    #  "Hello, , World!".dedup_punctuation # => "Hello, World!"
+    def dedup_punctuation
+      gsub(/((%[A-Z]+%)?[,.;:—] ?)+/, '\1').gsub(/([,;:—])/, '\1')
     end
 
     # Generate a sentence with capitalization and terminator
     # @param terminator [Array<String>] An array of beginning and ending punctuation marks.
     # @return [String] The string with a random punctuation mark at the end.
     def to_sent(terminator)
-      capitalize.compress.capitalize_i.dedup_commas.terminate(terminator)
+      capitalize.compress.capitalize_i.dedup_punctuation.terminate(terminator)
     end
 
     # Split a string by newlines, clean each line, and remove empty lines.
@@ -104,7 +112,9 @@ module RandomWords
     #   "Hello, World!\n\nThis is a test.".split_lines # => ["Hello World", "This is a test"]
     #
     def split_lines
-      strip.split("\n").map(&:clean).reject(&:empty?)
+      arr = strip.split("\n").map(&:clean)
+      arr.reject!(&:empty?)
+      arr
     end
 
     # Compress multiple spaces into a single space and remove leading/trailing spaces.
@@ -120,7 +130,13 @@ module RandomWords
     #   "Hello World".terminate(["", "."]) # => "Hello World."
     #
     def terminate(terminator)
-      sub(/^/, terminator[0]).sub(/[^a-zA-Z0-9]*$/, terminator[1])
+      debug = ''
+      str = dup
+      str.sub!(/^%[A-Z]+%/) do |match|
+        debug = match
+        ''
+      end
+      debug + str.sub(/^/, terminator[0]).sub(/[^a-zA-Z0-9]*$/, terminator[1])
     end
 
     # Remove any punctuation mark from the end of a string.
@@ -204,7 +220,7 @@ module RandomWords
 
       sources.each do |_k, v|
         v.names.each do |name|
-          next unless name.to_s =~ /^#{self}/i
+          next unless /^#{self}/i.match?(name.to_s)
 
           new_source = v.name
           break
@@ -231,5 +247,88 @@ module RandomWords
         :medium
       end
     end
+
+    # Terminal output colors
+    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
+
+    # Colorize the text for terminal output.
+    # @param text [String] The text to colorize.
+    # @param color [Symbol] The color to use (e.g., :red, :green).
+    #
+    # If the output is not a TTY, the text is returned without colorization.
+    #
+    # @return [String] The colorized text.
+    # @example
+    #  colorize_text("Hello, World!", :red) # => "\e[31mHello, World!\e[0m"
+    def colorize_text(text, color, testing = false)
+      return text if !$stdout.isatty && !testing
+
+      return text unless colors.key?(color)
+
+      return text if text.empty?
+
+      color_code = colors[color]
+
+      "\e[#{color_code}m#{text}\e[0m"
+    end
+
+    # Dictionary of expansions
+    def expansions
+      {
+        'ADJ' => ['Adjective', :yellow],
+        'ADV' => ['Adverb', :boldyellow],
+        'ART' => ['Article', :cyan],
+        'CLA' => ['Clause', :magenta],
+        'COC' => ['Coordinating Conjunction', :magenta],
+        'CON' => ['Conjunction', :magenta],
+        'NAM' => ['Name', :boldblue],
+        'NOU' => ['Noun', :green],
+        'NUM' => ['Number', :red],
+        'PAV' => ['Passive Verb', :boldred],
+        'PHR' => ['Phrase', :boldcyan],
+        'PLA' => ['Plural Article', :yellow],
+        'PLN' => ['Plural Noun', :green],
+        'PLV' => ['Plural Verb', :boldred],
+        'PNO' => ['Proper Noun', :boldblack],
+        'PRE' => ['Preposition', :boldwhite],
+        'PRP' => ['Prepositional Phrase', :boldwhite],
+        'SEP' => ['Separator', :red],
+        'SUC' => ['Subordinate Conjunction', :magenta],
+        'TER' => ['Terminator', :boldcyan],
+        'VER' => ['Verb', :boldred]
+      }
+    end
+
+    # Expand abbreviated debug statements in the string.
+    # @return [String] The expanded debug string.
+    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)
+      end
+    end
   end
 end

data/lib/random-words/version.rb

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