strings-inflection 0.1.0

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+FileList["tasks/**/*.rake"].each(&method(:import))
+
+desc "Run all specs"
+task ci: %w[ spec ]
+
+task default: :spec

data/lib/strings-inflection.rb

@@ -0,0 +1 @@
+require_relative "strings/inflection"

data/lib/strings/inflection.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+require_relative "inflection/combined_noun"
+require_relative "inflection/configuration"
+require_relative "inflection/noun"
+require_relative "inflection/parser"
+require_relative "inflection/verb"
+require_relative "inflection/version"
+
+module Strings
+  module Inflection
+    # Error raised by this inflector
+    class Error < StandardError; end
+
+    # Create a noun object
+    #
+    # @api public
+    def Noun(word)
+      Noun[word]
+    end
+    module_function :Noun
+
+    # Create a verb object
+    #
+    # @api public
+    def Verb(word)
+      Verb[word]
+    end
+    module_function :Verb
+
+    # A configuration object
+    #
+    # @api public
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    module_function :configuration
+
+    # Reset configuration and remove loaded inflections
+    #
+    # @api public
+    def reset(scope = :all)
+      configuration.reset(scope)
+    end
+    module_function :reset
+
+    # Configure custom inflections
+    #
+    # @example
+    #   configure do |config|
+    #     config.plural "index", "indexes"
+    #     config.singular "axes", "ax"
+    #   end
+    #
+    # @api public
+    def configure
+      if block_given?
+        yield configuration
+      else
+        configuration
+      end
+    end
+    module_function :configure
+
+    # Check if word is uncountable
+    #
+    # @param [String] word
+    #   the word to check
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def uncountable?(word)
+      Noun[word].uncountable?
+    end
+    module_function :uncountable?
+
+    # Inflect a noun into a correct form
+    #
+    # @example
+    #   Strings::Inflection.inflect("error", 3)
+    #   # => "errors"
+    #
+    # @param [String] word
+    #   the word to inflect
+    # @param [Integer] count
+    #   the count of items
+    #
+    # @api public
+    def inflect(word, count, term: :noun)
+      template = !!(word =~ /\{\{([^\}]+)\}\}/)
+
+      Parser.parse(template ? word : "{{#{term.upcase[0]}:#{word}}}", count)
+    end
+    module_function :inflect
+
+    # Inflect a pural word to its singular form
+    #
+    # @example
+    #   Strings::Inflection.singularize("errors")
+    #   # => "error"
+    #
+    # @param [String] word
+    #   the noun to inflect to singular form
+    #
+    # @api public
+    def singularize(word, term: :noun)
+      case term
+      when :noun, :n
+        Noun[word].singular
+      when :verb, :v
+        Verb[word].singular
+      end
+    end
+    module_function :singularize
+
+    # Inflect a word to its plural form
+    #
+    # @example
+    #   Strings::Inflection.pluralize("error")
+    #   # => "errors"
+    #
+    # @param [String] word
+    #   noun to inflect to plural form
+    #
+    # @api public
+    def pluralize(word, term: :noun)
+      case term
+      when :noun, :n
+        Noun[word].plural
+      when :verb, :v
+        Verb[word].plural
+      end
+    end
+    module_function :pluralize
+
+    # Check if noun is in singular form
+    #
+    # @example
+    #   Strings::Inflection.singular?("error")
+    #   # => true
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def singular?(word, term: :noun)
+      case term.to_sym
+      when :noun, :n
+        Noun[word].singular?
+      when :verb, :v
+        Verb[word].singular?
+      else
+        raise Error, "Unknown option '#{term}' as a term"
+      end
+    end
+    module_function :singular?
+
+    # Check if noun is in plural form
+    #
+    # @example
+    #   Strings::Inflection.plural?("errors")
+    #   # => true
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def plural?(word, term: :noun)
+      case term.to_sym
+      when :noun, :n
+        Noun[word].plural?
+      when :verb, :v
+        Verb[word].plural?
+      else
+        raise Error, "Unknown option '#{term}' as a term"
+      end
+    end
+    module_function :plural?
+
+
+    # Join a list of words into a single sentence
+    #
+    # @example
+    #   Strings::Inflection.join_words("one", "two", "three")
+    #   # => "one, two and three"
+    #
+    # @param [Array[String]] words
+    #   the words to join
+    # @param [String] separator
+    #   the character to use to join words, defaults to `,`
+    # @param [String] final_separator
+    #   the separator used before joining the last word
+    # @param [String] conjunctive
+    #   the word used for combining the last word with the rest
+    #
+    # @return [String]
+    #
+    # @api public
+    def join_words(*words, **options)
+      CombinedNoun.new(words).join_words(**options)
+    end
+    module_function :join_words
+  end # Inflection
+end # Strings

data/lib/strings/inflection/combined_noun.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Strings
+  module Inflection
+    class CombinedNoun
+      WHITESPACE_REGEX = /(\s)\s+/.freeze
+
+      attr_reader :words
+
+      # Create a combined noun
+      #
+      # @api private
+      def initialize(words = [])
+        @words = words
+      end
+
+      # Combined with another noun
+      #
+      # @param [String] word
+      #   the word to combine with
+      #
+      # @api public
+      def +(word)
+        CombinedNoun.new(@words + [word])
+      end
+
+      # Join a list of words into a single sentence
+      #
+      # @example
+      #   CombinedNoun(["one", "two", "three"]).join_words
+      #   # => "one, two and three"
+      #
+      # @param [Array[String]] words
+      #   the words to join
+      # @param [String] separator
+      #   the character to use to join words, defaults to `,`
+      # @param [String] final_separator
+      #   the separator used before joining the last word
+      # @param [String] conjunctive
+      #   the word used for combining the last word with the rest
+      #
+      # @return [String]
+      #
+      # @api public
+      def join_words(separator: ", ", conjunctive: "and", final_separator: nil)
+        oxford_comma = final_separator || separator
+
+        case words.length
+        when 0
+          ""
+        when 1, 2
+          words.join(" #{conjunctive} ").gsub(WHITESPACE_REGEX, "\\1")
+        else
+          ((words[0...-1]).join(separator.to_s) +
+          "#{oxford_comma} #{conjunctive} " + words[-1])
+            .gsub(WHITESPACE_REGEX, "\\1").gsub(/\s*(,)/, "\\1")
+        end
+      end
+
+      # The combined words
+      #
+      # @return [Array[String]]
+      #
+      # @api public
+      def to_ary
+        @words.to_ary
+      end
+    end # CombinedNoun
+  end # Inflection
+end # Strings

data/lib/strings/inflection/configuration.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Strings
+  module Inflection
+    class Configuration
+
+      attr_reader :plurals, :singulars, :uncountables
+
+      # Initialize a configuration
+      #
+      # @api private
+      def initialize
+        reset
+      end
+
+      # Add a singular rule form for a term. By default noun.
+      #
+      # @example
+      #   singular "axes", "ax"
+      #
+      # @param [String,Regex] rule
+      # @param [String] replacement
+      #
+      # @api public
+      def singular(rule, replacement, term: :noun)
+        @singulars[term] << [Regexp.new(rule, "i"), replacement]
+      end
+
+      # Add a plural rule form for a term. By default noun.
+      #
+      # @example
+      #   plural "index", "indexes"
+      #
+      # @param [String,Regex] rule
+      # @param [String] replacement
+      #
+      # @api public
+      def plural(rule, replacement, term: :noun)
+        @plurals[term] << [Regexp.new(rule, "i"), replacement]
+      end
+
+      # Add a rule that provides transformation for both singular and
+      # plural inflections.
+      #
+      # @example
+      #   rule "ax", "axes"
+      #
+      # @api public
+      def rule(sing, plur, term: :noun)
+        plural(sing, plur, term: term)
+        singular(plur, sing, term: term)
+      end
+
+      # Add an uncountable word. By default noun.
+      #
+      # @api public
+      def uncountable(word, term: :noun)
+        @uncountables[term] << word
+      end
+
+      # Reset configuration and remove loaded inflections. By default
+      # all scopes are reset. The available scopes are: :plurals,
+      # :singulars, :uncountable
+      #
+      # @example
+      #   reset(:all)
+      #   reset(:plurals)
+      #
+      # @api public
+      def reset(scope = :all)
+        case scope
+        when :all
+          %i[singulars plurals uncountables].map {|s| clear(s) }
+        else
+          clear(scope)
+        end
+      end
+
+      def clear(name)
+        instance_variable_set "@#{name}", { noun: [], verb: [] }
+      end
+    end # Configuration
+  end # Inflection
+end # Strings

data/lib/strings/inflection/extensions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Strings
+  module Inflection
+    module Extensions
+      refine String do
+        def inflect(*args, **options)
+          Strings::Inflection.inflect(self, *args, **options)
+        end
+
+        def singularize(**options)
+          Strings::Inflection.singularize(self, **options)
+        end
+
+        def pluralize(**options)
+          Strings::Inflection.pluralize(self, **options)
+        end
+
+        def singular?(**options)
+          Strings::Inflection.singular?(self, **options)
+        end
+
+        def plural?(**options)
+          Strings::Inflection.plural?(self, **options)
+        end
+
+        def join_words(*words, **options)
+          Strings::Inflection.join_words(self, *words, **options)
+        end
+      end
+    end # Extensions
+  end # Inflection
+end # Strings

data/lib/strings/inflection/noun.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "combined_noun"
+require_relative "term"
+require_relative "nouns"
+
+module Strings
+  module Inflection
+    class Noun < Term
+      # Check if word is uncountable
+      #
+      # @param [String] word
+      #   the word to check
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def uncountable?
+        Inflection.configuration.uncountables[:noun].include?(word.downcase) ||
+          Nouns.uncountable.include?(word.downcase)
+      end
+
+      # Inflect a word to its singular form
+      #
+      # @example
+      #   Strings::Inflection::Noun.new("errors").singular
+      #   # => "error"
+      #
+      # @param [String] word
+      #   the noun to inflect to singular form
+      #
+      # @api public
+      def singular
+        return word if word.to_s.empty?
+
+        find_match(Inflection.configuration.singulars[:noun]) ||
+          (uncountable? && word) || find_match(Nouns.singulars) || word
+      end
+
+      # Inflect a word to its plural form
+      #
+      # @example
+      #   Strings::Inflection::Noun.new("error").plural
+      #   # => "errors"
+      #
+      # @param [String] word
+      #   noun to inflect to plural form
+      #
+      # @api public
+      def plural
+        return word if word.to_s.empty?
+
+        find_match(Inflection.configuration.plurals[:noun]) ||
+          (uncountable? && word) || find_match(Nouns.plurals) || word
+      end
+
+      # Combine this noun with another word
+      #
+      # @param [String] other_word
+      #   the other word to combined with
+      #
+      # @return [CombinedNoun]
+      #
+      # @api public
+      def +(other_word)
+        CombinedNoun.new([word, other_word])
+      end
+    end # Noun
+  end # Inflection
+end # Strings