cybertrain 0.1.1 → 0.2.1

data/cybertrain/cli.rb

@@ -1,21 +1,25 @@
 # The `cybertrain` command: exe/cybertrain under CRuby (the gem), or
 # bin/cybertrain.rb built by spin (`spin install` from a checkout).
 #
-#   cybertrain new NAME [--path DIR | --version V] [--skip-spin]
+#   cybertrain new NAME [--path DIR | --version V | --git URL [--ref R]] [--skip-spin]
 #   cybertrain generate scaffold NAME field:type ... [parent:references]
-#   cybertrain migration | db COMMAND... | server [PORT] | build
-#   cybertrain version | help
+#   cybertrain db migrate | db COMMAND... | server [PORT] | build | spin ARGS...
+#   cybertrain setup [--force] | doctor | version | help
+#
+# Every command that runs spin first puts a Spinel of the pinned release on
+# PATH (Toolchain.ensure!), installing it under ~/.cybertrain the first time.
 require "cybertrain/version"
 require "cybertrain/cli/templates"
 require "cybertrain/cli/new_app"
 require "cybertrain/cli/scaffold"
 require "cybertrain/cli/build"
+require "cybertrain/cli/toolchain"
 
 module Cybertrain
   module CLI
     USAGE = <<~TEXT
       Usage:
-        cybertrain new NAME [--path DIR | --version V] [--skip-spin]
+        cybertrain new NAME [--path DIR | --version V | --git URL [--ref R]] [--skip-spin]
             Create an application in NAME, then run `spin lock` and
             `spin run gen` in it (skipped with --skip-spin). Its spin.toml
             depends on this cybertrain's release by default:
@@ -23,20 +27,33 @@ module Cybertrain
             --path DIR: the framework checkout at DIR (relative to the
             current directory; written as an absolute path).
             --version V: the index version constraint V.
+            --git URL [--ref R]: the framework at URL, at branch or tag R.
         cybertrain generate scaffold NAME field:type ... [parent:references]
             Add a resource to the application in the current directory.
             Types: #{Field::TYPES.join(", ")} (default string).
-        cybertrain migration
+        cybertrain db migrate
             Generate, apply pending migrations, generate again
             (spin run gen; spin run db -- migrate; spin run gen).
         cybertrain db COMMAND...
-            Any database command: status, rollback [N], schema:dump, create.
+            Any other database command, after `spin run gen`: status,
+            rollback [N] (generates again afterwards), schema:dump, create.
+            `cybertrain migration` is the same as `cybertrain db migrate`.
         cybertrain server [PORT]
             Generate, then start the development server
             (spin run gen; spin run NAME [-- PORT]; default port 3000).
         cybertrain build
             Build NAME with app/views embedded and assemble dist/
             (the binary, public/, storage/, tmp/).
+        cybertrain spin ARGS...
+            Run spin with the pinned Spinel, from any directory
+            (cybertrain spin test; cybertrain spin run gen -- --check).
+        cybertrain setup [--force]
+            Install Spinel #{Cybertrain::SPINEL_TAG} into ~/.cybertrain (CYBERTRAIN_HOME)
+            unless a spinel of that release is already on PATH, and print
+            the PATH line for ~/.cybertrain/bin. The commands above do the
+            install by themselves the first time they need spin.
+        cybertrain doctor
+            Check the C toolchain, the SQLite headers and the Spinel install.
         cybertrain version
         cybertrain help
     TEXT
@@ -47,10 +64,13 @@ module Cybertrain
       case command
       when "new" then run_new(argv)
       when "generate", "g" then run_generate(argv)
-      when "migration" then run_in_app { |_name| run_all(Build.migration_commands) }
-      when "db" then run_in_app { |_name| run_all(["spin run db -- #{db_args(argv)}"]) }
+      when "migration" then run_in_app { |_name| run_spin(Build.db_commands(["migrate"])) }
+      when "db" then run_in_app { |_name| run_db(argv) }
       when "server" then run_in_app { |name| run_server(name, argv) }
-      when "build" then run_in_app { |name| Build.run(".", name) }
+      when "build" then run_in_app { |name| build_app(name) }
+      when "spin" then run_spin_passthrough(argv)
+      when "setup" then Toolchain.setup(argv[1, argv.size - 1])
+      when "doctor" then run_doctor(argv)
       when "version", "--version", "-v"
         puts "cybertrain #{Cybertrain::VERSION}"
         0
@@ -68,7 +88,7 @@ module Cybertrain
     end
 
     def self.run_new(argv)
-      raise InvalidArgument, "usage: cybertrain new NAME [--path DIR | --version V] [--skip-spin]" if argv.size < 2
+      raise InvalidArgument, "usage: cybertrain new NAME [--path DIR | --version V | --git URL [--ref R]] [--skip-spin]" if argv.size < 2
 
       dir = argv[1]
       raise InvalidArgument, "'#{File.basename(dir)}' is not a valid app name (lowercase letters, digits and _)" unless Templates.identifier?(File.basename(dir))
@@ -76,8 +96,15 @@ module Cybertrain
 
       NewApp.create(dir, framework_dep(argv))
       return 0 if argv.include?("--skip-spin")
-
-      NewApp.bootstrap(dir) ? 0 : 1
+      return 1 unless NewApp.bootstrap(dir)
+
+      puts ""
+      puts "next:"
+      puts "  cd #{Build.quote_arg(dir)}"
+      puts "  cybertrain generate scaffold article title:string body:text"
+      puts "  cybertrain db migrate"
+      puts "  cybertrain server"
+      0
     end
 
     # The spin.toml value of the `cybertrain =` dependency. By default the
@@ -89,20 +116,41 @@ module Cybertrain
     def self.framework_dep(argv)
       path = option(argv, "--path")
       version = option(argv, "--version")
-      raise InvalidArgument, "pass either --path or --version, not both" unless path == "" || version == ""
-      return "\"#{version}\"" unless version == ""
-      return "{ path = \"#{File.expand_path(path, Dir.pwd)}\" }" unless path == ""
+      git = option(argv, "--git")
+      ref = option(argv, "--ref")
+      given = 0
+      given += 1 unless path == ""
+      given += 1 unless version == ""
+      given += 1 unless git == ""
+      raise InvalidArgument, "pass only one of --path, --version and --git" if given > 1
+      raise InvalidArgument, "--ref needs --git" if ref != "" && git == ""
+      return toml_string(version) unless version == ""
+      return "{ path = #{toml_string(File.expand_path(path, Dir.pwd))} }" unless path == ""
+      return "{ git = #{toml_string(git)} }" if git != "" && ref == ""
+      return "{ git = #{toml_string(git)}, ref = #{toml_string(ref)} }" unless git == ""
 
       "{ git = \"#{Cybertrain::REPOSITORY}\", ref = \"v#{Cybertrain::VERSION}\" }"
     end
 
-    # The value after `--flag`, or "" when the flag is absent.
+    # `value` as a TOML basic string: `\` and `"` escaped. Control
+    # characters are refused rather than encoded: no path, URL or git ref
+    # needs one, and spin.toml stays readable.
+    def self.toml_string(value)
+      raise InvalidArgument, "control characters are not allowed in --path, --version, --git or --ref" unless value.bytes.all? { |b| b >= 32 && b != 127 }
+
+      "\"#{value.gsub("\\", "\\\\\\\\").gsub("\"", "\\\"")}\""
+    end
+
+    # The value after `--flag`, or "" when the flag is absent. An empty
+    # value, or another option in the value's place, means it is missing.
     def self.option(argv, flag)
       i = argv.index(flag)
       return "" if i.nil?
-      raise InvalidArgument, "#{flag} needs a value" if i + 1 >= argv.size
 
-      argv[i + 1]
+      value = i + 1 < argv.size ? argv[i + 1] : ""
+      raise InvalidArgument, "#{flag} needs a value" if value == "" || value.start_with?("--")
+
+      value
     end
 
     # Commands that need the app: its name comes from ./spin.toml.
@@ -115,7 +163,22 @@ module Cybertrain
       yield name
     end
 
-    # Runs each command in turn; stops at the first failure.
+    # `cybertrain build`: the one dist/ name check, made before the toolchain
+    # is fetched or any spin command runs; Build.run assumes a name that got
+    # past it.
+    def self.build_app(name)
+      Build.require_dist_name!(name)
+      Toolchain.ensure! ? Build.run(".", name) : 1
+    end
+
+    # Runs spin commands in turn once a Spinel of the pinned release is on
+    # PATH; stops at the first failure.
+    def self.run_spin(commands)
+      return 1 unless Toolchain.ensure!
+
+      run_all(commands)
+    end
+
     def self.run_all(commands)
       status = 0
       commands.each do |command|
@@ -128,6 +191,37 @@ module Cybertrain
       status
     end
 
+    # `cybertrain spin ARGS...`: spin from the pinned toolchain, wherever
+    # the command runs (an application directory or not).
+    def self.run_spin_passthrough(argv)
+      args = argv[1, argv.size - 1]
+      if args.empty?
+        puts "usage: cybertrain spin ARGS... (for example: cybertrain spin test)"
+        return 1
+      end
+      return 1 unless Toolchain.ensure!
+
+      system((["spin"] + args.map { |arg| Build.quote_arg(arg) }).join(" ")) ? 0 : 1
+    end
+
+    def self.run_doctor(argv)
+      if argv.size > 1
+        puts "usage: cybertrain doctor"
+        return 1
+      end
+      Toolchain.doctor
+    end
+
+    # `cybertrain db COMMAND...`.
+    def self.run_db(argv)
+      args = argv[1, argv.size - 1]
+      if args.empty?
+        puts "usage: cybertrain db (migrate|rollback [N]|status|schema:dump|create)"
+        return 1
+      end
+      run_spin(Build.db_commands(args))
+    end
+
     # `cybertrain server [PORT]`.
     def self.run_server(name, argv)
       port = argv.size > 1 ? argv[1] : ""
@@ -139,12 +233,7 @@ module Cybertrain
         puts "error: unexpected argument '#{argv[2]}'"
         return 1
       end
-      run_all(Build.server_commands(name, port))
-    end
-
-    # The words after `db`, each shell-quoted.
-    def self.db_args(argv)
-      argv[1, argv.size - 1].map { |arg| Build.shell_quote(arg) }.join(" ")
+      run_spin(Build.server_commands(name, port))
     end
 
     def self.run_generate(argv)

data/cybertrain/generator/inflector.rb

@@ -1,29 +1,45 @@
 module Cybertrain
-  # The handful of Rails inflections the generators need. Singular/plural
-  # forms come from a small irregulars table plus English suffix rules;
-  # a word that is in neither simply gets the rules ("octopus" -> "octopuses").
+  # ActiveSupport::Inflector's camelize, underscore, pluralize and
+  # singularize with Rails' default English inflections
+  # (active_support/inflections.rb), checked rule for rule against
+  # ActiveSupport 8.1.4.
+  #
+  # Rails keeps its rules in tables that inflect.plural/singular/irregular/
+  # uncountable prepend to and tries them newest first, the first match
+  # winning. Spinel cannot keep Regexp objects in a collection, so each table
+  # is written out below as literal regexes in that application order: the
+  # expansion of every inflect.irregular (newest first), then the plain rules
+  # (newest first). An uncountable word -- or a compound ending in one after a
+  # word boundary, so "my money" but not "blog_fish" -- and "" come back
+  # unchanged.
+  #
+  # Application-defined inflections (config/initializers/inflections.rb:
+  # inflect.irregular, inflect.uncountable, inflect.acronym, ...) and locales
+  # other than English are not supported; camelize and underscore behave as
+  # Rails' do with no acronyms defined.
   module Inflector
-    IRREGULARS = {
-      "person" => "people", "man" => "men", "woman" => "women",
-      "child" => "children", "mouse" => "mice", "ox" => "oxen"
-    }
-    UNCOUNTABLE = %w[equipment information rice money species series fish sheep news jeans]
-    # Singulars ending in "s" whose plural adds "es" (Rails' alias/status/bus rules).
-    ES_WORDS = %w[status alias bus]
-
     # "posts_controller" -> "PostsController"; "admin/posts" -> "Admin::Posts".
-    def self.camelize(str)
+    # As Rails: the leading lowercase/digit run is capitalized, and each "_"
+    # or "/" is dropped and the alphanumeric run after it capitalized (the
+    # rest of that run downcased: "foo_BAR" -> "FooBar"); "/" becomes "::".
+    def self.camelize(term)
       out = +""
-      upper = true
-      str.each_char do |ch|
-        if ch == "_"
-          upper = true
-        elsif ch == "/"
-          out << "::"
-          upper = true
-        elsif upper
-          out << ch.upcase
-          upper = false
+      n = term.size
+      i = 0
+      while i < n && lower_or_digit?(term[i])
+        out << (i == 0 ? term[i].upcase : term[i])
+        i += 1
+      end
+      while i < n
+        ch = term[i]
+        i += 1
+        if ch == "_" || ch == "/"
+          out << "::" if ch == "/"
+          start = i
+          while i < n && alnum?(term[i])
+            out << (i == start ? term[i].upcase : term[i].downcase)
+            i += 1
+          end
         else
           out << ch
         end
@@ -31,96 +47,146 @@ module Cybertrain
       out
     end
 
-    # "PostsController" -> "posts_controller"; "HTMLParser" -> "html_parser".
-    def self.underscore(str)
-      # Two steps: in a threaded program a collection inside `chars` freed the
-      # unnamed gsub result it was splitting ("Post" came back as "").
-      path = str.gsub("::", "/")
+    # "PostsController" -> "posts_controller"; "HTMLTidyGenerator" ->
+    # "html_tidy_generator"; "Admin::Posts" -> "admin/posts". As Rails: "_"
+    # goes before an uppercase letter that follows a lowercase letter or digit,
+    # or that follows an uppercase letter and precedes a lowercase one; "-"
+    # becomes "_" and the result is downcased.
+    def self.underscore(camel_cased_word)
+      return camel_cased_word.dup unless camel_cased_word.match?(/[A-Z-]|::/)
+
+      # Two steps, the gsub result held in a local: in a threaded program a
+      # collection inside `chars` frees an unnamed gsub result it is
+      # splitting ("Post" comes back as "").
+      path = camel_cased_word.gsub("::", "/")
       chars = path.chars
       out = +""
       chars.each_with_index do |ch, i|
-        if upper?(ch)
-          prev = i > 0 ? chars[i - 1] : ""
+        if i > 0 && upper?(ch)
+          prev = chars[i - 1]
           nxt = i + 1 < chars.size ? chars[i + 1] : ""
-          if prev != "" && prev != "/" && (lower_or_digit?(prev) || (upper?(prev) && lower_or_digit?(nxt)))
-            out << "_"
-          end
-          out << ch.downcase
-        else
-          out << ch
+          out << "_" if lower_or_digit?(prev) || (upper?(prev) && lower?(nxt))
         end
+        out << (ch == "-" ? "_" : ch)
       end
-      out
-    end
-
-    # "posts" -> "post"; only the last "_" word is inflected ("blog_posts").
-    def self.singularize(str)
-      parts = split_last_word(str)
-      parts[0] + singular_word(parts[1])
+      out.downcase
     end
 
-    # "post" -> "posts"; only the last "_" word is inflected.
-    def self.pluralize(str)
-      parts = split_last_word(str)
-      parts[0] + plural_word(parts[1])
-    end
-
-    def self.singular_word(word)
-      return word if UNCOUNTABLE.include?(word)
+    # "post" -> "posts", "person" -> "people", "sales_person" ->
+    # "sales_people", "Category" -> "Categories", "sheep" -> "sheep".
+    def self.pluralize(word)
+      return word.dup if word.empty? || uncountable?(word)
 
-      IRREGULARS.each { |singular, plural| return singular if word == plural }
-      return word if IRREGULARS.key?(word)
+      # inflect.irregular, newest first: zombie, move, sex, child, man, person.
+      return word.sub(/(z)ombies$/i, '\1ombies') if word.match?(/(z)ombies$/i)
+      return word.sub(/(z)ombie$/i, '\1ombies') if word.match?(/(z)ombie$/i)
+      return word.sub(/(m)oves$/i, '\1oves') if word.match?(/(m)oves$/i)
+      return word.sub(/(m)ove$/i, '\1oves') if word.match?(/(m)ove$/i)
+      return word.sub(/(s)exes$/i, '\1exes') if word.match?(/(s)exes$/i)
+      return word.sub(/(s)ex$/i, '\1exes') if word.match?(/(s)ex$/i)
+      return word.sub(/(c)hildren$/i, '\1hildren') if word.match?(/(c)hildren$/i)
+      return word.sub(/(c)hild$/i, '\1hildren') if word.match?(/(c)hild$/i)
+      return word.sub(/(m)en$/i, '\1en') if word.match?(/(m)en$/i)
+      return word.sub(/(m)an$/i, '\1en') if word.match?(/(m)an$/i)
+      return word.sub(/(p)eople$/i, '\1eople') if word.match?(/(p)eople$/i)
+      return word.sub(/(p)erson$/i, '\1eople') if word.match?(/(p)erson$/i)
+      # inflect.plural, newest first.
+      return word.sub(/(quiz)$/i, '\1zes') if word.match?(/(quiz)$/i)
+      return word.sub(/^(oxen)$/i, '\1') if word.match?(/^(oxen)$/i)
+      return word.sub(/^(ox)$/i, '\1en') if word.match?(/^(ox)$/i)
+      return word.sub(/^(m|l)ice$/i, '\1ice') if word.match?(/^(m|l)ice$/i)
+      return word.sub(/^(m|l)ouse$/i, '\1ice') if word.match?(/^(m|l)ouse$/i)
+      return word.sub(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices') if word.match?(/(matr|vert|ind)(?:ix|ex)$/i)
+      return word.sub(/(x|ch|ss|sh)$/i, '\1es') if word.match?(/(x|ch|ss|sh)$/i)
+      return word.sub(/([^aeiouy]|qu)y$/i, '\1ies') if word.match?(/([^aeiouy]|qu)y$/i)
+      return word.sub(/(hive)$/i, '\1s') if word.match?(/(hive)$/i)
+      return word.sub(/(?:([^f])fe|([lr])f)$/i, '\1\2ves') if word.match?(/(?:([^f])fe|([lr])f)$/i)
+      return word.sub(/sis$/i, "ses") if word.match?(/sis$/i)
+      return word.sub(/([ti])a$/i, '\1a') if word.match?(/([ti])a$/i)
+      return word.sub(/([ti])um$/i, '\1a') if word.match?(/([ti])um$/i)
+      return word.sub(/(buffal|tomat)o$/i, '\1oes') if word.match?(/(buffal|tomat)o$/i)
+      return word.sub(/(bu)s$/i, '\1ses') if word.match?(/(bu)s$/i)
+      return word.sub(/(alias|status)$/i, '\1es') if word.match?(/(alias|status)$/i)
+      return word.sub(/(octop|vir)i$/i, '\1i') if word.match?(/(octop|vir)i$/i)
+      return word.sub(/(octop|vir)us$/i, '\1i') if word.match?(/(octop|vir)us$/i)
+      return word.sub(/^(ax|test)is$/i, '\1es') if word.match?(/^(ax|test)is$/i)
+      return word.sub(/s$/i, "s") if word.match?(/s$/i)
 
-      if word.end_with?("ies") && word.size > 3 && !vowel?(word[word.size - 4])
-        word[0, word.size - 3] + "y"
-      elsif ES_WORDS.include?(word[0, word.size - 2]) || word.end_with?("sses") ||
-            word.end_with?("xes") || word.end_with?("ches") || word.end_with?("shes")
-        word[0, word.size - 2]
-      elsif word.end_with?("ss") || ES_WORDS.include?(word)
-        word
-      elsif word.end_with?("s")
-        word[0, word.size - 1]
-      else
-        word
-      end
+      word.sub(/$/, "s")
     end
 
-    def self.plural_word(word)
-      return word if UNCOUNTABLE.include?(word)
+    # "posts" -> "post", "people" -> "person", "sales_people" ->
+    # "sales_person", "Categories" -> "Category", "news" -> "news".
+    def self.singularize(word)
+      return word.dup if word.empty? || uncountable?(word)
 
-      plural = IRREGULARS[word]
-      return plural unless plural.nil?
-
-      if word.end_with?("y") && word.size > 1 && !vowel?(word[word.size - 2])
-        word[0, word.size - 1] + "ies"
-      elsif ES_WORDS.include?(word) || word.end_with?("ss") || word.end_with?("x") ||
-            word.end_with?("ch") || word.end_with?("sh")
-        word + "es"
-      elsif word.end_with?("s")
-        word
-      else
-        word + "s"
+      # inflect.irregular, newest first: zombie, move, sex, child, man, person.
+      return word.sub(/(z)ombies$/i, '\1ombie') if word.match?(/(z)ombies$/i)
+      return word.sub(/(z)ombie$/i, '\1ombie') if word.match?(/(z)ombie$/i)
+      return word.sub(/(m)oves$/i, '\1ove') if word.match?(/(m)oves$/i)
+      return word.sub(/(m)ove$/i, '\1ove') if word.match?(/(m)ove$/i)
+      return word.sub(/(s)exes$/i, '\1ex') if word.match?(/(s)exes$/i)
+      return word.sub(/(s)ex$/i, '\1ex') if word.match?(/(s)ex$/i)
+      return word.sub(/(c)hildren$/i, '\1hild') if word.match?(/(c)hildren$/i)
+      return word.sub(/(c)hild$/i, '\1hild') if word.match?(/(c)hild$/i)
+      return word.sub(/(m)en$/i, '\1an') if word.match?(/(m)en$/i)
+      return word.sub(/(m)an$/i, '\1an') if word.match?(/(m)an$/i)
+      return word.sub(/(p)eople$/i, '\1erson') if word.match?(/(p)eople$/i)
+      return word.sub(/(p)erson$/i, '\1erson') if word.match?(/(p)erson$/i)
+      # inflect.singular, newest first.
+      return word.sub(/(database)s$/i, '\1') if word.match?(/(database)s$/i)
+      return word.sub(/(quiz)zes$/i, '\1') if word.match?(/(quiz)zes$/i)
+      return word.sub(/(matr)ices$/i, '\1ix') if word.match?(/(matr)ices$/i)
+      return word.sub(/(vert|ind)ices$/i, '\1ex') if word.match?(/(vert|ind)ices$/i)
+      return word.sub(/^(ox)en/i, '\1') if word.match?(/^(ox)en/i)
+      return word.sub(/(alias|status)(es)?$/i, '\1') if word.match?(/(alias|status)(es)?$/i)
+      return word.sub(/(octop|vir)(us|i)$/i, '\1us') if word.match?(/(octop|vir)(us|i)$/i)
+      return word.sub(/^(a)x[ie]s$/i, '\1xis') if word.match?(/^(a)x[ie]s$/i)
+      return word.sub(/(cris|test)(is|es)$/i, '\1is') if word.match?(/(cris|test)(is|es)$/i)
+      return word.sub(/(shoe)s$/i, '\1') if word.match?(/(shoe)s$/i)
+      return word.sub(/(o)es$/i, '\1') if word.match?(/(o)es$/i)
+      return word.sub(/(bus)(es)?$/i, '\1') if word.match?(/(bus)(es)?$/i)
+      return word.sub(/^(m|l)ice$/i, '\1ouse') if word.match?(/^(m|l)ice$/i)
+      return word.sub(/(x|ch|ss|sh)es$/i, '\1') if word.match?(/(x|ch|ss|sh)es$/i)
+      return word.sub(/(m)ovies$/i, '\1ovie') if word.match?(/(m)ovies$/i)
+      return word.sub(/(s)eries$/i, '\1eries') if word.match?(/(s)eries$/i)
+      return word.sub(/([^aeiouy]|qu)ies$/i, '\1y') if word.match?(/([^aeiouy]|qu)ies$/i)
+      return word.sub(/([lr])ves$/i, '\1f') if word.match?(/([lr])ves$/i)
+      return word.sub(/(tive)s$/i, '\1') if word.match?(/(tive)s$/i)
+      return word.sub(/(hive)s$/i, '\1') if word.match?(/(hive)s$/i)
+      return word.sub(/([^f])ves$/i, '\1fe') if word.match?(/([^f])ves$/i)
+      return word.sub(/(^analy)(sis|ses)$/i, '\1sis') if word.match?(/(^analy)(sis|ses)$/i)
+      if word.match?(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i)
+        return word.sub(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
       end
-    end
+      return word.sub(/([ti])a$/i, '\1um') if word.match?(/([ti])a$/i)
+      return word.sub(/(n)ews$/i, '\1ews') if word.match?(/(n)ews$/i)
+      return word.sub(/(ss)$/i, '\1') if word.match?(/(ss)$/i)
+      return word.sub(/s$/i, "") if word.match?(/s$/i)
 
-    # "sales_people" -> ["sales_", "people"].
-    def self.split_last_word(str)
-      i = str.rindex("_")
-      return ["", str] if i.nil?
-
-      [str[0, i + 1], str[i + 1, str.size - i - 1]]
+      word.dup
     end
 
-    def self.vowel?(ch)
-      ch == "a" || ch == "e" || ch == "i" || ch == "o" || ch == "u"
+    # inflect.uncountable: Rails matches /\b<word>\Z/i, so "my money" and
+    # "Sheep" are uncountable but "blog_fish" ("_" is a word character) is not.
+    def self.uncountable?(word)
+      word.match?(/\b(?:equipment|information|rice|money|species|series|fish|sheep|jeans|police)\Z/i)
     end
 
     def self.upper?(ch)
       ch >= "A" && ch <= "Z"
     end
 
+    def self.lower?(ch)
+      ch >= "a" && ch <= "z"
+    end
+
     def self.lower_or_digit?(ch)
-      (ch >= "a" && ch <= "z") || (ch >= "0" && ch <= "9")
+      lower?(ch) || (ch >= "0" && ch <= "9")
+    end
+
+    def self.alnum?(ch)
+      upper?(ch) || lower_or_digit?(ch)
     end
   end
 end