random-words 1.0.5 → 1.0.7

data/bin/randw

@@ -1,20 +1,24 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative '../lib/random-words'
-require 'optparse'
+require_relative "../lib/random-words"
+require "optparse"
 
 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
+        bracket: :cyan,
+        language: :boldmagenta,
       }
+      @sources = @sentence_generator.sources.keys.map(&:to_s)
     end
 
     def colors
@@ -27,15 +31,15 @@ module RandomWords
         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
+        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
 
@@ -47,19 +51,20 @@ module RandomWords
 
     def header_1(text)
       puts colorize_text("\n\n#{text}", :boldgreen)
-      puts colorize_text('=' * text.length, :boldgreen)
+      puts colorize_text("=" * text.length, :boldgreen)
       puts "\n"
     end
 
     def header_2(text)
       puts colorize_text("\n\n#{text}", :boldyellow)
-      puts colorize_text('-' * text.length, :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
 
       header_2("Random Paragraph (#{@sentence_generator.paragraph_length} #{@sentence_generator.sentence_length} sentences)")
       graf = @sentence_generator.paragraph
@@ -77,40 +82,60 @@ module RandomWords
 
     # Generate and print random combined sentences
     def combined_sentences(length = nil)
-      number_of_sentences = length || 3
-      header_1('Random Combined Sentences:')
-      @sentence_generator.sentences(number_of_sentences).each_with_index do |_sentence, _index|
-        puts text(sentence(:medium))
+      number_of_sentences = length || 2
+
+      header_1("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
-      header_1('Random Sentences')
-      @sentence_generator.lengths.keys.each do |length|
+      header_1("Random Sentences")
+      @sentence_generator.lengths.keys.each_with_index do |length, index|
+        @sentence_generator.source = @sources[index]
         sentence(length)
       end
     end
 
     def random_paragraphs
-      header_1('Random Paragraphs')
-      @sentence_generator.lengths.keys.each do |length|
+      header_1("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 = 10
+      number_of_words = []
+      @sources.count.times do |i|
+        puts i
+        number_of_words << (i * i) * 5 + 10
+      end
+
       header_1("#{number_of_words} Random Words")
-      s = @sentence_generator.words(number_of_words)
-      puts "#{marker} #{text(s)}  "
-      puts counter("#{s.split(/ /).count} words, #{s.length} characters")
+      @sources.each_with_index do |source, index|
+        header_2("#{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
-      header_1('Random Characters (exact length)')
-      [20, 50, 120, 200].each do |i|
+      header_1("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
@@ -118,8 +143,10 @@ module RandomWords
       # Generate and print specified number of characters
       max_characters = [15, 25, 53, 110, 600]
       min_characters = [10, 20, 50, 100, 500]
-      header_1('Random Characters (length range)')
+
+      header_1("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)}"
@@ -127,16 +154,22 @@ module RandomWords
     end
 
     def marker
-      colorize_text('•', @colors[: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}", @colors[:counter])}#{colorize_text(']', @colors[:bracket])}"
+      "#{colorize_text("[",
+                       @colors[:bracket])}#{colorize_text("#{length}", @colors[:counter])}#{colorize_text("]", @colors[:bracket])} #{language}"
     end
 
     def print_test
@@ -149,6 +182,8 @@ module RandomWords
   end
 end
 
+# Default options for the script
+
 @options = {
   source: :latin,
   length: :medium,
@@ -157,94 +192,137 @@ end
   method: nil,
   debug: false,
   whitespace: true,
-  separator: ' '
+  separator: " ",
+  use_extended_punctuation: false,
 }
 
+markdown_help = <<HELP
+                                     dec: add em and strong
+                                     link: add links
+                                     ul: add unordered lists
+                                     ol: add ordered lists
+                                     dl: add definition lists
+                                     bq: add block quotes
+                                     code: add code spans and block
+                                     mark: add ==highlights==
+                                     headers: add headlines
+                                     image: add images
+                                     table: add tables
+HELP
+
 OptionParser.new do |opts|
-  opts.banner = 'Usage: randw [options]'
-
-  opts.separator 'Options:'
-
-  opts.on('-S', '--source [SOURCE]', 'Specify the source language (default: latin)') do |source|
-    @options[:source] = case source
-                        when /^e/
-                          :english
-                        when /^l/
-                          :latin
-                        when /^(co|pro)/
-                          :corporate
-                        when /^(me|ba|ca)/
-                          :bacon
-                        else
-                          :latin
-                        end
+  opts.banner = "Usage: randw [options]"
+
+  opts.separator "OPTIONS:"
+
+  opts.on("-S", "--source SOURCE", "Specify the source language (default: latin)") do |source|
+    @options[:source] = source.to_source
   end
 
-  opts.on('-l', '--length [short|medium|long|very_long]', 'Specify the length of the sentence') do |length|
+  opts.on("-l", "--length LENGTH", "Specify the length of the sentence [short|medium|long|very_long]") do |length|
     @options[:length] = case length
-                        when /^s/
-                          :short
-                        when /^l/
-                          :long
-                        when /^v/
-                          :very_long
-                        else
-                          :medium
-                        end
+      when /^s/
+        :short
+      when /^l/
+        :long
+      when /^v/
+        :very_long
+      else
+        :medium
+      end
   end
 
-  opts.on('--graf-length [NUMBER]', 'Specify the number of sentences in a paragraph') do |length|
+  opts.on("--graf-length NUMBER", "Specify the number of sentences in a paragraph") do |length|
     @options[:paragraph_length] = length.to_i
   end
 
-  opts.on('-s', '--sentences [NUMBER]', 'Generate random sentences') do |number|
+  opts.on("--[no-]extended", "Specify whether to use extended punctuation in generated text") do |value|
+    @options[:use_extended_punctuation] = value
+  end
+
+  opts.separator "GENERATORS:"
+
+  opts.on("-s", "--sentences [NUMBER]", "Generate NUMBER of random sentences (default: 3)") do |number|
     @options[:method] = :sentences
-    @options[:count] = number.to_i
+    @options[:count] = number&.to_i || 3
   end
 
-  opts.on('-p', '--paragraphs [NUMBER]', 'Generate random paragraphs') do |number|
+  opts.on("-p", "--paragraphs [NUMBER]", "Generate NUMBER of random paragraphs (default: 3)") do |number|
     @options[:method] = :paragraphs
-    @options[:count] = number
+    @options[:count] = number&.to_i || 3
   end
 
-  opts.on('-w', '--words [NUMBER]', 'Generate random words') do |number|
+  opts.on("-w", "--words [NUMBER]", "Generate NUMBER of random words (default: 10)") do |number|
     @options[:method] = :words
-    @options[:count] = number
+    @options[:count] = number&.to_i || 10
   end
 
-  opts.on('-c', '--characters [NUMBER]', 'Generate random characters') do |number|
+  opts.on("-c", "--characters [NUMBER]", "Generate random characters of length (default: 100)") do |number|
     @options[:method] = :characters
-    @options[:count] = number
+    @options[:count] = number&.to_i || 100
   end
 
-  opts.on('--password', 'Generate a random password') do
+  opts.on("-m", "--markdown [SETTINGS]", "Generate random markdown text, comma separated string like \"latin,10,all\"\n#{markdown_help}") do |settings|
+    @options[:method] = :markdown
+    @options[:markdown_settings] = settings || "latin,10,all"
+  end
+
+  opts.on("-H", "--html [SETTINGS]", "Generate random html text, comma separated string like \"latin,10,all\"") do |settings|
+    @options[:method] = :html
+    @options[:markdown_settings] = settings || "latin,10,all"
+  end
+
+  opts.on("--password [LENGTH]", "Generate a random password of LENGTH (default: 20)") do |len|
     @options[:method] = :password
-    @options[:count] = 20
+    @options[:count] = len&.to_i || 20
   end
 
-  opts.on('--separator [CHAR]', 'Specify the separator character for the password') do |separator|
+  opts.separator "PASSWORD OPTIONS:"
+
+  opts.on("--separator CHAR", 'Specify the separator character for the password (default: " ")') do |separator|
     @options[:separator] = separator
   end
 
-  opts.on('-n', '--no-whitespace', 'Specify whether to remove whitespace in generated text (characters only)') do
-    @options[:whitespace] = false
+  opts.on("-n", "--[no-]whitespace", "Specify whether to remove whitespace in generated text (characters only)") do |value|
+    @options[:whitespace] = value
   end
 
-  opts.on('-d', '--debug', 'Enable debug mode, displays sentence/word/character counts') do
+  opts.separator "DICTIONARIES:"
+
+  opts.on("--list-dictionaries", "List available dictionaries") do
+    @rw = RandomWords::Generator.new(:latin)
+
+    @rw.sources.each do |k, v|
+      puts "#{v.name}: #{v.description}"
+      puts "triggers: (#{v.names.join(", ")})"
+      puts
+    end
+    Process.exit 0
+  end
+
+  opts.on("--create-dictionary [NAME]", "Create a new dictionary") do |name|
+    @rw = RandomWords::Generator.new(:latin)
+    @rw.create_dictionary(name)
+    Process.exit 0
+  end
+
+  opts.separator "OTHER OPTIONS:"
+
+  opts.on("-d", "--debug", "Enable debug mode, displays sentence/word/character counts") do
     @options[:debug] = true
   end
 
-  opts.on('-h', '--help', 'Display this help message') do
+  opts.on("-h", "--help", "Display this help message") do
     puts opts
     exit
   end
 
-  opts.on('-v', '--version', 'Display the version') do
+  opts.on("-v", "--version", "Display the version") do
     puts "RandomWords v#{RandomWords::VERSION}"
     exit
   end
 
-  opts.on('-t', '--test', 'Run the full debug test') do
+  opts.on("-t", "--test", "Run the full debug test") do
     @options[:method] = :test
     @options[:debug] = true
   end
@@ -261,9 +339,86 @@ def debug(msg)
   warn RandomWords::Terminal.new.colorize_text(" [#{msg}]", :cyan)
 end
 
+def markdown_settings(settings)
+  base_config = RandomWords::Config.new(:latin).config
+
+  defaults = {
+    source: base_config[:source].is_a?(String) ? base_config[:source].to_source : base_config[:source],
+    grafs: 10,
+    sentences: base_config[:paragraph_length],
+    length: base_config[:sentence_length],
+    decorate: false,
+    link: false,
+    ul: false,
+    ol: false,
+    dl: false,
+    bq: false,
+    code: false,
+    mark: false,
+    headers: false,
+    table: false,
+  }
+  sources = []
+  RandomWords::Generator.new(:latin).sources.each { |k, v| sources.concat(v.names.map(&:to_s)) }
+
+  markdown_options = defaults.dup
+  settings = settings.split(%r{[,/.\|]}).map(&:strip)
+
+  settings.each do |setting|
+    case setting
+    when /^all$/
+      new_options = {
+        decorate: true,
+        link: true,
+        ul: true,
+        ol: true,
+        dl: true,
+        bq: true,
+        code: true,
+        mark: true,
+        headers: true,
+        image: true,
+        table: true,
+      }
+      markdown_options.merge!(new_options)
+    when Regexp.union(sources)
+      markdown_options[:source] = setting.to_source
+    when /^\d+$/
+      markdown_options[:grafs] = setting.to_i
+    when 'dec', 'decorate'
+      markdown_options[:decorate] = true
+    when 'link'
+      markdown_options[:link] = true
+    when 'ul'
+      markdown_options[:ul] = true
+    when 'ol'
+      markdown_options[:ol] = true
+    when 'dl'
+      markdown_options[:dl] = true
+    when 'bq', 'blockquote'
+      markdown_options[:bq] = true
+    when 'code'
+      markdown_options[:code] = true
+    when 'mark'
+      markdown_options[:mark] = true
+    when 'header', 'h'
+      markdown_options[:headers] = true
+    when 'table', 't'
+      markdown_options[:table] = true
+    when 'short', 's', 'medium', 'med', 'm', 'long', 'l', 'very_long', 'vl'
+      markdown_options[:length] = setting.to_length
+    else
+      markdown_options[:source] = setting.to_source
+    end
+  end
+
+  markdown_options
+end
+
 @rw = RandomWords::Generator.new(@options[:source])
 @rw.sentence_length = @options[:length] || :medium
 @rw.paragraph_length = @options[:paragraph_length] || 3
+@rw.use_extended_punctuation = @options[:use_extended_punctuation] || false
 @options[:count] = @options[:count].to_i
 
 case @options[:method]
@@ -271,21 +426,21 @@ when :sentences
   total = {
     sentences: @options[:count],
     words: 0,
-    characters: 0
+    characters: 0,
   }
-  @options[:count].times do
-    s = @rw.sentence
-    total[:words] += s.split(/ /).count
-    total[:characters] += s.length
-    print s
-    debug "#{s.split(/ /).count}w, #{s.length}c"
-  end
+  # @options[:count].times do
+  s = @rw.sentences(@options[:count]).join(" ")
+  total[:words] += s.split(/ /).count
+  total[:characters] += s.length
+  print s
+  debug "#{s.split(/ /).count}w, #{s.length}c"
+  # end
   debug "Total: #{total[:sentences]}s, #{total[:words]}w, #{total[:characters]}c"
 when :paragraphs
   total = {
     sentences: 0,
     words: 0,
-    characters: 0
+    characters: 0,
   }
   @options[:count].times do
     p = @rw.paragraph
@@ -305,13 +460,24 @@ when :characters
   c = @rw.characters(@options[:count], whitespace: @options[:whitespace])
   print c
   debug "#{c.split(/ /).count}w, #{c.length}c"
+when :markdown, :html
+  settings = markdown_settings(@options[:markdown_settings])
+  @rw.source = settings[:source]
+  @rw.sentence_length = settings[:length] || :medium
+  @rw.paragraph_length = settings[:sentences] || 5
+  @rw.use_extended_punctuation = settings[:use_extended_punctuation] || false
+  if @options[:method] == :markdown
+    puts @rw.markdown(settings)
+  else
+    puts @rw.html(settings)
+  end
 when :password
   p = @rw.characters(20, whitespace: @options[:whitespace])
 
-  m = p.match(/[oleat]/i)
+  m = p.match(/[oleats]/i)
   if m
     num_char = m.begin(0)
-    char = m[0].tr('oleat', '01347')
+    char = m[0].tr("oleats", "013475")
   else
     num_char = p.length
     char = rand(10).to_s
@@ -319,10 +485,10 @@ when :password
   p[num_char] = char
 
   cap_char = rand(20)
-  cap_char = rand(20) while p[cap_char] == ' '
+  cap_char = rand(20) while p[cap_char] !~ /[a-z]/
   p[cap_char] = p[cap_char].upcase
 
-  tail_char = p =~ /[^a-z0-9]/i ? '' : %w[! @ # $ % ^ & * ( ) _ + - = ; : < > , . ? /].sample
+  tail_char = p =~ /[^a-z0-9]/i ? "" : %w[! @ # $ % ^ & * ( ) _ + - = ; : < > , . ? /].sample
 
   print p.gsub(/ /, @options[:separator]) + tail_char
   debug "#{p.split(@options[:separator]).count}w, #{p.length}c"
@@ -330,5 +496,5 @@ when :test
   t = RandomWords::Terminal.new(@options[:source])
   t.print_test
 else
-  puts 'Please specify a valid method: sentences, paragraphs, words, or characters.'
+  puts "Please specify a valid method: sentences, paragraphs, words, or characters."
 end

data/lib/random-words/array.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RandomWords
+  # Array helpers for RandomWords
+  # This module extends the Array class with additional methods for manipulating arrays.
+  class ::Array
+    # Split a terminators array into terminators and
+    # extended punctuation based on a line without a comma
+    # @return [Array<Array<String>>]
+    #   An array containing two arrays: the first for terminators
+    #   and the second for extended punctuation
+    def split_terminators
+      terminators = []
+      extended_punctuation = []
+      terminators_ended = false
+      each do |line|
+        if line.include?(',') && !terminators_ended
+          terminators << line.split(',').map(&:strip)
+        elsif terminators_ended
+          extended_punctuation << line.split(',').map(&:strip)
+        else
+          terminators_ended = true
+        end
+      end
+      terminators.delete_if { |line| line[1].empty? }
+      extended_punctuation.delete_if { |line| line[1].empty? }
+      [terminators, extended_punctuation]
+    end
+
+    # Split a names list into first and last names
+    # Splits the names at blank line into two arrays: first names and last names.
+    # @return [Array<Array<String>, Array<String>>]
+    def split_names
+      first_names = []
+      last_names = []
+      full_names = []
+      first_names_ended = false
+      last_names_ended = false
+
+      sections = [[]]
+      idx = 0
+      each do |line|
+        if line.strip.empty? || line !~ /^[[:word:]]/i
+          idx += 1
+          sections[idx] = []
+        else
+          sections[idx] << line.strip
+        end
+      end
+
+      if sections.length == 1
+        first_names = []
+        last_names = []
+        full_names = sections[0]
+      elsif sections.length == 2
+        first_names = sections[0]
+        last_names = sections[1]
+        full_names = []
+      else
+        first_names = sections[0]
+        last_names = sections[1]
+        full_names = sections[2]
+      end
+
+      first_names.delete_if(&:empty?)
+      last_names.delete_if(&:empty?)
+      full_names.delete_if(&:empty?)
+      [first_names, last_names, full_names]
+    end
+  end
+end