random-words 1.0.5 → 1.0.7

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# Original code by Mike Burns
+
+# Copyright 2007 Mike Burns
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+module RandomWords
+  # This class extends the Integer class with methods to convert numbers
+  # into their word representations. It provides methods for converting
+  # numbers to words in various languages, including English.
+  #
+  # @example
+  #   1.to_word # => "one"
+  #   126620.to_word # => "one hundred twenty six thousand six hundred twenty"
+  #
+  class ::Integer
+    # Turn a number into the word representation of that number.
+    #  1.to_word      # => "one"
+    #  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)
+      place = 3 # special-case the tens and below
+      until tmp.zero?
+        final = (tmp % 1000).hundred_to_word(place, numbers) + ' ' + final
+        place += 1
+        tmp /= 1000
+      end
+      final == '' ? 'zero' : final.sub(/\s+$/, '')
+    end
+
+    # For testing edge cases
+    def additional_tests(numbers)
+      teen_to_word(numbers)
+      digit_to_word(numbers)
+      tens_place_to_word(numbers)
+      true
+    end
+
+    protected
+
+    # Convert a number to its word representation for the hundreds place.
+    def hundred_to_word(place = 0, numbers)
+      if zero?
+        ''
+      elsif self < 10
+        append_place(digit_to_word(numbers), place, numbers)
+      elsif self < 20
+        append_place(teen_to_word(numbers), place, numbers)
+      elsif self < 100
+        append_place(tens_place_to_word(numbers), place, numbers)
+      else
+        hundreds = self / 100
+        tens = self % 100
+        if tens.zero?
+          append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]}", place, numbers)
+        else
+          append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]} " + tens.tens_place_to_word(numbers), place,
+                       numbers)
+        end
+      end
+    end
+
+    # Append the appropriate place value to a word based on its position.
+    # @param word [String] The word representation of the number.
+    # @param place [Integer] The place value (e.g., hundreds, thousands).
+    # @param numbers [Hash] A hash containing number words.
+    # @return [String] The word with the appropriate place value appended.
+    def append_place(word, place, numbers)
+      places = numbers[:places]
+      if place > 2
+        word + ' ' + places[place]
+      else
+        word
+      end
+    end
+
+    # Convert a number to its word representation for the tens place.
+    # This is a special case for numbers 20-99.
+    # @param numbers [Hash] A hash containing number words.
+    # @return [String] The word representation of the number.
+    # @example
+    #   45.tens_place_to_word(numbers) # => "forty five"
+    def tens_place_to_word(numbers)
+      if self > 19
+        tens = self / 10
+        ones = self % 10
+        ten = numbers[:tens][tens - 2]
+        ten + (ones.zero? ? '' : ' ' + ones.digit_to_word(numbers))
+      else
+        teen_to_word(numbers)
+      end
+    end
+
+    # Convert a number to its word representation for the teens place.
+    # This is a special case for numbers 10-19.
+    # @param numbers [Hash] A hash containing number words.
+    # @return [String] The word representation of the number.
+    # @example
+    #   12.teen_to_word(numbers) # => "twelve"
+    def teen_to_word(numbers)
+      if self < 10
+        digit_to_word(numbers)
+      elsif self < 20
+        numbers[:teens][self - 10]
+      else
+        tens_place_to_word(numbers)
+      end
+    end
+
+    # Convert a number to its word representation for the digits place.
+    # This is a special case for numbers 0-9.
+    # @param numbers [Hash] A hash containing number words.
+    # @return [String] The word representation of the number.
+    # @example
+    #   5.digit_to_word(numbers) # => "five"
+    def digit_to_word(numbers)
+      if zero?
+        ''
+      else
+        numbers[:digits][self]
+      end
+    end
+  end
+end

data/lib/random-words/source.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+module RandomWords
+  # A class representing a source of words for the RandomWords library.
+  class Source
+    attr_reader :name, :names, :config, :dictionary, :description
+
+    # Initializes a new Source instance.
+    # @param name [Symbol] The name of the source
+    # @param path [String] The path to the source directory
+    def initialize(name, path)
+      @name = name.to_sym
+      @path = path
+      config = IO.read(File.join(path, 'config.yml'))
+      @config = YAML.safe_load(config, aliases: true)
+      @names = @config['triggers'] || [name]
+      @description = @config['description'] || 'No description available'
+      @dictionary = from_files
+      @dictionary[:all_words] = @dictionary.values.flatten.uniq
+      @dictionary[:terminators], @dictionary[:extended_punctuation] = from_file('terminators').split_terminators
+      @dictionary[:first_names], @dictionary[:last_names], @dictionary[:full_names] = from_file('names').split_names
+    rescue StandardError
+      @name = name.to_sym
+      @config = {}
+      @names = [name]
+      @description = 'No description available'
+      @dictionary = from_files
+      @dictionary[:all_words] = @dictionary.values.flatten.uniq
+      @dictionary[:terminators], @dictionary[:extended_punctuation] = from_file('terminators').split_terminators
+      @dictionary[:first_names], @dictionary[:last_names], @dictionary[:full_names] = from_file('names').split_names
+    end
+
+    # def to_sym
+    #   name.to_sym
+    # end
+
+    # Bad init method for testing purposes
+    # @!visibility private
+    def bad_init
+      from_file('nouns-noent.txt')
+    end
+
+    private
+
+    # Load words from all dictionary files
+    # @return [Hash] A hash containing arrays of words for each part of speech
+    # @example
+    #   from_files # Loads words from all dictionary files
+    def from_files
+      {
+        nouns: from_file('nouns-singular'),
+        plural_nouns: from_file('nouns-plural'),
+        verbs: from_file('verbs-singular'),
+        plural_verbs: from_file('verbs-plural'),
+        passive_verbs: from_file('verbs-passive'),
+        adverbs: from_file('adverbs'),
+        adjectives: from_file('adjectives'),
+        articles: from_file('articles-singular'),
+        plural_articles: from_file('articles-plural'),
+        prepositions: from_file('prepositions'),
+        clauses: from_file('clauses'),
+        coordinating_conjunctions: from_file('conjunctions-coordinating'),
+        subordinate_conjunctions: from_file('conjunctions-subordinate'),
+        numbers: from_yaml('numbers'),
+        phrases: from_file('phrases')
+      }
+    end
+
+    # Load words from a dictionary file
+    # Files are plain text with one word or phrase per line
+    # The @source variable defines which dictionary to be used and should be defined before calling this method
+    # @param filename [String] The name of the file to load
+    # @return [Array] An array of words loaded from the file
+    # @example
+    #   from_file('nouns.txt') # Loads words from words/[source]/nouns.txt
+    def from_file(filename)
+      filename = "#{filename.sub(/\.txt$/, '')}.txt"
+      path = File.join(@path, filename)
+
+      File.read(path).strip.split("\n").map(&:strip) # Changed from split_lines to split("\n")
+    rescue Errno::ENOENT
+      warn "File not found: #{path}"
+      []
+    end
+
+    # Load words from a YAML file
+    # @param filename [String] The name of the YAML file to load
+    # @return [Hash] A hash of words loaded from the YAML file
+    def from_yaml(filename)
+      path = File.join(@path, "#{filename}.yml")
+      return {} unless File.exist?(path)
+
+      begin
+        nums = YAML.safe_load(File.read(path), aliases: true).symbolize_keys
+        nums.keys.each do |key|
+          nums[key] = nums[key].split(' ').map(&:strip) if nums[key].is_a?(String)
+        end
+        nums
+      rescue Psych::SyntaxError => e
+        warn "YAML syntax error in #{path}: #{e.message}"
+        {}
+      end
+    end
+  end
+end

data/lib/random-words/string.rb

@@ -1,56 +1,235 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# String extensions for RandomWords
-# This module extends the String class with additional methods for cleaning,
-# compressing, and manipulating strings.
-#
-# @example
-#   str = "  Hello, World!  "
-#   str.clean # => "Hello World"
-#   str.compress # => "Hello World"
-#   str.terminate # => "Hello World."
-#
-class ::String
-  # Remove unwanted characters and whitespace from a string.
-  # @return [String] The string with unwanted characters removed.
-  # @example
-  #   "Hello, World!".clean # => "Hello World"
+module RandomWords
+  # String extensions for RandomWords
+  # This module extends the String class with additional methods for cleaning,
+  # compressing, and manipulating strings.
   #
-  # @return [String] The cleaned string.
-  def clean
-    gsub(/[^-a-zA-Z0-9\s]/, '').strip
-  end
-
-  # Split a string by newlines, clean each line, and remove empty lines.
-  # @return [Array<String>] The string split into lines, cleaned, and empty lines removed.
   # @example
-  #   "Hello, World!\n\nThis is a test.".split_lines # => ["Hello World", "This is a test"]
+  #   str = "  Hello, World!  "
+  #   str.clean # => "Hello World"
+  #   str.compress # => "Hello World"
+  #   str.terminate # => "Hello World."
   #
-  def split_lines
-    strip.split("\n").map(&:clean).reject(&:empty?)
-  end
+  class ::String
+    # Remove unwanted characters and whitespace from a string.
+    # @return [String] The string with unwanted characters removed.
+    # @example
+    #   "Hello, World!".clean # => "Hello World"
+    #
+    # @return [String] The cleaned string.
+    def clean
+      gsub(/[^-a-zA-Z0-9\s]/, '').strip
+    end
 
-  # Compress multiple spaces into a single space and remove leading/trailing spaces.
-  # @return [String] The string with extra spaces compressed.
-  def compress
-    gsub(/\s+/, ' ').strip
-  end
+    # Captialize instances of "i" in a string.
+    # @return [String] The string with "i" capitalized.
+    # @example
+    #   "this is an i".capitalize_i # => "this is an I"
+    # @example
+    #   "this is an iPhone".capitalize_i # => "this is an iPhone"
+    #
+    def capitalize_i
+      gsub(/\bi\b/, 'I')
+    end
 
-  # Terminate a string with a random punctuation mark.
-  # @return [String] The string with a random punctuation mark at the end.
-  # @example
-  #   "Hello World".terminate # => "Hello World."
-  #
-  def terminate
-    terminators = %w[. . . ! ! ?]
-    terminator = terminators.sample
-    sub(/[.!?;,-]*$/, terminator)
-  end
+    # Capitalize the first letter of a string, respcting punctuation.
+    # @return [String] The string with the first letter capitalized.
+    # @example
+    #  "hello world".capitalize # => "Hello world"
+    def capitalize
+      return self if empty?
+
+      letters = split('')
+      string = []
+      string << letters.shift while letters[0] !~ /[[:word:]]/
+      string << letters.shift.upcase
+      string.concat(letters)
+      string.join('')
+    end
+
+    # Downcase the first letter of a string, respecting punctuation.
+    # @return [String] The string with the first letter downcased.
+    def downcase_first
+      return self if empty?
+
+      letters = split('')
+      string = []
+      string << letters.shift while letters[0] !~ /[[:word:]]/
+      string << letters.shift.downcase
+      string.concat(letters)
+      string.join('')
+    end
+
+    # Capitalize the first letter of each sentence in a string.
+    # Scans for all known terminators followed by a space and capitalizes the next letter.
+    # @param terminators [Array<Array>] An array of beginning and ending punctuation mark arrays.
+    # @return [String] The string with the first letter of each sentence capitalized.
+    # @example
+    #   "hello world. this is a test.".fix_caps([[".", "."]]) # => "Hello world. This is a test."
+    #
+    def fix_caps(terminators)
+      return self if empty?
+
+      terminator_ends = terminators.map { |t| t[1].split('').last }.delete_if(&:empty?)
+      return capitalize if terminator_ends.empty?
+
+      terminator_regex = Regexp.new("[#{Regexp.escape(terminator_ends.join)}]")
+      return capitalize unless self =~ terminator_regex
+
+      split(/(?<=#{terminator_regex}) /).map do |sentence|
+        sentence.capitalize
+      end.join(' ')
+    end
+
+    # Remove duplicate commas
+    # @return [String] The string with duplicate commas removed.
+    # @example
+    #  "Hello, , World!".remove_duplicate_commas # => "Hello, World!"
+    def dedup_commas
+      gsub(/(, *)+/, ',').gsub(',', ', ')
+    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)
+    end
+
+    # Split a string by newlines, clean each line, and remove empty lines.
+    # @return [Array<String>] The string split into lines, cleaned, and empty lines removed.
+    # @example
+    #   "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?)
+    end
+
+    # Compress multiple spaces into a single space and remove leading/trailing spaces.
+    # @return [String] The string with extra spaces compressed.
+    def compress
+      gsub(/\s+/, ' ').strip
+    end
+
+    # Terminate a string with a random punctuation mark.
+    # @param terminator [Array<String>] An array of beginning and ending punctuation marks.
+    # @return [String] The string with a random punctuation mark at the end.
+    # @example
+    #   "Hello World".terminate(["", "."]) # => "Hello World."
+    #
+    def terminate(terminator)
+      sub(/^/, terminator[0]).sub(/[^a-zA-Z0-9]*$/, terminator[1])
+    end
+
+    # Remove any punctuation mark from the end of a string.
+    # @return [String] The string with the last punctuation mark removed.
+    def no_term(terminators)
+      str = dup
+      leading = terminators.map { |t| t[0] }.delete_if(&:empty?).join
+      trailing = terminators.map { |t| t[1] }.delete_if(&:empty?).join
+      return self if leading.empty? && trailing.empty?
+
+      str.sub!(/^[#{Regexp.escape(leading)}]/, '') unless leading.empty?
+
+      str.sub!(/[#{Regexp.escape(trailing)}]+$/, '') unless trailing.empty?
+
+      str
+    end
+
+    # Indent every line in a string with a specified string.
+    # @param [String] string The string to indent with.
+    # @return [String] The indented string.
+    def indent(string)
+      gsub(/^/, string)
+    end
+
+    # Capitalize the first letter of a string.
+    # @return [String] The string with the first letter capitalized.
+    def cap_first
+      # Capitalizes the first letter of a string.
+      self[0] = self[0].upcase
+      self
+    end
+
+    # Add a specified character to the end of a string, avoiding repeated punctuation.
+    # @param [String] char The character to add (default: '.').
+    # @return [String] The string with the specified character at the end.
+    def term(char = '.')
+      # Adds a specified character to the end of a string.
+      sub(/[.?!,;]?$/, "#{char}")
+    end
+
+    # Remove extra newlines from the output.
+    # @return [String] The string with extra newlines removed.
+    def compress_newlines
+      # Removes extra newlines from the output.
+      gsub(/\n{2,}/, "\n\n").strip
+    end
+
+    # Compress newlines in the output, destructive.
+    # @see #compress_newlines
+    # @return [String] The string with newlines compressed.
+    def compress_newlines!
+      # Removes extra newlines from the output.
+      replace compress_newlines
+    end
+
+    # Preserve spaces in the output by replacing multiple spaces with %%.
+    # @return [String] The string with spaces preserved.
+    def preserve_spaces
+      # Preserves spaces in the output.
+      gsub(/ +/, '%%')
+    end
+
+    # Restore spaces in the output by replacing %% with spaces.
+    # @return [String] The string with spaces restored.
+    def restore_spaces
+      # Restores spaces in the output.
+      gsub('%%', ' ')
+    end
+
+    # Check if the string is trueish (starts with 't', 'y', or '1').
+    # @return [Boolean] true if the string is trueish, false otherwise.
+    def trueish?
+      to_s =~ /^[ty1]/i
+    end
+
+    # Convert the string to a source symbol based on its name.
+    # @return [Symbol] The symbolized name of the source.
+    def to_source
+      new_source = nil
+      sources = RandomWords::Generator.new.sources
+
+      sources.each do |_k, v|
+        v.names.each do |name|
+          next unless name.to_s =~ /^#{self}/i
+
+          new_source = v.name
+          break
+        end
+        break if new_source
+      end
+
+      new_source || :latin
+    end
 
-  # Remove any punctuation mark from the end of a string.
-  # @return [String] The string with the last punctuation mark removed.
-  def no_term
-    sub(/[.!?;,-]*$/, '')
+    # Convert the string to a length symbol based on its name.
+    # @return [Symbol] The symbolized length of the string.
+    def to_length
+      case self
+      when /^s/i
+        :short
+      when /^m/i
+        :medium
+      when /^l/i
+        :long
+      when /^v/i
+        :very_long
+      else
+        :medium
+      end
+    end
   end
 end