pluralizr 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 17c077ed1850b4d0fe7b41ab7f065069a8280f1a
+  data.tar.gz: 362d60c7ffc856b170182712236b7bb3364ade51
+SHA512:
+  metadata.gz: 61d3f86e66377b7983533059fc88843cd238a159113972d4050ad9f36376df2b2de154836b6ffc885410418908357bea244f2c1aefe44e6fc031946a210899f0
+  data.tar.gz: bd68975f2d1f7612b140384c7c31106714c8c6411800701c84d2e0b09174c4bb2898c6fb693dc54e3f2b58d2e38444d12d0b714b9af4ef2afe544b6eff9771bf

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.13.6

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 0.2.0
+* Update homepage URL in gemspec
+
+## 0.1.0
+* Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Johnny Hu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# Pluralizr
+
+Pluralizr is a gem that takes a single word and returns the pluralized version of that word. It attempts to take into account various rules—like, handling words that end in 'y' where the 'y' is preceded by a vowel or consonant (i.e., `day` -> `days` versus `baby` -> `babies`)—as well as words of French, Greek and Latin origins.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pluralizr'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pluralizr
+
+## Usage
+
+Require Pluralizr in your application (or in `irb`).
+
+```ruby
+require 'pluralizr'
+```
+
+Then, simply use the `Pluralizr.pluralize()` method to get pluralizing!
+
+```ruby
+$ Pluralizr.pluralize('day')
+=> "days"
+
+$ Pluralizr.pluralize('baby')
+=> "babies"
+
+$ Pluralizr.pluralize('foot')
+=> "feet"
+
+$ Pluralizr.pluralize('child')
+=> "children"
+
+$ Pluralizr.pluralize('pundit')
+=> "pundits"
+
+$ Pluralizr.pluralize('alumnus')
+=> "alumni"
+
+$ Pluralizr.pluralize('criterion')
+=> "criteria"
+```
+
+## Contributing
+
+Making a contribution is easy and happily welcomed. Simply submit a pull request on GitHub at https://github.com/srndptylabs/pluralizr/pulls. Here are a few examples of things worth submitting a pull request for:
+
+* a word that's not pluralizing as expected
+* a word that should be added to the exception list
+* any bugs you encounter
+* improvements to the README file
+* and whatever else you can think of!
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pluralizr"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/pluralizr.rb

@@ -0,0 +1,146 @@
+require "pluralizr/version"
+require "pluralizr/rules"
+require "pluralizr/lists"
+require "pluralizr/exceptions"
+
+
+# A module that takes a single word and returns the pluralized version
+# of that word. It attempts to take into account various rules—like,
+# handling words that end in 'y' where the 'y' is preceded by a vowel
+# or consonant (i.e., +day+ -> +days+ versus +baby+ -> +babies+)—as well as
+# words of French, Greek and Latin origins.
+
+module Pluralizr
+
+  # Pluralizes the object passed in or returns an error if an exception is raised.
+  #
+  # ==== Parameters:
+  # word::
+  #   The object passed in.
+  # ==== Returns:
+  # Either an error message, if any exceptions are raised via
+  # Pluralizr.check_for_errors method, or the appropriate plural
+  # version of the word passed into the method.
+
+  def self.pluralize(word)
+
+    check_for_errors(word)
+
+    case
+    when word.is_irregular? then return IRREGULAR_WORDS[word]
+    when word.has_same_singular_and_plural_form? || word.only_has_plural_form?
+      return word
+    when word.ends_with_vowel_and_y_or_o? || word.ends_with_double_vowel_and_f?
+      return word.insert(-1, 's')
+    else
+      RULES.each do |rule, props| 
+        return find_plural_of(word, props) if word.end_with?(rule)
+      end
+    end
+    return find_plural_of(word, RULES['default'])
+  end
+
+  # Returns +true+ if the word (the caller) ends in a vowel plus
+  # either a 'y' or an 'o'. For example, +day+ and +valley+ or 
+  # +stereo+ and +tattoo+.
+
+  def ends_with_vowel_and_y_or_o?
+    self.match(/[aeiouy][oy]$/i)
+  end
+
+  # Returns +true+ if the word (the caller) ends in a double vowel 
+  # plus 'f'. For example, +proof+ or +handkerchief+.
+
+  def ends_with_double_vowel_and_f?
+    self.match(/[aeiouy]+[f]$/i)
+  end
+
+  # Returns +true+ if the word (the caller) is found in
+  # the IRREGULAR_WORDS hash.
+
+  def is_irregular?
+    IRREGULAR_WORDS.include?(self)
+  end
+
+  # Returns +true+ if the word (the caller) is found in
+  # the PLURAL_ONLY_WORDS hash.
+
+  def only_has_plural_form?
+    PLURAL_ONLY_WORDS.include?(self)
+  end
+
+  # Returns +true+ if the word (the caller) is found in
+  # the SINGULAR_AND_PLURAL_FORMS_ARE_THE_SAME hash.
+
+  def has_same_singular_and_plural_form?
+    SINGULAR_AND_PLURAL_FORMS_ARE_THE_SAME.include?(self)
+  end
+
+  protected
+
+  # Determines which implementation method to use based on
+  # several factors: whether or not the rule from the RULES
+  # hash matching the word being passed in has an exceptions list
+  # and, if so, whether the word is on that list or not.
+  # ==== Parameters:
+  # word::
+  #   A String representing the original word passed in.
+  # props::
+  #   A hash value representing the properties of the rule,
+  # from the RULES hash, matching the word passed in.
+  # ==== Returns:
+  # The pluralized form of the original word passed in.
+
+  def self.find_plural_of(word, props)
+    if !props[:has_exception_list]
+      convert_ending_of(word, props[:with_ending], props[:offset])
+    elsif EXCEPTIONS_LIST.include?(word)
+      EXCEPTIONS_LIST[word]
+    else
+      convert_ending_of(word, props[:with_ending], props[:offset])
+    end
+  end
+
+  # Checks if word passed into the Pluralizr.pluralize method
+  # raises any errors. Currently, the following errors are checked:
+  # Pluralizr::InvalidTypeError, Pluralizr::InvalidStringError,
+  # and Pluralizr::TooManyWordsError.
+  #
+  # ==== Parameters:
+  # word::
+  #   A String representing the original word passed in.
+  # ==== Returns:
+  # An error message and backtrace if an error is raised.
+
+  def self.check_for_errors(word)
+    raise InvalidTypeError   if !word.is_a? String
+    raise InvalidStringError if word.match(/^[\d\W_]/)
+    raise TooManyWordsError  if !word.match(/^[a-z]+$/i)
+  end
+
+  # Converts the word passed into the Pluralizr.pluralize method
+  # into its plural form.
+  #
+  # ==== Parameters:
+  # word::
+  #   A String representing the original word passed in.
+  # with_ending::
+  #   A String representing the word's plural form ending.
+  # offset::
+  #   An Integer representing the number of letters to remove from the
+  #   end of the original word, before appending the plural form ending.
+  #
+  # ==== Returns:
+  # A string representing the pluralized form of the original word passed in.
+
+  def self.convert_ending_of(word, with_ending, offset)
+    word[0..offset].insert(-1, with_ending)
+  end
+
+end
+
+# Includes Pluralizr in String class.
+
+class String
+  include Pluralizr
+end

data/lib/pluralizr/exceptions.rb

@@ -0,0 +1,29 @@
+module Pluralizr
+
+  # A TypeError meant to inform users when the object passed into the Pluralizr.pluralize method isn't a String.
+  # For example, integers, boolean values, arrays, etc.
+
+  class InvalidTypeError < TypeError
+    def initialize(msg="argument must be a String")
+      super
+    end
+  end
+
+  # A TypeError meant to inform users when the object passed into the Pluralizr.pluralize method doesn't begin with a letter.
+  # For example, words like +32numbersfirst+ and +.specialcharactersfirst+
+
+  class InvalidStringError < TypeError
+    def initialize(msg="string must begin with a letter")
+      super
+    end
+  end
+
+  # An ArgumentError meant to inform users when the object passed into the Pluralizr.pluralize method is a String, but contains more than one word.
+  # For example, strings like <tt>"More than one word"</tt>.
+
+  class TooManyWordsError < ArgumentError
+    def initialize(msg="argument contains too many words")
+      super
+    end
+  end
+end

data/lib/pluralizr/lists.rb

@@ -0,0 +1,111 @@
+module Pluralizr
+
+  # List of words that are exceptions to the rules in the RULES constant variable hash.
+
+  EXCEPTIONS_LIST = {
+    # SXZCHSH_EXCEPTIONS
+    'quiz'          =>    'quizzes',
+    'stomach'       =>    'stomachs',
+    'epoch'         =>    'epochs',
+
+    # FE_F_EXCEPTIONS
+    'chef'          =>    'chefs',
+    'dwarf'         =>    'dwarfs',
+    'gulf'          =>    'gulfs',
+    'hoof'          =>    'hooves',
+    'safe'          =>    'safes',
+    'surf'          =>    'surfs',
+    'turf'          =>    'turfs',
+
+    # EX_EXCEPTIONS
+    'annex'         =>    'annexes',
+    'complex'       =>    'complexes',
+    'duplex'        =>    'duplexes',
+    'hex'           =>    'hexes',
+    'index'         =>    'indexes',
+    'sex'           =>    'sexes',
+
+    # O_EXCEPTIONS
+    'albino'        =>    'albinos',
+    'armadillo'     =>    'armadillos',
+    'auto'          =>    'autos',
+    'cello'         =>    'cellos',
+    'combo'         =>    'combos',
+    'ego'           =>    'egos',
+    'halo'          =>    'halos',
+    'inferno'       =>    'infernos',
+    'lasso'         =>    'lassos',
+    'memento'       =>    'mementos',
+    'memo'          =>    'memos',
+    'piano'         =>    'pianos',
+    'photo'         =>    'photos',
+    'pro'           =>    'pros',
+    'silo'          =>    'silos',
+    'solo'          =>    'solos',
+    'taco'          =>    'tacos',
+    'tuxedo'        =>    'tuxedos',
+    'typo'          =>    'typos',
+
+    # UM_EXCEPTIONS
+    'album'         =>    'albums',
+    'stadium'       =>    'stadiums',
+    'minimum'       =>    'minimums',
+    'maximum'       =>    'maximums',
+    'premium'       =>    'premiums',
+    'vacuum'        =>    'vacuums',
+
+    # STRICT_LATIN_ORIGINS
+    'radius'        =>    'radii',
+    'alumnus'       =>    'alumni',
+    'cactus'        =>    'cacti',
+    'fungus'        =>    'fungi',
+    'nucleus'       =>    'nuclei',
+    'genus'         =>    'genera',
+    'syllabus'      =>    'syllabi',
+    'alga'          =>    'algae',
+    'vertebra'      =>    'vertebrae',
+    'larva'         =>    'larvae',
+
+    # STRICT_GREEK_ORIGINS
+    'automaton'     =>    'automata',
+    'criterion'     =>    'criteria',
+    'phenomenon'    =>    'phenomena',
+
+    # ITALIAN_ORIGINS
+    'espresso'      =>    'espressos',
+    'pizza'         =>    'pizzas',
+    'risotto'       =>    'risottos',
+    'paparazzo'       =>    'paparazzi',
+    'spaghetto'       =>    'spaghetti'
+  }
+
+  # List of words whose plural form doesn't adhere to a rule in the RULES hash, but instead, often mutates the original word.
+  # For example, +mouse+ => +mice+. Or, +foot+ => +feet+.
+
+  IRREGULAR_WORDS = {
+    'child'         =>    'children',
+    'die'           =>    'dice',
+    'foot'          =>    'feet',
+    'goose'         =>    'geese',
+    'louse'         =>    'lice',
+    'man'           =>    'men',
+    'mouse'         =>    'mice',
+    'ox'            =>    'oxen',
+    'person'        =>    'people',
+    'that'          =>    'those',
+    'this'          =>    'these',
+    'tooth'         =>    'teeth',
+    'woman'         =>    'women'
+  }
+
+  # List of words whose plural form is the same as its singular form.
+  # For example, +deer+ is used in both singular and plural contexts.
+
+  SINGULAR_AND_PLURAL_FORMS_ARE_THE_SAME = %w(advice aircraft bison corn deer equipment evidence gold information jewelry kin legislation luck luggage moose music offspring sheep silver swine trousers trout wheat)
+
+  # List of words that only have a plural form. There is no singular form of the word.
+  # For example, the word +tweezers+ has no singular form. The word tweezer is actually a verb and not a noun.
+
+  PLURAL_ONLY_WORDS = %w(barracks bellows cattle deer dregs eyeglasses gallows headquarters mathematics means measles mumps news oats pants pliers pajamas scissors series shears shorts species tongs tweezers vespers)
+
+end

data/lib/pluralizr/rules.rb

@@ -0,0 +1,45 @@
+module Pluralizr
+
+  # Hash containing the various rules for specific word endings
+  # in the English language.
+  #--
+  # These endings are stored in the hash as keys. Each key has a set
+  # of properties as its value. These properties specify the word's
+  # plural form ending, how the plural form should be applied to the
+  # original word, and if there are any words considered exceptions
+  # to the particular rule.
+  #
+  # For example, given a word that ends in 'a', the pluralize() method
+  # will check for errors (see exceptions.rb) and special cases (see lists.rb),
+  # and then iterate through the RULES hash below. Since the word ends in
+  # 'a', it matches with the RULES['a'] key, and since this list contains an
+  # exceptions list, it checks if the word is on the list. If so, it returns
+  # the plural version of that word from the exceptions list. If not, it adds
+  # an 's' to the end of the original word and returns it.
+
+  RULES = {
+    'ia'        =>  { with_ending: 's',    offset: -1 },
+    'a'         =>  { with_ending: 's',    offset: -1, has_exception_list: true },
+    'ffe'       =>  { with_ending: 's',    offset: -1 },
+    'fe'        =>  { with_ending: 'ves',  offset: -3, has_exception_list: true },
+    'ff'        =>  { with_ending: 's',    offset: -1 },
+    'f'         =>  { with_ending: 'ves',  offset: -2, has_exception_list: true },
+    'ch'        =>  { with_ending: 'es',   offset: -1, has_exception_list: true },
+    'sh'        =>  { with_ending: 'es',   offset: -1, has_exception_list: true },
+    'um'        =>  { with_ending: 'a',    offset: -3, has_exception_list: true },
+    'tion'      =>  { with_ending: 's',    offset: -1 },
+    'on'        =>  { with_ending: 's',    offset: -1, has_exception_list: true },
+    'o'         =>  { with_ending: 'es',   offset: -1, has_exception_list: true },
+    'is'        =>  { with_ending: 'es',   offset: -3 },
+    'us'        =>  { with_ending: 'es',   offset: -1, has_exception_list: true },
+    's'         =>  { with_ending: 'es',   offset: -1, has_exception_list: true },
+    'eau'       =>  { with_ending: 's',    offset: -1 },
+    'ex'        =>  { with_ending: 'ices', offset: -3, has_exception_list: true },
+    'x'         =>  { with_ending: 'es',   offset: -1, has_exception_list: true },
+    'y'         =>  { with_ending: 'ies',  offset: -2 },
+    'z'         =>  { with_ending: 'es',   offset: -1, has_exception_list: true },
+    'irregular' =>  {                      offset: -1, has_exception_list: true },
+    'default'   =>  { with_ending: 's',    offset: -1 }
+  }
+
+end

data/lib/pluralizr/version.rb

@@ -0,0 +1,5 @@
+module Pluralizr
+  # Current gem version.
+
+  VERSION = "0.2.0"
+end

data/pluralizr.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pluralizr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pluralizr'
+  spec.version       = Pluralizr::VERSION
+  spec.license       = 'MIT'
+  spec.summary       = 'A gem that pluralizes the singular form of a word passed in.'
+  spec.description   = <<-EOF
+    Pluralizr is a gem that takes a single word and returns the pluralized version of that word. It takes into account various rules including words that end with the letter 'y'—where 'y' is preceded by a vowel or consonant—and words of French, Greek and Latin origins.
+  EOF
+  spec.homepage      = 'https://github.com/srndptylabs/pluralizr'
+
+  spec.authors       = ['Johnny Hu']
+  spec.email         = ['jgeehen.hu@gmail.com']
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: pluralizr
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Johnny Hu
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: "    Pluralizr is a gem that takes a single word and returns the pluralized
+  version of that word. It takes into account various rules including words that end
+  with the letter 'y'—where 'y' is preceded by a vowel or consonant—and words of French,
+  Greek and Latin origins.\n"
+email:
+- jgeehen.hu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/pluralizr.rb
+- lib/pluralizr/exceptions.rb
+- lib/pluralizr/lists.rb
+- lib/pluralizr/rules.rb
+- lib/pluralizr/version.rb
+- pluralizr.gemspec
+homepage: https://github.com/srndptylabs/pluralizr
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: A gem that pluralizes the singular form of a word passed in.
+test_files: []