strings-inflection 0.1.0

data/lib/strings/inflection/parser.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+require_relative "noun"
+
+module Strings
+  module Inflection
+    class Parser
+      # Parse a string by evaluating content inside tags
+      #
+      # @api private
+      def self.parse(str, count)
+        parser = new(str, count)
+        parser.parse
+      end
+
+      def initialize(str, count)
+        @scanner = StringScanner.new(str)
+        @count = count
+        @value = []
+      end
+
+      def parse
+        while !@scanner.eos?
+          parse_noun || parse_verb ||
+          parse_count || parse_char
+        end
+
+        @value.join
+      end
+
+      private
+
+      # @api private
+      def parse_noun
+        if @scanner.scan(/\{\{N([^\}]*?):([^\}]+?)\}\}/)
+          option = @scanner[1].to_s.tr(" ", "").downcase
+          if option =~ /[^sp]/i
+            raise "Unknown option '#{option}' in {{N:...}} tag"
+          end
+          inflection = if option.empty?
+                         @count == 1 ? :singular : :plural
+                       else
+                         option == "s" ? :singular : :plural
+                       end
+          noun = Noun[@scanner[2].to_s.tr(" ", "")]
+          @value << noun.public_send(inflection)
+        end
+      end
+
+      # @api private
+      def parse_verb
+        if @scanner.scan(/\{\{V([^\}]*?):([^\}]+?)\}\}/)
+          option = @scanner[1].to_s.tr(" ", "").downcase
+          if !option.empty?
+            raise "Unknown option '#{option}' in {{V:...}} tag"
+          end
+          inflection = @count == 1 ? :singular : :plural
+          verb = Verb[@scanner[2].to_s.tr(" ", "")]
+          @value << verb.public_send(inflection)
+        end
+      end
+
+      # @api private
+      def parse_count
+        if @scanner.scan(/\{\{#([^\}]*?):([^\}]+?)\}\}/)
+          option = @scanner[1].to_s.tr(" ", "").downcase
+          if option =~ /[^f]/
+            raise "Unknown option '#{option}' in {{#:...}} tag"
+          end
+          amount = case option
+                   when "f"
+                     fuzzy_count(@count)
+                   else
+                     @count
+                   end
+          @value << amount
+        end
+      end
+
+      # @api private
+      def parse_char
+        @value << @scanner.getch
+      end
+
+      # @api private
+      def fuzzy_count(count)
+        if count >= 10 then "many"
+        elsif count >= 6 then "several"
+        elsif count >= 3 then "a few"
+        elsif count == 2 then "a couple of"
+        elsif count == 1 then "one"
+        else "no"
+        end
+      end
+    end # Parser
+  end # Inflection
+end # Strings

data/lib/strings/inflection/term.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Strings
+  module Inflection
+    class Term
+      # Create a term
+      #
+      # @api public
+      def self.[](word)
+        self.new(word)
+      end
+
+      attr_reader :word
+
+      # Create a new term
+      #
+      # @param [String] word
+      #   the word to turn into a term object
+      #
+      # @api public
+      def initialize(word)
+        @word = word.dup
+        freeze
+      end
+
+      # Find a matching rule and replace
+      #
+      # @return [nil, String]
+      #  nil or replaced word
+      #
+      # @api private
+      def find_match(rules)
+        regex, replacement = rules.find { |rule| !!(word =~ rule[0]) }
+
+        return if regex.nil?
+
+        word.sub(regex, replacement)
+      end
+
+      # Check if noun is in singular form
+      #
+      # @example
+      #   Strings::Inflection::Noun.new("error").singular?
+      #   # => true
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def singular?
+        return false if word.to_s.empty?
+
+        word.downcase == singular
+      end
+
+      # Check if noun is in plural form
+      #
+      # @example
+      #   Strings::Inflection::Noun.new("errors").plural?
+      #   # => true
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def plural?
+        return false if word.to_s.empty?
+
+        word.downcase == plural
+      end
+
+      # A string representation of this term
+      #
+      # @api public
+      def to_s
+        word.to_s
+      end
+    end # Term
+  end # Inflection
+end # Strings

data/lib/strings/inflection/verb.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "term"
+require_relative "verbs"
+
+module Strings
+  module Inflection
+    class Verb < Term
+      # Check if word is uninflected
+      #
+      # @param [String] word
+      #   the word to check
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def uninflected?
+        Verbs.uninflected.include?(word)
+      end
+
+      # Inflect a word to its singular form
+      #
+      # @example
+      #   Strings::Inflection::Verb.new("go").singular
+      #   # => "goes"
+      #
+      # @return [String]
+      #   the verb inflected to singular form
+      #
+      # @api public
+      def singular
+        return word if word.to_s.empty? || uninflected?
+
+        find_match(Verbs.singulars) || word
+      end
+
+      # Inflect a word to its plural form
+      #
+      # @example
+      #   Strings::Inflection::Verb.new("goes").plural
+      #   # => "go"
+      #
+      # @return [String]
+      #   the verb inflected to plural form
+      #
+      # @api public
+      def plural
+        return word if word.to_s.empty? || uninflected?
+
+        find_match(Verbs.plurals) || word
+      end
+    end # Verb
+  end # Inflection
+end # Strings

data/lib/strings/inflection/verbs.rb

@@ -0,0 +1,130 @@
+# frozen_string_litearl: true
+
+module Strings
+  module Inflection
+    module Verbs
+
+      @uninflected = [
+        "can",
+        "may",
+        "must",
+        "ought",
+        "shall",
+        "will"
+      ]
+
+      @singular_irregular = [
+        [/\A(is|are)$/, "is"],
+        [/\A(was|were)$/, "was"],
+        [/\A(ha)ve$/, "\\1s"],
+        [/(.*go|do)$/, "\\1es"],
+        [/(.*demo)$/, "\\1s"],
+        [/\A(gas)$/i, "\\1ses"],
+        [/(.*precis)$/i, "\\1es"],
+        [/(.*stomach)$/i, "\\1s"],
+      ]
+
+      @singular_rules = [
+        [/(.*[y]ch)$/i, "\\1s"],
+        [/(.*[cs]h)$/i, "\\1es"],
+        [/(.*is)$/i, "\\1ses"],
+        [/(.*[ua]s)$/i, "\\1es"],
+        [/(.*[x])$/i, "\\1es"],
+        [/(.*oe)$/i, "\\1s"],
+        [/(.*iz)$/i, "\\1zes"],
+        [/(.*zz)$/i, "\\1es"],
+        [/(.*[il]tz)$/i, "\\1es"],
+        [/(.*ss)$/i, "\\1es"],
+        [/(.*[aeiou])y$/i, "\\1ys"],
+        [/(.*)y$/i, "\\1ies"],
+        [/(.*[io]o)$/i, "\\1s"],
+        [/(.*o)$/i, "\\1es"],
+        [/(.*[^s])$/i, "\\1s"],
+        [/(.*)s$/i, "\\1s"],
+        [/(.*)$/i, "\\1s"]
+      ]
+
+      @singulars = @singular_irregular + @singular_rules
+
+      @plural_irregular = [
+        [/\A(am|is)$/, "are"],
+        [/\Awas$/, "were"],
+        [/\Ahas$/, "have"],
+        [/(.*go|do)es$/, "\\1"],
+        [/\A(bellyache|ache)s$/, "\\1"],
+        [/\A(axe)s$/, "\\1"],
+        [/\A(bus)es$/, "\\1"],
+        [/(.*caucus)es$/i, "\\1"],
+        [/(.*finesse)s$/i, "\\1"],
+        [/(.*bias)es$/i, "\\1"],
+        [/(.*cache)s$/i, "\\1"],
+        [/(.*caddie)s$/i, "\\1"],
+        [/(.*caucus)es$/i, "\\1"],
+        [/(.*chorus)es$/i, "\\1"],
+        [/\A(die|hie|vie)s$/i, "\\1"],
+        [/\A(lie|belie|overlie|underlie)s$/i, "\\1"],
+        [/\A(tie|untie)s$/i, "\\1"],
+        [/\A(dis|gas)ses$/i, "\\1"],
+        [/(.*echo|veto)es$/i, "\\1"],
+        [/(.*douche)s$/i, "\\1"],
+        [/(.*focus)es$/i, "\\1"],
+        [/(.*precis)es$/i, "\\1"],
+        [/(.*quiz)zes$/i, "\\1"],
+        [/(.*stymie)s$/i, "\\1"],
+        [/(.*sk)ies$/i, "\\1y"],
+        [/(.*whiz)zes$/i, "\\1"]
+      ]
+
+      @plural_rules = [
+        [/(.*[aeiou]y)s$/i, "\\1"],
+        [/(.*[aiurywnopl]se)s$/i, "\\1"],
+        [/(.*[cs]h)es$/i, "\\1"],
+        [/(.*[sx])es$/i, "\\1"],
+        # [/(.*oe)s$/i, "\\1"],
+        [/(.*zz)es$/i, "\\1"],
+        [/(.*[il]tz)es$/i, "\\1"],
+        [/(.*ue)s$/i, "\\1"],
+        [/(.*[gk]ie)s$/i, "\\1"],
+        [/(.*all)ies$/i, "\\1y"],
+        [/(.*)ies$/i, "\\1y"],
+        [/(.*y)s$/i, "\\1"],
+        [/(.*[thn]oe)s$/i, "\\1"],
+        [/(.*o)es$/i, "\\1"],
+        [/(.+[^s])s$/i, "\\1"],
+        [/(.+)s$/i, "\\1"]
+      ]
+
+      @plurals = @plural_irregular + @plural_rules
+
+      # A set of uninflected verbs
+      #
+      # @return [Array[String]]
+      #
+      # @api private
+      def uninflected
+        @uninflected
+      end
+      module_function :uninflected
+
+      # A list of singular rules
+      #
+      # @return [Array[String]]
+      #
+      # @api private
+      def singulars
+        @singulars
+      end
+      module_function :singulars
+
+      # A list of plural rules
+      #
+      # @return [Array[String]]
+      #
+      # @api private
+      def plurals
+        @plurals
+      end
+      module_function :plurals
+    end # Verbs
+  end # Inflection
+end # Strings

data/lib/strings/inflection/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Strings
+  module Inflection
+    VERSION = "0.1.0"
+  end
+end

data/strings-inflection.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "strings/inflection/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "strings-inflection"
+  spec.version       = Strings::Inflection::VERSION
+  spec.authors       = ["Piotr Murach"]
+  spec.email         = ["me@piotrmurach.com"]
+  spec.summary       = %q{Inflect English nouns and verbs.}
+  spec.description   = %q{Inflect English nouns and verbs. The algorithms are based on the analysis of 7,000 most frequently used nouns and 6,000 most used verbs in English language.}
+  spec.homepage      = "https://github.com/piotrmurach/strings-inflection"
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+    spec.metadata["changelog_uri"] = "https://github.com/piotrmurach/strings-inflection/blob/master/CHANGELOG.md"
+    spec.metadata["documentation_uri"] = "https://www.rubydoc.info/gems/strings-inflection"
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/piotrmurach/strings-inflection"
+  end
+
+  spec.files         = Dir["lib/**/*.rb"]
+  spec.files        += Dir["tasks/*", "strings-inflection.gemspec"]
+  spec.files        += Dir["README.md", "CHANGELOG.md", "LICENSE.txt", "Rakefile"]
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", ">= 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/tasks/console.rake

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+desc "Load gem inside irb console"
+task :console do
+  require "irb"
+  require "irb/completion"
+  require File.join(__FILE__, "../../lib/strings-inflection")
+  ARGV.clear
+  IRB.start
+end
+task c: %w[ console ]

data/tasks/coverage.rake

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+desc "Measure code coverage"
+task :coverage do
+  begin
+    original, ENV["COVERAGE"] = ENV["COVERAGE"], "true"
+    Rake::Task["spec"].invoke
+  ensure
+    ENV["COVERAGE"] = original
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+begin
+  require "rspec/core/rake_task"
+
+  desc "Run all specs"
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.pattern = "spec/{unit,integration}{,/*/**}/*_spec.rb"
+  end
+
+  namespace :spec do
+    desc "Run unit specs"
+    RSpec::Core::RakeTask.new(:unit) do |task|
+      task.pattern = "spec/unit{,/*/**}/*_spec.rb"
+    end
+
+    desc "Run integration specs"
+    RSpec::Core::RakeTask.new(:integration) do |task|
+      task.pattern = "spec/integration{,/*/**}/*_spec.rb"
+    end
+
+    desc "Run performance specs"
+    RSpec::Core::RakeTask.new(:perf) do |task|
+      task.pattern = "spec/perf{,/*/**}/*_spec.rb"
+    end
+  end
+
+rescue LoadError
+  %w[spec spec:unit spec:integration].each do |name|
+    task name do
+      $stderr.puts "In order to run #{name}, do `gem install rspec`"
+    end
+  end
+end