spoonerize 0.1.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb11ac34b545af8dd6a68950c95de9617c0b54995e5fb9b0ae55f3613d18be22
-  data.tar.gz: 5b60db2501c97458406205884f985e2b07a93a5e7a78b891daedcda45c687d33
+  metadata.gz: 1b4c993b75b971449d8795c0666e4645bee48ff903afaea84463025da44ffdbf
+  data.tar.gz: b57070d3e1dc670ef4cdf17f9657c8759828e86a039571d305a6d6716aaa5b65
 SHA512:
-  metadata.gz: 1b9c899c14a35ae01d4aaa857f174427acaf91dbdad28a913c57b8e542e7fa33756f5e991c76cf5c978334280b2cd3217c32ef4749e52b2acfc5ed5f9de65cf6
-  data.tar.gz: 0e6c20e84abfb81cd4098f42ee9e5f1907e11c5e62827340885106cce38717dc770acdf21df087da9fcc81235e78bee60f4da05cffbdb3ee07a0b5395f4b7e9a
+  metadata.gz: ccf19838d1a10609dddbd2da4cfe8286c548b9bc91e2b957ee592120225305c93a166da7ae10c34ead80a402f8cb767fbb192162fade18afc046298ff3d5dd1c
+  data.tar.gz: 3420c7dc81ea682e3388b9f9097a6c538199cbb38e2f5179e3a5f68f8200b278674da04397df05e14a259ad6ba5878daf3b63390f244a3988c3678f08e8b85a3

data/Gemfile.lock

@@ -1,28 +1,74 @@
 PATH
   remote: .
   specs:
-    spoonerize (0.1.3)
+    spoonerize (1.0.0)
       csv
 
 GEM
   remote: https://rubygems.org/
   specs:
+    ast (2.4.3)
     csv (3.3.5)
     date (3.5.1)
     erb (6.0.4)
+    json (2.20.0)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    parallel (1.28.0)
+    parser (3.3.11.1)
+      ast (~> 2.4.1)
+      racc
     power_assert (3.0.1)
+    prism (1.9.0)
     psych (5.4.0)
       date
       stringio
+    racc (1.8.1)
+    rainbow (3.1.1)
     rake (13.4.2)
     rdoc (7.2.0)
       erb
       psych (>= 4.0.0)
       tsort
+    regexp_parser (2.12.0)
+    rubocop (1.84.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-performance (1.26.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.47.1, < 2.0)
+    ruby-progressbar (1.13.0)
+    standard (1.54.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.84.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.8)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.9.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.26.0)
     stringio (3.2.0)
     test-unit (3.7.8)
       power_assert
     tsort (0.2.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
 
 PLATFORMS
   arm64-darwin-25
@@ -33,6 +79,7 @@ DEPENDENCIES
   rake (~> 13.0, >= 13.0.1)
   rdoc
   spoonerize!
+  standard (= 1.54.0)
   test-unit (~> 3.3, >= 3.3.5)
 
 BUNDLED WITH

data/README.md

@@ -26,6 +26,8 @@ consonants, but will still lose its own if it has any.
 - If the word to pull from is excluded, that word is skipped, and you pull the
 leading consonants from the next non-excluded word.
 - "Q" and "U" should stay together (like "queen").
+- "Y" is treated like a leading consonant by itself or before a vowel sound
+(like "yellow"), but like a leading vowel before a consonant (like "yttrium").
 - A lot of the time, the words won't look how they're supposed to sound, as you
 go by how the word *used* to sound, not how it's spelled. For instance,
 `$ spoonerize two new cuties` becomes "no cew twuties", but it would be
@@ -40,7 +42,7 @@ Just install the gem!
 gem install spoonerize
 ```
 
-If you don't have permission on your system to install ruby or gems, I recommend
+If you don't have permission on your system to install Ruby or gems, I recommend
 using
 [rbenv](http://www.rubyinside.com/rbenv-a-simple-new-ruby-version-management-tool-5302.html),
 or you can try the manual methods below.
@@ -82,10 +84,12 @@ get the results. For example:
 
 ```
 $ spoonerize -s not too shabby
-Saving [tot shoo nabby] to ~/.cache/spoonerize/spoonerize.csv
+tot shoo nabby
+Saving...
 
 $ spoonerize -rs not too shabby
-Saving [shot noo tabby] to ~/.cache/spoonerize/spoonerize.csv
+shot noo tabby
+Saving...
 
 $ spoonerize -p
 not too shabby | tot shoo nabby | No Options
@@ -97,72 +101,90 @@ Here is a list of all available options:
 ```
 -r, --[no-]reverse               Reverse flipping
 -l, --[no-]lazy                  Skip small words
+-c, --[no-]consonants-only       Only flip consonant-starting words
 -m, --[no-]map                   Print words mapping
--p, --[no-]print                 Print all entries in the log
+-p, --[no-]print-log             Print all entries in the log
 -s, --[no-]save                  Save results in log
-    --exclude=WORDS              Words to skip
+    --exclude=WORD               Words to skip
 ```
 
 ### Config File
-You can create a config file called `~/.spoonerize.yml`. In this file, you can
-change default options at runtime. Available settings are:
-
-```yaml
-# Setting       Default
-excluded_words: []
-lazy:           false
-reverse:        false
-logfile_name:   '~/.cache/spoonerize/spoonerize.csv'
+You can create a Ruby config file called `~/.spoonerizerc`. The CLI loads this
+file automatically before it parses command-line options, so options set in the
+file can still be overridden at runtime by executable flags.
+
+```ruby
+Spoonerize.configure do |config|
+  config.excluded_words = []
+  config.lazy = false
+  config.consonants_only = false
+  config.reverse = false
+  config.logfile_name = File.expand_path("~/.cache/spoonerize/spoonerize.csv")
+end
 ```
 
-Options set by this file can be overridden at runtime by the use of the
-executable's flags.
+Because the file is Ruby, you can set only the values you want to change.
 
 ## API
 The API is [fully
 documented](https://evanthegrayt.github.io/spoonerize/), but below
-are some quick examples of how you could use this in your ruby code.
+are some quick examples of how you could use this in your Ruby code.
 
 ```ruby
 require 'spoonerize'
 
-spoonerism = Spoonerize::Spoonerism.new(%w[not too shabby]) do |s|
-  s.reverse = true
-end
+spoonerism = Spoonerize::Spoonerism.new("not", "too", "shabby")
+
+spoonerism.to_s
+# => tot shoo nabby
 
-spoonerism.spoonerize
+reversed = Spoonerize::Spoonerism.new("not", "too", "shabby", reverse: true)
+reversed.to_s
 # => shot noo tabby
 
-spoonerism.reverse = false
-spoonerism.spoonerize
-# => tot shoo nabby
+Spoonerize.configure do |config|
+  config.logfile_name = File.expand_path("~/.cache/spoonerize/spoonerize.csv")
+end
+Spoonerize::Spoonerism.new("not", "too", "shabby").save
+```
 
-spoonerism.logfile_name = '~/.cache/spoonerize/spoonerize.csv'
-spoonerism.save
+To leave vowel-starting words alone, enable consonants-only mode:
+
+```ruby
+Spoonerize::Spoonerism.new("turn", "up", "son", consonants_only: true).to_s
+# => surn up ton
 ```
 
-You can also use the [config file](#config-file), either by passing it at
-initialization, or via the setter. The config file will be automatically loaded
-if passed at initialization, before the instance is yielded so you can still
-change the values via the block. If set via the setter, you must call
-`#load_config_file`.
+You can also configure global defaults before creating a spoonerism:
 
 ```ruby
-# Config file would be automatically loaded before block is executed.
-s = Spoonerise::Spoonerism.new(%w[not too shabby], '~/.spoonerize.yml') do |sp|
-  sp.reverse = true
+Spoonerize.configure do |config|
+  config.reverse = true
 end
 
-# Config file would need to be manually loaded.
-s = Spoonerise::Spoonerism.new(%w[not too shabby]) do |sp|
-  sp.config_file = '~/.spoonerize.yml'
-end
+s = Spoonerize::Spoonerism.new("not", "too", "shabby")
+s.spoonerize
+# => shot noo tabby
+```
+
+Options passed directly to `Spoonerize::Spoonerism.new` only apply to that
+instance.
+
+Passing words as an array is deprecated and will be removed in Spoonerize 1.0:
 
-s.load_config_file
+```ruby
+Spoonerize::Spoonerism.new(%w[not too shabby])
+```
+
+Or load a config file manually:
+
+```ruby
+Spoonerize.load_config_file("~/.spoonerizerc")
+s = Spoonerize::Spoonerism.new("not", "too", "shabby")
 ```
 
 ## Self Promotion
 I do these projects for fun, and I enjoy knowing that they're helpful to people.
 Consider starring [the repository](https://github.com/evanthegrayt/spoonerize)
 if you like it! If you love it, follow me [on
-github](https://github.com/evanthegrayt)!
+GitHub](https://github.com/evanthegrayt)!

data/Rakefile

@@ -4,6 +4,7 @@ require_relative "lib/spoonerize"
 require "bundler/gem_tasks"
 require "rdoc/task"
 require "rake/testtask"
+require "standard/rake"
 
 Rake::TestTask.new do |t|
   t.libs = ["lib"]
@@ -64,4 +65,3 @@ namespace :version do
     end
   end
 end
-

data/lib/spoonerize/bumper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Spoonerize
   ##
   # Class that handles bumping an index.

data/lib/spoonerize/cli.rb

@@ -1,16 +1,16 @@
+# frozen_string_literal: true
+
 require "optparse"
-require "yaml"
 
 module Spoonerize
   ##
   # The class for handling the command-line interface.
   class Cli
     ##
-    # The preferences file the user can create to change runtime options.
+    # The config file the user can create to change default runtime options.
     #
     # @return [String]
-    PREFERENCE_FILE =
-      File.expand_path(File.join(ENV["HOME"], ".spoonerize.yml")).freeze
+    CONFIG_FILE = File.expand_path(File.join(ENV["HOME"], ".spoonerizerc"))
 
     ##
     # Creates an instance of +Spoonerism+ and runs what the user requested.
@@ -19,7 +19,7 @@ module Spoonerize
     def self.execute(options = [])
       exe = new(options)
 
-      if exe.print?
+      if exe.print_log?
         exe.print_log
         return
       end
@@ -40,10 +40,10 @@ module Spoonerize
     attr_reader :options
 
     ##
-    # Preferences after reading config file and parsing ARGV.
+    # Overrides after reading config file and parsing ARGV.
     #
-    # @return [Array]
-    attr_reader :preferences
+    # @return [Hash]
+    attr_reader :overrides
 
     ##
     # Create instance of +Cli+
@@ -52,23 +52,20 @@ module Spoonerize
     #
     # @return [self]
     def initialize(options)
+      Spoonerize.load_config_file(CONFIG_FILE) if File.file?(CONFIG_FILE)
       @map = false
       @save = false
-      @print = false
+      @print_log = false
       @options = options
-      @preferences = get_preferences
+      @overrides = get_overrides
     end
 
     ##
-    # Sets up an instance of +Spoonerize::Spoonerism+ and passes all user
-    # preferences.
+    # Sets up an instance of +Spoonerize::Spoonerism+
     #
     # @return [Spoonerize::Spoonerism]
     def spoonerism
-      pf = File.file?(PREFERENCE_FILE) ? PREFERENCE_FILE : nil
-      @spoonerism ||= Spoonerism.new(options, pf) do |s|
-        preferences.each { |k, v| s.send(:"#{k}=", v) }
-      end
+      @spoonerism ||= Spoonerism.new(*options, **overrides)
     end
 
     ##
@@ -91,8 +88,8 @@ module Spoonerize
     # Should we print to the command line?
     #
     # @return [Boolean]
-    def print?
-      @print
+    def print_log?
+      @print_log
     end
 
     ##
@@ -100,8 +97,7 @@ module Spoonerize
     #
     # @return [Integer]
     def longest_word_length
-      @longest_word_length ||=
-        spoonerism.spoonerize.group_by(&:size).max.first.size
+      @longest_word_length ||= spoonerism.spoonerize.max_by(&:size).size
     end
 
     ##
@@ -109,8 +105,9 @@ module Spoonerize
     #
     # @return [nil]
     def print_log
-      s = Spoonerize::Log.new(spoonerism.logfile_name)
-      s.each { |row| print row.join(" | ") + "\n" }
+      Spoonerize::Log.new(Spoonerize.config.logfile_name).each do |row|
+        puts row.join(" | ")
+      end
     end
 
     ##
@@ -119,7 +116,7 @@ module Spoonerize
     # @return [nil]
     def print_mappings
       spoonerism.to_h.each do |k, v|
-        printf("%-#{longest_word_length}s => %s\n", k, v)
+        printf("%-#{longest_word_length + 1}s => %s\n", k, v)
       end
     end
 
@@ -127,27 +124,30 @@ module Spoonerize
 
     ##
     # Read in args and set options
-    def get_preferences # :nodoc:
+    def get_overrides # :nodoc:
       {}.tap do |prefs|
         OptionParser.new do |o|
           o.version = ::Spoonerize::Version.to_s
           o.on("-r", "--[no-]reverse", "Reverse flipping") do |v|
-            prefs["reverse"] = v
+            prefs[:reverse] = v
           end
           o.on("-l", "--[no-]lazy", "Skip small words") do |v|
-            prefs["lazy"] = v
+            prefs[:lazy] = v
+          end
+          o.on("-c", "--[no-]consonants-only", "Only flip consonant-starting words") do |v|
+            prefs[:consonants_only] = v
           end
           o.on("-m", "--[no-]map", "Print words mapping") do |v|
             @map = v
           end
-          o.on("-p", "--[no-]print", "Print all entries in the log") do |v|
-            @print = v
+          o.on("-p", "--[no-]print-log", "Print all entries in the log") do |v|
+            @print_log = v
           end
           o.on("-s", "--[no-]save", "Save results in log") do |v|
             @save = v
           end
           o.on("--exclude=WORD", Array, "Words to skip") do |v|
-            prefs["exclude"] = v
+            prefs[:excluded_words] = v
           end
         end.parse!(options)
       end

data/lib/spoonerize/config.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Spoonerize
+  class Config
+    ##
+    # Lazy mode. If true, words in +lazy_words+ will not be altered.
+    #
+    # @return [Boolean]
+    attr_accessor :lazy
+
+    ##
+    # Words to skip when +lazy+ is true.
+    #
+    # @return [Array]
+    attr_accessor :lazy_words
+
+    ##
+    # Words that should not be altered.
+    #
+    # @return [Array]
+    attr_accessor :excluded_words
+
+    ##
+    # When true, only consonant-starting words are eligible to be flipped.
+    #
+    # @return [Boolean]
+    attr_accessor :consonants_only
+
+    ##
+    # When true, reverse the order of the flipping. Only makes a difference
+    # when there are more than two flip-able words.
+    #
+    # @return [Boolean]
+    attr_accessor :reverse
+
+    ##
+    # Name of the log file. Should be a fully-qualified file path.
+    #
+    # @return [String]
+    attr_accessor :logfile_name
+
+    ##
+    # Create instance of Config.
+    #
+    # @return [Spoonerize::Config]
+    def initialize
+      @lazy = false
+      @lazy_words = %w[i a an and in of the my your his her him hers to is]
+      @excluded_words = []
+      @consonants_only = false
+      @reverse = false
+      @logfile_name = File.expand_path(
+        File.join(ENV["HOME"], ".cache", "spoonerize", "spoonerize.csv")
+      )
+    end
+
+    ##
+    # Create a copy of the current config with optional overrides.
+    #
+    # @return [Spoonerize::Config]
+    def with(**overrides)
+      self.class.new.tap do |config|
+        config.lazy = lazy
+        config.lazy_words = lazy_words.dup
+        config.excluded_words = excluded_words.dup
+        config.consonants_only = consonants_only
+        config.reverse = reverse
+        config.logfile_name = logfile_name
+
+        overrides.each do |key, value|
+          config.public_send(:"#{key}=", copy_value(value))
+        end
+      end
+    end
+
+    private
+
+    def copy_value(value)
+      value.is_a?(Array) ? value.dup : value
+    end
+  end
+end

data/lib/spoonerize/log.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "csv"
 require "fileutils"
 
 module Spoonerize
   ##
-  # Class that handles reading/writing logs.
+  # Class that handles reading/writing logs. Log file is stored as a simple CSV.
   class Log
     ##
     # The file name to use.
@@ -51,7 +53,7 @@ module Spoonerize
     ##
     # Iterate through each line of the file.
     #
-    # @return [Array]
+    # @return [Enumerable]
     def each
       contents.each { |row| yield row }
     end

data/lib/spoonerize/spoonerism.rb

@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 module Spoonerize
   ##
   # The main word-flipper.
   class Spoonerism
+    VOWEL_LETTERS = "aeio"
+    CONSONANT_LETTERS = "bcdfghjklmnprstvwxz"
+    Y_FOLLOWING_CONSONANTS = "bcdfghjklmnpqrstvwxz"
+
     ##
     # The words originally passed at initialization.
     #
@@ -9,224 +15,235 @@ module Spoonerize
     attr_reader :words
 
     ##
-    # This boolean determines if flipping should be performed lazily.
-    #
-    # @param [Boolean] true if should be lazy.
-    #
-    # @return [Boolean]
-    attr_writer :lazy
-
-    ##
-    # This boolean determines if flipping should be reversed.
-    #
-    # @param [Boolean] true if should be reversed.
-    #
-    # @return [Boolean]
-    attr_writer :reverse
-
-    ##
-    # The full path to the log file.
-    #
-    # @param [String] file
-    #
-    # @return [String]
-    attr_accessor :logfile_name
-
-    ##
-    # The words that are to be excluded.
-    #
-    # @param [Array] words
-    #
-    # @return [Array]
-    attr_accessor :excluded_words
-
-    ##
-    # The configuration file. Default is +nil+. If set to a string, and the file
-    # exists, it is used to set options.
+    # Configuration values for this spoonerism.
     #
-    # @return [String] file path
-    attr_reader :config_file
-
-    ##
-    # The options from +config_file+ as a hash.
-    #
-    # @return [Hash] Options from +config_file+
+    # @return [Spoonerize::Config]
     attr_reader :config
 
     ##
-    # Initialize instance. You can also use the +config_file+ either by passing
-    # it at initialization, or via the setter. The config file will be
-    # automatically loaded if passed at initialization, before the instance is
-    # yielded so you can still change the values via the block. If set via the
-    # setter, you must call `#load_config_file`.
-    #
-    # @param [Array] words
-    #
-    # @param [String] config_file
-    #
-    # @example
-    #  # Config file would be automatically loaded before block is executed.
-    #  s = Spoonerise::Spoonerism.new(%w[not too shabby], '~/.spoonerize.yml') do |sp|
-    #    sp.reverse = true # Would override setting from config file
-    #  end
-    #  # Config file would need to be manually loaded.
-    #  s = Spoonerise::Spoonerism.new(%w[not too shabby]) do |sp|
-    #    sp.config_file = '~/.spoonerize.yml'
-    #    sp.reverse = true
-    #  end
-    #  s.load_config_file # Would override setting from initialization
-    def initialize(words, config_file = nil)
-      @config = {}
-      @excluded_words = []
-      @words = words.map(&:downcase)
-      @lazy = false
-      @reverse = false
-      @config_file = config_file && File.expand_path(config_file)
-      @config_file_loaded = false
-      @logfile_name = File.expand_path(
-        File.join(ENV["HOME"], ".cache", "spoonerize", "spoonerize.csv")
-      )
-
-      load_config_file if config_file
-
-      yield self if block_given?
+    # Initialize instance.
+    #
+    # @param [Array<String>] words Words to spoonerize. Passing a single array
+    #   is deprecated and will be removed in Spoonerize 1.0.
+    # @param [Spoonerize::Config] config Base config to copy.
+    # @param [Boolean, nil] lazy Override lazy mode for this instance.
+    # @param [Array<String>, nil] lazy_words Override lazy words for this instance.
+    # @param [Array<String>, nil] excluded_words Override excluded words for this instance.
+    # @param [Boolean, nil] consonants_only Override consonants-only mode for this instance.
+    # @param [Boolean, nil] reverse Override reverse mode for this instance.
+    # @param [String, nil] logfile_name Override the log file path for this instance.
+    #
+    # @return [Spoonerize::Spoonerism]
+    def initialize(
+      *words,
+      config: Spoonerize.config,
+      lazy: nil,
+      lazy_words: nil,
+      excluded_words: nil,
+      consonants_only: nil,
+      reverse: nil,
+      logfile_name: nil
+    )
+      @words = normalize_words(words).map(&:downcase)
+      @config = config.with(**{
+        lazy: lazy,
+        lazy_words: lazy_words,
+        excluded_words: excluded_words,
+        consonants_only: consonants_only,
+        reverse: reverse,
+        logfile_name: logfile_name
+      }.reject { |_, value| value.nil? })
     end
 
     ##
     # Iterates through words array, and maps its elements to the output of
-    # flip_words. Returns results as an array.
+    # flip_words.
+    #
+    # @return [Array]
     def spoonerize
-      raise JakPibError, "Not enough words to flip" unless enough_flippable_words?
+      raise "Not enough words to flip" unless enough_flippable_words?
 
       words.map.with_index { |word, idx| flip_words(word, idx) }
     end
 
     ##
-    # Returns spoonerize array as a joined string.
+    # Spoonerized results as a joined string.
+    #
+    # @return [String]
     def to_s
       spoonerize.join(" ")
     end
 
     ##
-    # Returns hash of the original words mapped to their flipped counterparts.
+    # Spoonerized results as a joined hash.
+    #
+    # @return [Hash]
     def to_h
       words.zip(spoonerize).to_h
     end
 
     ##
     # Same as to_h, but as json.
+    #
+    # @return [String]
     def to_json
       to_h.to_json
     end
 
     ##
-    # Has a config file been loaded?
+    # True if there are more than one non-excluded word to flip
     #
     # @return [Boolean]
-    def config_file_loaded?
-      @config_file_loaded
+    def enough_flippable_words?
+      words.each_index.count { |index| flippable?(index) } > 1
     end
 
     ##
-    # Returns true if there are more than one non-excluded word to flip
-    def enough_flippable_words?
-      (words - all_excluded_words).size > 1
+    # Saves the flipped words to the log file, along with the options
+    #
+    # @return [Array]
+    def save
+      log.write([words.join(" "), to_s, options.join(", ")])
     end
 
     ##
-    # Should the lazy words be excluded?
-    def lazy?
-      @lazy
+    # Array of words to exclude by combining two arrays:
+    # * Any user-passed words, stored in +config.excluded_words+
+    # * Any lazy words, if lazy mode is true
+    #
+    # @return [Array]
+    def all_excluded_words
+      (config.excluded_words + (
+        config.lazy ? config.lazy_words : []
+      )).map(&:downcase)
+    end
+
+    private
+
+    def normalize_words(words)
+      if words.size == 1 && words.first.is_a?(Array)
+        warn(
+          "Passing words as an array is deprecated and will be removed in Spoonerize 1.0. " \
+          "Pass words as positional arguments instead."
+        )
+        words = words.first
+      end
+
+      unless words.all? { |word| word.is_a?(String) }
+        raise ArgumentError, "Words must be strings"
+      end
+
+      words
     end
 
     ##
-    # Should the words flip the other direction?
-    def reverse?
-      @reverse
+    # Main flipping method. Creates the replacement word from the next
+    # non-excluded word's leading consonants, and the current word's first
+    # vowel sound through the end of the word.
+    def flip_words(word, idx) # :nodoc:
+      return word unless flippable?(idx)
+
+      bumper = Bumper.new(idx, words.size, config.reverse)
+      bumper.bump until flippable?(bumper.value)
+      leading_consonants(words[bumper.value]) + retained_suffix(word)
     end
 
     ##
-    # Saves the flipped words to the log file, along with the options
-    def save
-      log.write([words.join(" "), to_s, options.join(", ")])
+    # Returns true if word[index] is in the excluded_words array
+    def excluded?(index) # :nodoc:
+      all_excluded_words.include?(words[index])
     end
 
     ##
-    # Returns an array of words to exclude by combining three arrays:
-    # * Any word in the passed arguments that's only one character
-    # * Any user-passed words, stored in +excluded_words+
-    # * If lazy-mode, the LAZY_WORDS from yaml file are added
-    def all_excluded_words
-      (excluded_words + (lazy? ? LAZY_WORDS : [])).map(&:downcase)
+    # Returns true if word[index] can participate in a spoonerism.
+    def flippable?(index) # :nodoc:
+      return false if excluded?(index)
+
+      !config.consonants_only || consonant_sound_start?(words[index])
     end
 
     ##
-    # Setter for +config_file+. Must be expanded in case the user uses `~` for
-    # home.
-    #
-    # @param [String] file
-    #
-    # @return [String]
-    def config_file=(config_file)
-      @config_file = File.expand_path(config_file)
+    # Returns true when a word starts with a consonant sound.
+    def consonant_sound_start?(word) # :nodoc:
+      return false if word.empty?
+
+      !vowel_sound_at?(word, 0)
     end
 
     ##
-    # Loads the config file
-    #
-    # @return [Hash] The config options
-    def load_config_file
-      raise "No config file set" if config_file.nil?
-      raise "File #{config_file} does not exist" unless File.file?(config_file)
-      @config = YAML.load_file(config_file)
-      @config_file_loaded = true
-      @config.each { |k, v| send(:"#{k}=", v) }
+    # Returns the consonant group a word contributes to another word.
+    def leading_consonants(word) # :nodoc:
+      return "qu" if word.start_with?("qu")
+      return "y" if initial_y_consonant?(word)
+
+      index = word.length.times.find do |letter_index|
+        !CONSONANT_LETTERS.include?(word[letter_index])
+      end
+
+      index ? word[0...index] : word
     end
 
-    private
+    ##
+    # Returns the part of a word kept after dropping its leading consonants.
+    def retained_suffix(word) # :nodoc:
+      index = first_vowel_sound_index(word)
+
+      index ? word[index..] : ""
+    end
 
     ##
-    # Main flipping method. Creates the replacement word from the next
-    # non-excluded word's leading syllables, and the current word's first vowels
-    # through the end of the word.
-    def flip_words(word, idx) # :nodoc:
-      return word if excluded?(idx)
-      bumper = Bumper.new(idx, words.size, reverse?)
-      bumper.bump while excluded?(bumper.value)
-      words[bumper.value].match(consonants).to_s + word.match(vowels).to_s
+    # Returns the first index where a word starts sounding vowel-like.
+    def first_vowel_sound_index(word) # :nodoc:
+      word.length.times.find { |index| vowel_sound_at?(word, index) }
     end
 
     ##
-    # Returns true if word[index] is in the excluded_words array
-    def excluded?(index) # :nodoc:
-      all_excluded_words.include?(words[index])
+    # Returns true when the letter at index starts a vowel sound.
+    def vowel_sound_at?(word, index) # :nodoc:
+      letter = word[index]
+
+      VOWEL_LETTERS.include?(letter) ||
+        (letter == "u" && word[index - 1] != "q") ||
+        y_vowel_sound_at?(word, index)
     end
 
     ##
-    # Returns regex to match first vowels through the rest of the word
-    def vowels # :nodoc:
-      /((?<!q)u|[aeio]|(?<=[bcdfghjklmnprstvwxz])y).*$/
+    # Initial y is vowel-like before a consonant; later y is vowel-like after a
+    # consonant.
+    def y_vowel_sound_at?(word, index) # :nodoc:
+      return false unless word[index] == "y"
+
+      if index.zero?
+        next_letter = word[index + 1]
+
+        next_letter && Y_FOLLOWING_CONSONANTS.include?(next_letter)
+      else
+        CONSONANT_LETTERS.include?(word[index - 1])
+      end
     end
 
     ##
-    # Returns regex to match leading consonants
-    def consonants # :nodoc:
-      /^(y|[bcdfghjklmnprstvwxz]+|qu)/
+    # Initial y is consonant-like by itself or before a vowel sound.
+    def initial_y_consonant?(word) # :nodoc:
+      word == "y" || (word.start_with?("y") && vowel_sound_at?(word, 1))
     end
 
     ##
     # Creates and memoizes instance of the log file.
     def log # :nodoc:
-      @log ||= Spoonerize::Log.new(logfile_name)
+      @log ||= Spoonerize::Log.new(config.logfile_name)
     end
 
     ##
-    # the options as a string
+    # The options that were passed at runtime as a string
     def options # :nodoc:
       [].tap do |o|
-        o << "Lazy" if lazy?
-        o << "Reverse" if reverse?
-        o << "Exclude [#{all_excluded_words.join(", ")}]" if excluded_words.any?
+        o << "Lazy" if config.lazy
+        o << "Consonants Only" if config.consonants_only
+        o << "Reverse" if config.reverse
+        if config.excluded_words.any?
+          o << "Exclude [#{config.excluded_words.join(", ")}]"
+        end
         o << "No Options" if o.empty?
       end
     end

data/lib/spoonerize/version.rb

@@ -9,19 +9,19 @@ module Spoonerize
     # Major version.
     #
     # @return [Integer]
-    MAJOR = 0
+    MAJOR = 1
 
     ##
     # Minor version.
     #
     # @return [Integer]
-    MINOR = 1
+    MINOR = 0
 
     ##
     # Patch version.
     #
     # @return [Integer]
-    PATCH = 3
+    PATCH = 0
 
     module_function
 

data/lib/spoonerize.rb

@@ -1,4 +1,6 @@
-require "yaml"
+# frozen_string_literal: true
+
+require_relative "spoonerize/config"
 require_relative "spoonerize/spoonerism"
 require_relative "spoonerize/bumper"
 require_relative "spoonerize/version"
@@ -9,12 +11,57 @@ require_relative "spoonerize/cli"
 # The main namespace for the gem.
 module Spoonerize
   ##
-  # The error exception raised when there are not enough flippable words.
-  JakPibError = Class.new(StandardError)
+  # Has the config file been loaded?
+  @config_file_loaded = false
+
+  module_function
+
+  ##
+  # Method for accessing the configuration.
+  #
+  # @return [Spoonerize::Config]
+  def config
+    @config || reset_config
+  end
+
+  ##
+  # Reset all configuration values to their defaults.
+  #
+  # @return [Spoonerize::Config]
+  def reset_config
+    @config_file_loaded = false
+    @config = Spoonerize::Config.new
+  end
 
   ##
-  # Excluded words from config files.
-  LAZY_WORDS = YAML.load_file(
-    File.join(File.dirname(__FILE__), "config", "lazy_words.yml")
-  ).freeze
+  # Allows for configuration via a block. Useful when making config files.
+  #
+  # @example
+  #   Spoonerize.configure { |s| s.lazy = true }
+  def configure
+    yield config
+  end
+
+  ##
+  # Has a config file been loaded?
+  #
+  # @return [Boolean]
+  def config_file_loaded?
+    @config_file_loaded
+  end
+
+  ##
+  # Loads a config file.
+  #
+  # @param [String] config_file
+  #
+  # @return [String] file
+  def load_config_file(config_file)
+    ::File.expand_path(config_file).tap do |file|
+      raise "File #{file} does not exist." unless ::File.file?(file)
+
+      @config_file_loaded = true
+      load file
+    end
+  end
 end

data/spoonerize.gemspec

@@ -31,5 +31,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "csv"
   spec.add_development_dependency "rdoc"
   spec.add_development_dependency "rake", "~> 13.0", ">= 13.0.1"
+  spec.add_development_dependency "standard", "= 1.54.0"
   spec.add_development_dependency "test-unit", "~> 3.3", ">= 3.3.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spoonerize
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Evan Gray
@@ -57,6 +57,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 13.0.1
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.54.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.54.0
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -93,10 +107,10 @@ files:
 - Rakefile
 - _config.yml
 - bin/spoonerize
-- lib/config/lazy_words.yml
 - lib/spoonerize.rb
 - lib/spoonerize/bumper.rb
 - lib/spoonerize/cli.rb
+- lib/spoonerize/config.rb
 - lib/spoonerize/log.rb
 - lib/spoonerize/spoonerism.rb
 - lib/spoonerize/version.rb

data/lib/config/lazy_words.yml

@@ -1,22 +0,0 @@
-#=================================================================#
-#         File: lazy_words.yml                                    #
-#  Description: Words to be excluded when "lazy" mode is enabled  #
-#                                                                 #
-#       Author: Evan Gray                                         #
-#=================================================================#
-
-- i
-- a
-- an
-- and
-- in
-- of
-- the
-- my
-- your
-- his
-- her
-- him
-- hers
-- to
-- is