random-words 1.0.6 → 1.0.7

data/bin/randw

@@ -1,10 +1,11 @@
 #!/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
@@ -15,7 +16,7 @@ module RandomWords
         counter: :boldcyan,
         marker: :boldgreen,
         bracket: :cyan,
-        language: :boldmagenta
+        language: :boldmagenta,
       }
       @sources = @sentence_generator.sources.keys.map(&:to_s)
     end
@@ -30,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
 
@@ -50,13 +51,13 @@ 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
 
@@ -83,7 +84,7 @@ module RandomWords
     def combined_sentences(length = nil)
       number_of_sentences = length || 2
 
-      header_1('Random Combined Sentences:')
+      header_1("Random Combined Sentences:")
       @sources.count.times do |i|
         @sentence_generator.source = @sources[i - 1]
         @sentence_generator.sentence_length = :medium
@@ -92,20 +93,20 @@ module RandomWords
         s = @sentence_generator.sentence
         puts "#{marker} #{text(s)}"
         puts counter("#{s.split(/ /).count} words, #{s.length} characters")
-        puts colorize_text(' ' * 2, :boldwhite)
+        puts colorize_text(" " * 2, :boldwhite)
       end
     end
 
     def random_sentences
-      header_1('Random Sentences')
-      @sentence_generator.lengths.keys.each_with_index  do |length, index|
+      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')
+      header_1("Random Paragraphs")
       @sentence_generator.lengths.keys.each_with_index do |length, index|
         @sentence_generator.source = @sources[index]
         paragraphs(length, 3)
@@ -132,7 +133,7 @@ module RandomWords
 
     # Generate and print specified number of characters
     def random_characters
-      header_1('Random Characters (exact length)')
+      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)
@@ -143,7 +144,7 @@ module RandomWords
       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)
@@ -153,7 +154,7 @@ module RandomWords
     end
 
     def marker
-      colorize_text('•', @colors[:marker])
+      colorize_text("•", @colors[:marker])
     end
 
     def text(text)
@@ -163,8 +164,7 @@ module RandomWords
     def language
       "#{colorize_text("(",
                        @colors[:bracket])}#{colorize_text("#{@sentence_generator.source}", @colors[:language])}#{colorize_text(")",
-                       @colors[:bracket])}"
-
+                                                                                                                               @colors[:bracket])}"
     end
 
     def counter(length)
@@ -192,91 +192,104 @@ end
   method: nil,
   debug: false,
   whitespace: true,
-  separator: ' ',
-  use_extended_punctuation: false
+  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.banner = "Usage: randw [options]"
 
-  opts.separator 'OPTIONS:'
+  opts.separator "OPTIONS:"
 
-  opts.on('-S', '--source SOURCE', 'Specify the source language (default: latin)') do |source|
+  opts.on("-S", "--source SOURCE", "Specify the source language (default: latin)") do |source|
     @options[:source] = source.to_source
   end
 
-  opts.on('-l', '--length LENGTH', 'Specify the length of the sentence [short|medium|long|very_long]') 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('--[no-]extended', 'Specify whether to use extended punctuation in generated text') do |value|
+  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.separator "GENERATORS:"
 
-  opts.on('-s', '--sentences [NUMBER]', 'Generate NUMBER of random sentences (default: 3)') do |number|
+  opts.on("-s", "--sentences [NUMBER]", "Generate NUMBER of random sentences (default: 3)") do |number|
     @options[:method] = :sentences
     @options[:count] = number&.to_i || 3
   end
 
-
-  opts.on('-p', '--paragraphs [NUMBER]', 'Generate NUMBER of random paragraphs (default: 3)') do |number|
+  opts.on("-p", "--paragraphs [NUMBER]", "Generate NUMBER of random paragraphs (default: 3)") do |number|
     @options[:method] = :paragraphs
     @options[:count] = number&.to_i || 3
   end
 
-  opts.on('-w', '--words [NUMBER]', 'Generate NUMBER of random words (default: 10)') do |number|
+  opts.on("-w", "--words [NUMBER]", "Generate NUMBER of random words (default: 10)") do |number|
     @options[:method] = :words
     @options[:count] = number&.to_i || 10
   end
 
-  opts.on('-c', '--characters [NUMBER]', 'Generate random characters of length (default: 100)') do |number|
+  opts.on("-c", "--characters [NUMBER]", "Generate random characters of length (default: 100)") do |number|
     @options[:method] = :characters
     @options[:count] = number&.to_i || 100
   end
 
-  opts.on('-m', '--markdown [SETTINGS]', 'Generate random markdown text, comma separated string like "latin,10,all"') do |settings|
+  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'
+    @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|
+  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'
+    @options[:markdown_settings] = settings || "latin,10,all"
   end
 
-  opts.on('--password [LENGTH]', 'Generate a random password of LENGTH (default: 20)') do |len|
+  opts.on("--password [LENGTH]", "Generate a random password of LENGTH (default: 20)") do |len|
     @options[:method] = :password
     @options[:count] = len&.to_i || 20
   end
 
-  opts.separator 'PASSWORD OPTIONS:'
+  opts.separator "PASSWORD OPTIONS:"
 
-  opts.on('--separator CHAR', 'Specify the separator character for the password (default: " ")') do |separator|
+  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 |value|
+  opts.on("-n", "--[no-]whitespace", "Specify whether to remove whitespace in generated text (characters only)") do |value|
     @options[:whitespace] = value
   end
 
-  opts.separator 'DICTIONARIES:'
+  opts.separator "DICTIONARIES:"
 
-  opts.on('--list-dictionaries', 'List available dictionaries') do
+  opts.on("--list-dictionaries", "List available dictionaries") do
     @rw = RandomWords::Generator.new(:latin)
 
     @rw.sources.each do |k, v|
@@ -287,29 +300,29 @@ OptionParser.new do |opts|
     Process.exit 0
   end
 
-  opts.on('--create-dictionary [NAME]', 'Create a new dictionary') do |name|
+  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.separator "OTHER OPTIONS:"
 
-  opts.on('-d', '--debug', 'Enable debug mode, displays sentence/word/character counts') do
+  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
@@ -334,7 +347,7 @@ def markdown_settings(settings)
     grafs: 10,
     sentences: base_config[:paragraph_length],
     length: base_config[:sentence_length],
-    decorate: true,
+    decorate: false,
     link: false,
     ul: false,
     ol: false,
@@ -343,16 +356,17 @@ def markdown_settings(settings)
     code: false,
     mark: false,
     headers: false,
-    table: 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 /^a(ll)?/
+    when /^all$/
       new_options = {
         decorate: true,
         link: true,
@@ -364,35 +378,37 @@ def markdown_settings(settings)
         mark: true,
         headers: true,
         image: true,
-        table: 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/
+    when 'dec', 'decorate'
       markdown_options[:decorate] = true
-    when /^link/
+    when 'link'
       markdown_options[:link] = true
-    when /^ul/
+    when 'ul'
       markdown_options[:ul] = true
-    when /^ol/
+    when 'ol'
       markdown_options[:ol] = true
-    when /^dl/
+    when 'dl'
       markdown_options[:dl] = true
-    when /^bq/
+    when 'bq', 'blockquote'
       markdown_options[:bq] = true
-    when /^co/
+    when 'code'
       markdown_options[:code] = true
-    when /^ma/
+    when 'mark'
       markdown_options[:mark] = true
-    when /^h/
+    when 'header', 'h'
       markdown_options[:headers] = true
-    when /^t(a|bl)/
+    when 'table', 't'
       markdown_options[:table] = true
-    when /^[smlv]/
+    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
 
@@ -410,21 +426,21 @@ when :sentences
   total = {
     sentences: @options[:count],
     words: 0,
-    characters: 0
+    characters: 0,
   }
   # @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"
+  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
@@ -450,14 +466,18 @@ when :markdown, :html
   @rw.sentence_length = settings[:length] || :medium
   @rw.paragraph_length = settings[:sentences] || 5
   @rw.use_extended_punctuation = settings[:use_extended_punctuation] || false
-  puts @rw.html(settings)
+  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(/[oleats]/i)
   if m
     num_char = m.begin(0)
-    char = m[0].tr('oleats', '013475')
+    char = m[0].tr("oleats", "013475")
   else
     num_char = p.length
     char = rand(10).to_s
@@ -468,7 +488,7 @@ when :password
   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"
@@ -476,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

@@ -33,19 +33,39 @@ module RandomWords
     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 =~ /^[\w-]+$/ && !first_names_ended
-          first_names << line
-        elsif first_names_ended
-          last_names << line
+        if line.strip.empty? || line !~ /^[[:word:]]/i
+          idx += 1
+          sections[idx] = []
         else
-          first_names_ended = true
+          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?)
-      [first_names, last_names]
+      full_names.delete_if(&:empty?)
+      [first_names, last_names, full_names]
     end
   end
-end
+end

data/lib/random-words/config.rb

@@ -48,7 +48,6 @@ module RandomWords
       rw_source = RandomWords::Source.new(@lang, @source_dir)
 
       @dictionary = rw_source.dictionary
-
     end
 
     # Tests if a uer dictionary exists
@@ -56,7 +55,9 @@ module RandomWords
     # @raise [RuntimeError] if the user dictionary is incomplete
     def user_dictionary_exist?
       if user_lang_dir
-        raise "User dictionary for #{@lang} is incomplete. Please run create_user_dictionary." unless all_parts_of_speech?(user_lang_dir, @lang)
+        raise "User dictionary for #{@lang} is incomplete. Please run create_user_dictionary." unless all_parts_of_speech?(
+          user_lang_dir, @lang
+        )
 
         true
       else
@@ -93,11 +94,11 @@ module RandomWords
       dir ||= @source_dir
       exists = true
       SPEECH_PARTS.each do |part|
-        unless File.exist?(File.join(dir, "#{part}.txt"))
-          warn "Missing #{File.join(dir, "#{part}.txt")} for #{lang}"
-          exists = false
-          break
-        end
+        next if File.exist?(File.join(dir, "#{part}.txt"))
+
+        warn "Missing #{File.join(dir, "#{part}.txt")} for #{lang}"
+        exists = false
+        break
       end
       CONFIG_FILES.each do |file|
         unless File.exist?(File.join(dir, "#{file}.yml"))
@@ -112,7 +113,8 @@ module RandomWords
     # @param lang [String] The language to create the dictionary for
     # @return [Symbol, nil] The language symbol if successful, nil otherwise
     def create_user_dictionary(lang = nil)
-      return lang.to_sym if File.directory?(File.join(config_dir, 'words', lang)) && all_parts_of_speech?(File.join(config_dir, 'words', lang), lang)
+      return lang.to_sym if File.directory?(File.join(config_dir, 'words',
+                                                      lang)) && all_parts_of_speech?(File.join(config_dir, 'words', lang), lang)
 
       lang_dir = File.join(config_dir, 'words', lang)
 
@@ -132,27 +134,29 @@ module RandomWords
       target_file = File.join(lang_dir, 'numbers.yml')
       unless File.exist?(target_file)
         FileUtils.cp(source_file, target_file)
-        warn "Created numbers.yml"
+        warn 'Created numbers.yml'
       end
 
       # Create the config.yml file if it doesn't exist
-      target_file = File.join(lang_dir, "config.yml")
+      target_file = File.join(lang_dir, 'config.yml')
 
       unless File.exist?(target_file)
         config = {
-          "name" => lang,
-          "triggers" => [lang],
-          "description" => "User dictionary for #{lang}",
+          'name' => lang,
+          'triggers' => [lang],
+          'description' => "User dictionary for #{lang}"
         }
         File.write(target_file, config.to_yaml)
         warn "Created #{target_file}"
       end
 
-      if all_parts_of_speech?(lang_dir, lang) || (RandomWords.testing && !RandomWords.tested.include?('create_user_dictionary'))
-        RandomWords.tested << 'create_user_dictionary'
-        warn "Created #{lang} in #{lang_dir}"
-        lang.to_sym
+      unless all_parts_of_speech?(lang_dir, lang) || (RandomWords.testing && !RandomWords.tested.include?('create_user_dictionary'))
+        return
       end
+
+      RandomWords.tested << 'create_user_dictionary'
+      warn "Created #{lang} in #{lang_dir}"
+      lang.to_sym
     end
 
     # List all sources available, builtin and custom
@@ -161,13 +165,15 @@ module RandomWords
       return @sources if @sources
 
       @sources = {}
-      Dir[File.join(__dir__, "words", "*")].each do |dir|
+      Dir[File.join(__dir__, 'words', '*')].each do |dir|
         next unless File.directory?(dir)
+
         name = File.basename(dir)
         @sources[name] = RandomWords::Source.new(name, dir)
       end
-      Dir[File.join(config_dir, "words", "*")].each do |dir|
+      Dir[File.join(config_dir, 'words', '*')].each do |dir|
         next unless File.directory?(dir)
+
         name = File.basename(dir)
         @sources[name] = RandomWords::Source.new(name, dir)
       end
@@ -201,7 +207,7 @@ module RandomWords
       {
         source: configuration[:source].to_source || :latin,
         sentence_length: configuration[:length].to_length || :medium,
-        paragraph_length: configuration[:paragraph_length].to_i || 5,
+        paragraph_length: configuration[:paragraph_length].to_i || 5
       }
     end
 
@@ -236,9 +242,9 @@ module RandomWords
     def create_base_config(config_file)
       FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
       config = {
-        "source" => "latin",
-        "length" => "medium",
-        "paragraph_length" => 5,
+        'source' => 'latin',
+        'length' => 'medium',
+        'paragraph_length' => 5
       }
       File.write(config_file, config.to_yaml)
       warn "Created #{config_file}"