random-words 1.0.4 → 1.0.6

data/bin/randw

@@ -9,12 +9,15 @@ module RandomWords
     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
@@ -60,6 +63,7 @@ module RandomWords
     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 +81,60 @@ module RandomWords
 
     # Generate and print random combined sentences
     def combined_sentences(length = nil)
-      number_of_sentences = length || 3
+      number_of_sentences = length || 2
+
       header_1('Random Combined Sentences:')
-      @sentence_generator.sentences(number_of_sentences).each_with_index do |_sentence, _index|
-        puts text(sentence(:medium))
+      @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|
+      @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|
+      @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|
+      [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 +142,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)')
       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)}"
@@ -134,9 +160,16 @@ module RandomWords
       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,30 +192,20 @@ end
   method: nil,
   debug: false,
   whitespace: true,
-  separator: ' '
+  separator: ' ',
+  use_extended_punctuation: false
 }
 
 OptionParser.new do |opts|
   opts.banner = 'Usage: randw [options]'
 
-  opts.separator '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.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
@@ -193,43 +218,83 @@ OptionParser.new do |opts|
                         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"') 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.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
@@ -261,9 +326,83 @@ 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: true,
+    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 /^a(ll)?/
+      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/
+      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/
+      markdown_options[:bq] = true
+    when /^co/
+      markdown_options[:code] = true
+    when /^ma/
+      markdown_options[:mark] = true
+    when /^h/
+      markdown_options[:headers] = true
+    when /^t(a|bl)/
+      markdown_options[:table] = true
+    when /^[smlv]/
+      markdown_options[:length] = setting.to_length
+    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]
@@ -273,13 +412,13 @@ when :sentences
     words: 0,
     characters: 0
   }
-  @options[:count].times do
-    s = @rw.sentence
+  # @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
+  # end
   debug "Total: #{total[:sentences]}s, #{total[:words]}w, #{total[:characters]}c"
 when :paragraphs
   total = {
@@ -305,13 +444,20 @@ 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
+  puts @rw.html(settings)
 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,7 +465,7 @@ 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

data/lib/random-words/array.rb

@@ -0,0 +1,51 @@
+# 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 = []
+      first_names_ended = false
+      each do |line|
+        if line.strip =~ /^[\w-]+$/ && !first_names_ended
+          first_names << line
+        elsif first_names_ended
+          last_names << line
+        else
+          first_names_ended = true
+        end
+      end
+      first_names.delete_if(&:empty?)
+      last_names.delete_if(&:empty?)
+      [first_names, last_names]
+    end
+  end
+end

data/lib/random-words/config.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+module RandomWords
+  # Configuration
+  class Config
+    # Language config files
+    CONFIG_FILES = %w[
+      config
+      numbers
+    ].freeze
+
+    # Parts of speech
+    SPEECH_PARTS = %w[
+      adjectives
+      adverbs
+      articles-plural
+      articles-singular
+      clauses
+      conjunctions-coordinating
+      conjunctions-subordinate
+      nouns-plural
+      nouns-singular
+      prepositions
+      terminators
+      verbs-passive
+      verbs-plural
+      verbs-singular
+    ].freeze
+
+    # Dictionary for source
+    attr_reader :dictionary
+
+    # Source directory for languages
+    attr_reader :source_dir
+
+    # Initialize the config with the given language
+    # @param lang [Symbol] The language to use
+    # @raise [RuntimeError] if no dictionary is found for the given language
+    def initialize(lang)
+      @lang = lang.to_s
+      FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
+
+      @source_dir = user_dictionary_exist? ? user_lang_dir : builtin_lang_dir
+
+      raise "No dictionary found for #{@lang}" unless @source_dir
+
+      rw_source = RandomWords::Source.new(@lang, @source_dir)
+
+      @dictionary = rw_source.dictionary
+
+    end
+
+    # Tests if a uer dictionary exists
+    # @return [Boolean] true if the user dictionary exists, false otherwise
+    # @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)
+
+        true
+      else
+        false
+      end
+    end
+
+    # The user language directory path
+    # @return [String] The path to the user language directory
+    def user_lang_dir
+      File.join(config_dir, 'words', @lang) if File.exist?(File.join(config_dir, 'words', @lang))
+    end
+
+    # The builtin language directory path
+    # @param lang [String] The language to use
+    # @param basedir [String] The base directory to use
+    # @return [String, nil] The path to the builtin language directory or nil if not found
+    def builtin_lang_dir(lang = nil, basedir: nil)
+      lang ||= @lang
+      basedir ||= __dir__
+      dir = File.join(basedir, 'words', lang)
+      return dir if File.directory?(dir)
+
+      warn "No dictionary found for #{lang}"
+      nil
+    end
+
+    # Check if all parts of speech files exist in the given directory
+    # @param dir [String] The directory to check
+    # @param lang [String] The language to check
+    # @return [Boolean] true if all parts of speech files exist, false otherwise
+    def all_parts_of_speech?(dir, lang = nil)
+      lang ||= @lang
+      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
+      end
+      CONFIG_FILES.each do |file|
+        unless File.exist?(File.join(dir, "#{file}.yml"))
+          warn "Missing #{File.join(dir, "#{file}.yml")} for #{lang}"
+          exists = false
+        end
+      end
+      exists
+    end
+
+    # Create a user dictionary for the given language
+    # @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)
+
+      lang_dir = File.join(config_dir, 'words', lang)
+
+      FileUtils.mkdir_p(lang_dir) unless File.directory?(lang_dir)
+      SPEECH_PARTS.each do |part|
+        source_file = File.join(builtin_lang_dir('english'), "#{part}.txt")
+
+        target_file = File.join(lang_dir, "#{part}.txt")
+        unless File.exist?(target_file)
+          FileUtils.cp(source_file, target_file)
+          warn "Created #{part}.txt"
+        end
+      end
+
+      # Copy numbers.yml file from the builtin directory
+      source_file = File.join(builtin_lang_dir('english'), 'numbers.yml')
+      target_file = File.join(lang_dir, 'numbers.yml')
+      unless File.exist?(target_file)
+        FileUtils.cp(source_file, target_file)
+        warn "Created numbers.yml"
+      end
+
+      # Create the config.yml file if it doesn't exist
+      target_file = File.join(lang_dir, "config.yml")
+
+      unless File.exist?(target_file)
+        config = {
+          "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
+      end
+    end
+
+    # List all sources available, builtin and custom
+    # @return [Hash] A hash of source names and their corresponding RandomWords::Source objects
+    def sources
+      return @sources if @sources
+
+      @sources = {}
+      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|
+        next unless File.directory?(dir)
+        name = File.basename(dir)
+        @sources[name] = RandomWords::Source.new(name, dir)
+      end
+      @sources
+    end
+
+    # The base configuration
+    def config
+      @config ||= base_config
+    end
+
+    # private
+
+    # The user configuration directory path
+    # @return [String] The path to the config directory
+    def config_dir
+      @config_dir ||= File.expand_path(File.join(Dir.home, '.config', 'random-words'))
+    end
+
+    # Set the user configuration directory path
+    # @param dir [String] The path to the config directory
+    # @return [String] The path to the config directory
+    def config_dir=(dir)
+      @config_dir = File.expand_path(dir)
+    end
+
+    # Convert a config file's options to regular config
+    # @param configuration [Hash] The configuration hash
+    # @return [Hash] The converted configuration hash
+    def handle_config(configuration)
+      {
+        source: configuration[:source].to_source || :latin,
+        sentence_length: configuration[:length].to_length || :medium,
+        paragraph_length: configuration[:paragraph_length].to_i || 5,
+      }
+    end
+
+    # Return base configuration
+    # @return [Hash] The base configuration
+    def base_config
+      config_file = File.join(config_dir, 'config.yml')
+      if File.exist?(config_file)
+        config = YAML.load_file(config_file).symbolize_keys
+        return handle_config(config)
+      end
+      # If the config file doesn't exist, create it
+      # and return the default configuration
+      create_base_config(config_file)
+      config = YAML.load_file(config_file).symbolize_keys
+      handle_config(config)
+    end
+
+    # Look for a config.yml file in the config directory
+    # @return [String, nil] The path to the config.yml file or nil if not found
+    def config_file
+      config_file = File.join(config_dir, 'config.yml')
+      return config_file if File.exist?(config_file)
+
+      create_base_config(config_file)
+      config_file
+    end
+
+    # Create a base config.yml file if it doesn't exist
+    # @param config_file [String] The path to the config.yml file
+    # @return [String] The path to the config.yml file
+    def create_base_config(config_file)
+      FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
+      config = {
+        "source" => "latin",
+        "length" => "medium",
+        "paragraph_length" => 5,
+      }
+      File.write(config_file, config.to_yaml)
+      warn "Created #{config_file}"
+      config_file
+    end
+  end
+end