flexus 1.0.0.beta.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d4fb081e1ddb588f626630927563e06b07bf29d2
+  data.tar.gz: 9a17ef6e6ec631441073dc6b018617d7677fe9f6
+SHA512:
+  metadata.gz: 8e17f42debb31c4392d530067560de527d8ee7d842aad65fd4400d5884e168332331fa953993f1f6479bdf759f87a4481a89e8160489e66b5ebeffb7ef4c5778
+  data.tar.gz: 7d2f42bec41028173062ef36fd3dcba84f923f98cd4c283de691024b235ff2ab169f7d5e361a9135f7240c0980c0ba60183e43f75fc450c58b7b8ada738e597c

data/.gitignore

@@ -0,0 +1,37 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## Rubinius
+*.rbc
+.rbx
+
+## PROJECT::GENERAL
+*.gem
+coverage
+profiling
+turbulence
+rdoc
+pkg
+tmp
+doc
+log
+.yardoc
+measurements
+
+## BUNDLER
+.bundle
+Gemfile.lock
+
+## PROJECT::SPECIFIC

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,37 @@
+language: ruby
+cache: bundler
+before_install: gem install bundler
+bundler_args: --without yard guard benchmarks
+script: "bundle exec rake ci:metrics"
+rvm:
+  - 2.1.8
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
+  - ruby-head
+  - rbx-3.81
+notifications:
+  irc:
+    channels:
+      - "irc.freenode.org#rom-rb"
+    on_success: never
+    on_failure: change
+  email:
+    on_success: never
+    on_failure: change
+matrix:
+  include:
+    - rvm: jruby-19mode
+      env: JRUBY_OPTS="$JRUBY_OPTS --debug"
+    - rvm: jruby-head
+      env: JRUBY_OPTS="$JRUBY_OPTS --debug"
+    - rvm: 2.4.0
+      env: WITH_MUTANT=true
+      script: "bundle exec rake ci" # include mutant
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx-3.81
+    - rvm: jruby-19mode
+    - rvm: jruby-head
+    - env: WITH_MUTANT=true
+  fast_finish: true

data/Changelog.md

@@ -0,0 +1,7 @@
+# v0.0.2 2013-01-20
+
+[change] Do not depend on backports
+
+# v0.0.1 2012-12-12
+
+First public release!

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec
+
+group :development, :test do
+  gem 'devtools', '~> 0.1.x'
+end

data/Guardfile

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+guard :bundler do
+  watch('Gemfile')
+end
+
+guard :rspec do
+  # run all specs if the spec_helper or supporting files files are modified
+  watch('spec/spec_helper.rb')                      { 'spec' }
+  watch(%r{\Aspec/(?:lib|support|shared)/.+\.rb\z}) { 'spec' }
+
+  # run unit specs if associated lib code is modified
+  watch(%r{\Alib/(.+)\.rb\z})                                         { |m| Dir["spec/unit/#{m[1]}"] }
+  watch("lib/#{File.basename(File.expand_path('../', __FILE__))}.rb") { 'spec'                       }
+
+  # run a spec if it is modified
+  watch(%r{\Aspec/(?:unit|integration)/.+_spec\.rb\z})
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) The rails, merb & datamapper team
+
+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,78 @@
+flexus
+========
+
+[![Gem Version](https://badge.fury.io/rb/flexus.png)][gem]
+[![Build Status](https://secure.travis-ci.org/Ptico/flexus.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/badges/github.com/Ptico/flexus.svg)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/Ptico/flexus.png)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/Ptico/flexus/badge.png?branch=master)][coveralls]
+
+[gem]: https://rubygems.org/gems/flexus
+[travis]: https://travis-ci.org/Ptico/flexus
+[gemnasium]: https://gemnasium.com/Ptico/flexus
+[codeclimate]: https://codeclimate.com/github/Ptico/flexus
+[coveralls]: https://coveralls.io/r/Ptico/flexus
+
+This gem is a resurrection of [inflecto](https://github.com/mbj/inflecto)
+
+Inflecto is a standalone inflector ripped out from [dm-core](https://github.com/datamapper/dm-core)
+
+The dm-core inflector originated from [extlib](https://github.com/datamapper/extlib)
+
+The extlib inflecto originated from [active_support](https://github.com/rails/rails)
+
+Migration from `inflecto`
+-------------------------
+
+Remove inflecto and add flexus to your Gemfile.
+
+```ruby
+gem 'flexus', '1.0.0'
+```
+
+At your code, change all `Inflecto` references to `Flexus` and it should work out of the box for flexus version 1.0.0. Please report any issues.
+
+Flexus will try the best to respect semantic versioning as http://semver.org/
+So, expect api breaking changes on major version releases.
+
+We'll make pre release gems for 2.0.0 version. To experiment with that you should add this to your Gemfile.
+
+```ruby
+gem 'flexus', '>= 2.0.0.beta'
+```
+
+Examples
+--------
+
+```ruby
+require 'flexus'
+
+Flexus.underscore("CamelCase")
+# => "camel_case"
+```
+
+Credits
+-------
+
+The rails, merb & datamapper team
+
+The original gem was extracted and maintained by Markus Schirp ([mbj](https://github.com/mbj)) with help from [indrekj](https://github.com/indrekj).
+
+Current maintainers: Andrii Savchenko [Ptico](https://github.com/Ptico) and Abinoam P. Marques Jr. [abinoam](https://github.com/abinoam)
+
+Contributing
+-------------
+
+* If you want your code merged into the mainline, please discuss the proposed changes with me before doing any work on it. This library is still in early development, and the direction it is going may not always be clear. Some features may not be appropriate yet, may need to be deferred until later when the foundation for them is laid, or may be more applicable in a plugin.
+* Fork the project.
+* Make your feature addition or bug fix.
+  * Follow this [style guide](https://github.com/dkubb/styleguide).
+* Add specs for it. This is important so I don't break it in a future version unintentionally. Tests must cover all branches within the code, and code must be fully covered.
+* Commit, do not mess with Rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Run "rake ci". This must pass and not show any regressions in the metrics for the code to be merged.
+* Send me a pull request. Bonus points for topic branches.
+
+License
+-------
+
+See LICENSE.txt for details

data/Rakefile

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "devtools"
+
+# rake metrics and rake ci
+Devtools.init_rake_tasks
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/TODO

@@ -0,0 +1 @@
+* Find the guys to mention in credits.

data/flexus.gemspec

@@ -0,0 +1,33 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "flexus/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "flexus"
+  spec.version     = Flexus::VERSION
+  spec.authors     =
+    [ "The rails, merb & datamapper team",
+      "Markus Schirp",
+      "Andrii Savchenko",
+      "Abinoam P. Marques Jr." ]
+  spec.email       = ["andrey@aejis.eu", "abinoam@gmail.com"]
+  spec.description = "Inflector for strings"
+  spec.summary     = spec.description
+  spec.homepage    = "https://github.com/Ptico/flexus"
+  spec.license     = "MIT"
+
+  spec.require_paths    = %w[lib]
+
+  spec.files       = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features|config)/})
+  end
+
+  spec.extra_rdoc_files = %w[LICENSE.txt README.md TODO]
+
+  spec.required_ruby_version = ">= 2.1"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/flexus/defaults.rb

@@ -0,0 +1,59 @@
+Flexus.inflections do |inflect|
+  inflect.plural(/\z/, 's')
+  inflect.plural(/s\z/i, 's')
+  inflect.plural(/(ax|test)is\z/i, '\1es')
+  inflect.plural(/(octop|vir)us\z/i, '\1i')
+  inflect.plural(/(octop|vir)i\z/i, '\1i')
+  inflect.plural(/(alias|status)\z/i, '\1es')
+  inflect.plural(/(bu)s\z/i, '\1ses')
+  inflect.plural(/(buffal|tomat)o\z/i, '\1oes')
+  inflect.plural(/([ti])um\z/i, '\1a')
+  inflect.plural(/([ti])a\z/i, '\1a')
+  inflect.plural(/sis\z/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)\z/i, '\1\2ves')
+  inflect.plural(/(hive)\z/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y\z/i, '\1ies')
+  inflect.plural(/(x|ch|ss|sh)\z/i, '\1es')
+  inflect.plural(/(matr|vert|ind)(?:ix|ex)\z/i, '\1ices')
+  inflect.plural(/([m|l])ouse\z/i, '\1ice')
+  inflect.plural(/([m|l])ice\z/i, '\1ice')
+  inflect.plural(/^(ox)\z/i, '\1en')
+  inflect.plural(/^(oxen)\z/i, '\1')
+  inflect.plural(/(quiz)\z/i, '\1zes')
+
+  inflect.singular(/s\z/i, '')
+  inflect.singular(/(n)ews\z/i, '\1ews')
+  inflect.singular(/([ti])a\z/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses\z/i, '\1\2sis')
+  inflect.singular(/(^analy)ses\z/i, '\1sis')
+  inflect.singular(/([^f])ves\z/i, '\1fe')
+  inflect.singular(/(hive)s\z/i, '\1')
+  inflect.singular(/(tive)s\z/i, '\1')
+  inflect.singular(/([lr])ves\z/i, '\1f')
+  inflect.singular(/([^aeiouy]|qu)ies\z/i, '\1y')
+  inflect.singular(/(s)eries\z/i, '\1eries')
+  inflect.singular(/(m)ovies\z/i, '\1ovie')
+  inflect.singular(/(ss)\z/i, '\1')
+  inflect.singular(/(x|ch|ss|sh)es\z/i, '\1')
+  inflect.singular(/([m|l])ice\z/i, '\1ouse')
+  inflect.singular(/(bus)es\z/i, '\1')
+  inflect.singular(/(o)es\z/i, '\1')
+  inflect.singular(/(shoe)s\z/i, '\1')
+  inflect.singular(/(cris|ax|test)es\z/i, '\1is')
+  inflect.singular(/(octop|vir)i\z/i, '\1us')
+  inflect.singular(/(alias|status)es\z/i, '\1')
+  inflect.singular(/^(ox)en/i, '\1')
+  inflect.singular(/(vert|ind)ices\z/i, '\1ex')
+  inflect.singular(/(matr)ices\z/i, '\1ix')
+  inflect.singular(/(quiz)zes\z/i, '\1')
+  inflect.singular(/(database)s\z/i, '\1')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('man', 'men')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+  inflect.irregular('cow', 'cows')
+
+  inflect.uncountable(%w(hovercraft moose milk rain Swiss grass equipment information rice money species series fish sheep jeans))
+end

data/lib/flexus/inflections.rb

@@ -0,0 +1,232 @@
+module Flexus
+  # A singleton instance of this class is yielded by Flexus.inflections, which can then be used to specify additional
+  # inflection rules. Examples:
+  #
+  #   Flexus.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  #
+  class Inflections
+
+    # Return instance
+    #
+    # @return [Inflections]
+    #
+    # @api private
+    #
+    def self.instance
+      @__instance__ ||= new
+    end
+
+    # Return plurals
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    attr_reader :plurals
+
+    # Return singulars
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    attr_reader :singulars
+
+    # Return uncountables
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    attr_reader :uncountables
+
+    # Return humans
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    #
+    attr_reader :humans
+
+    # Initialize object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize
+      @plurals      = RulesCollection.new
+      @singulars    = RulesCollection.new
+      @humans       = RulesCollection.new
+      @uncountables = Set[]
+    end
+
+    # Add a new plural role
+    #
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # @param [String, Regexp] rule
+    # @param [String, Regexp] replacement
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def plural(rule, replacement)
+      rule(rule, replacement, plurals)
+
+      self
+    end
+
+    # Add a new singular rule
+    #
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # @param [String, Regexp] rule
+    # @param [String, Regexp] replacement
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def singular(rule, replacement)
+      rule(rule, replacement, singulars)
+
+      self
+    end
+
+    # Add a new irregular pluralization
+    #
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    #
+    # @example
+    #
+    #   Flexus.irregular('octopus', 'octopi')
+    #   Flexus.irregular('person', 'people')
+    #
+    # @param [String] singular
+    # @param [String] plural
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def irregular(singular, plural)
+      uncountables.delete(singular)
+      uncountables.delete(plural)
+
+      add_irregular(singular, plural, plurals)
+      add_irregular(plural, singular, singulars)
+
+      self
+    end
+
+    # Add uncountable words
+    #
+    # Uncountable will not be inflected
+    #
+    # @example
+    #
+    #   Flexus.uncountable "money"
+    #   Flexus.uncountable "money", "information"
+    #   Flexus.uncountable %w( money information rice )
+    #
+    # @param [Enumerable<String>] words
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def uncountable(*words)
+      uncountables.merge(words.flatten)
+
+      self
+    end
+
+    # Add humanize rule
+    #
+    # Specifies a humanized form of a string by a regular expression rule or by a string mapping.
+    # When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
+    # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
+    #
+    # @example
+    #   Flexus.human(/_cnt$/i, '\1_count')
+    #   Flexus.human("legacy_col_person_name", "Name")
+    #
+    # @param [String, Regexp] rule
+    # @param [String, Regexp] replacement
+    #
+    # @api private
+    #
+    # @return [self]
+    #
+    def human(rule, replacement)
+      humans.insert(0, [rule, replacement])
+      self
+    end
+
+    # Clear all inflection rules
+    #
+    # @example
+    #
+    #   Flexus.clear
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def clear
+      initialize
+      self
+    end
+
+    private
+
+    # Add irregular inflection
+    #
+    # @param [String] rule
+    # @param [String] replacement
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def add_irregular(rule, replacement, target)
+      head, *tail = rule.chars.to_a
+      rule(/(#{head})#{tail.join}\z/i, '\1' + replacement[1..-1], target)
+    end
+
+    # Add a new rule
+    #
+    # @param [String, Regexp] rule
+    # @param [String, Regexp] replacement
+    # @param [Array] target
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def rule(rule, replacement, target)
+      uncountables.delete(rule)
+      uncountables.delete(replacement)
+
+      target.insert(0, [rule, replacement])
+    end
+
+  end
+end

data/lib/flexus/rules_collection.rb

@@ -0,0 +1,38 @@
+module Flexus
+  # Wraps inflections array
+  #
+  class RulesCollection
+    extend Forwardable
+
+    def_delegators :@collection,
+      :each, :insert, :empty?,
+      :size, :last, :include?
+
+    def initialize(*args)
+      @collection = Array.new(*args)
+    end
+
+    # Applies first found rule to given word
+    #
+    # @param [String] word
+    #
+    # @return [String]
+    #   modified word
+    #
+    # @api private
+    #
+    def apply_to(word)
+      result = word.dup
+      each { |rule, replacement| break if result.gsub!(rule, replacement) }
+      result
+    end
+
+    def ==(other)
+      @collection == other.to_a
+    end
+
+    def to_a
+      @collection.dup
+    end
+  end
+end

data/lib/flexus/version.rb

@@ -0,0 +1,3 @@
+module Flexus
+  VERSION = "1.0.0.beta.1"
+end

data/lib/flexus.rb

@@ -0,0 +1,331 @@
+require 'set'
+
+# The Flexus transforms words from singular to plural, class names to table names, modularized class names to ones without,
+# and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
+# in inflections.rb.
+#
+# The Rails core team has stated patches for the inflections library will not be accepted
+# in order to avoid breaking legacy applications which may be relying on errant inflections.
+# If you discover an incorrect inflection and require it for your application, you'll need
+# to correct it yourself (explained below).
+module Flexus
+
+  # Convert input to UpperCamelCase
+  #
+  # Will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  # @param [String] input
+  #
+  # @example
+  #   Flexus.camelize("data_mapper")        # => "DataMapper"
+  #   Flexus.camelize("data_mapper/errors") # => "DataMapper::Errors"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.camelize(input)
+    input.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:\A|_)(.)/) { $1.upcase }
+  end
+
+  # Convert input to underscored, lowercase string
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # @param [String] input
+  #
+  # @example
+  #   Flexus.underscore("DataMapper")         # => "data_mapper"
+  #   Flexus.underscore("DataMapper::Errors") # => "data_mapper/errors"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.underscore(input)
+    word = input.gsub(/::/, '/')
+    underscorize(word)
+  end
+
+  # Convert input underscores to dashes
+  #
+  # @param [String] input
+  #
+  # @example
+  #   Flexus.dasherize("foo_bar") # => "foo-bar"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.dasherize(input)
+    input.tr('_', '-')
+  end
+
+  # Return unscoped constant name
+  #
+  # @param [String] input
+  #
+  # @example
+  #
+  #   Flexus.demodulize("DataMapper::Error") # => "Error"
+  #   Flexus.demodulize("DataMapper")        # => "DataMapper"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.demodulize(input)
+    input.split('::').last
+  end
+
+  # Creates a foreign key name
+  #
+  # @param [String] input
+  #
+  # @example
+  #
+  #   Flexus.foreign_key("Message") => "message_id"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.foreign_key(input)
+    "#{underscorize(demodulize(input))}_id"
+  end
+
+  # Find a constant with the name specified in the argument string
+  #
+  # The name is assumed to be the one of a top-level constant, constant scope of caller is ignored
+  #
+  # @param [String] input
+  #
+  # @example
+  #
+  #   Flexus.constantize("Module")            # => Module
+  #   Flexus.constantize("DataMapper::Error") # => DataMapper::Error
+  #
+  # @return [Class, Module]
+  #
+  # @api public
+  #
+  def self.constantize(input)
+    names = input.split('::')
+    names.shift if names.first.empty?
+
+    names.inject(Object) do |constant, name|
+      if constant.const_defined?(name, false)
+        constant.const_get(name)
+      else
+        constant.const_missing(name)
+      end
+    end
+  end
+
+  ORDINALIZE_TH = (4..16).to_set.freeze
+
+  # Convert a number into an ordinal string
+  #
+  # @param [Fixnum] number
+  #
+  # @example
+  #
+  #   ordinalize(1)     # => "1st"
+  #   ordinalize(2)     # => "2nd"
+  #   ordinalize(1002)  # => "1002nd"
+  #   ordinalize(1003)  # => "1003rd"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.ordinalize(number)
+    abs_value = number.abs
+
+    if ORDINALIZE_TH.include?(abs_value % 100)
+      "#{number}th"
+    else
+      case abs_value % 10
+        when 1; "#{number}st"
+        when 2; "#{number}nd"
+        when 3; "#{number}rd"
+      end
+    end
+  end
+
+  # Yields a singleton instance of Flexus::Inflections
+  #
+  # @example
+  #
+  #   Flexus.inflections do |inflect|
+  #     inflect.uncountable "rails"
+  #   end
+  #
+  # @return [Flexus::Inflections]
+  #
+  # @api public
+  #
+  def self.inflections
+    instance = Inflections.instance
+    block_given? ? yield(instance) : instance
+  end
+
+  # Convert input word string to plural
+  #
+  # @param [String] word
+  #
+  # @example
+  #
+  #   Flexus.pluralize("post")         # => "posts"
+  #   Flexus.pluralize("octopus")      # => "octopi"
+  #   Flexus.pluralize("sheep")        # => "sheep"
+  #   Flexus.pluralize("words")        # => "words"
+  #   Flexus.pluralize("CamelOctopus") # => "CamelOctopi"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.pluralize(word)
+    return word if uncountable?(word)
+    inflections.plurals.apply_to(word)
+  end
+
+  # Convert word to singular
+  #
+  # @param [String] word
+  #
+  # @example
+  #
+  #   Flexus.singularize("posts") # => "post"
+  #   Flexus.singularize("octopi") # => "octopus"
+  #   Flexus.singularize("sheep") # => "sheep"
+  #   Flexus.singularize("word") # => "word"
+  #   Flexus.singularize("CamelOctopi") # => "CamelOctopus"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.singularize(word)
+    return word if uncountable?(word)
+    inflections.singulars.apply_to(word)
+  end
+
+  # Humanize string
+  #
+  # @param [String] input
+  #
+  # capitalizes the first word and turns underscores into spaces and strips a # trailing "_id", if any.
+  # Like +titleize+, this is meant for creating pretty output.
+  #
+  # @example
+  #
+  #   Flexus.humanize("employee_salary") # => "Employee salary"
+  #   Flexus.humanize("author_id")       # => "Author"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.humanize(input)
+    result = inflections.humans.apply_to(input)
+    result.gsub!(/_id\z/, "")
+    result.tr!('_', " ")
+    result.capitalize!
+    result
+  end
+
+  # Tabelize input string
+  #
+  # @param [String] input
+  #
+  # Create the name of a table like Rails does for models to table names.
+  # This method # uses the +pluralize+ method on the last word in the string.
+  #
+  # @example
+  #
+  #   Flexus.tableize("RawScaledScorer") # => "raw_scaled_scorers"
+  #   Flexus.tableize("egg_and_ham")     # => "egg_and_hams"
+  #   Flexus.tableize("fancyCategory")   # => "fancy_categories"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.tableize(input)
+    word = input.gsub(/::/, '_')
+    pluralize(underscorize(word))
+  end
+
+  # Classify input
+  #
+  # Create a class name from a plural table name like Rails does for table names to models.
+  # Note that this returns a string and not a Class.
+  #
+  # To convert to an actual class # follow +classify+ with +constantize+.
+  #
+  # @examples:
+  #
+  #   Flexus.classify("egg_and_hams") # => "EggAndHam"
+  #   Flexus.classify("posts")        # => "Post"
+  #
+  #   # Singular names are not handled correctly:
+  #   Flexus.classify("business")     # => "Busines"
+  #
+  # @return [String]
+  #
+  # @api public
+  #
+  def self.classify(table_name)
+    # strip out any leading schema name
+    camelize(singularize(table_name.sub(/.*\./, '')))
+  end
+
+  # Test if word is uncountable
+  #
+  # @example
+  #
+  #   Flexus.uncountable?('rice') #=> true
+  #   Flexus.uncountable?('apple') #=> false
+  #
+  # @param [String] word
+  #
+  # @return [Boolean]
+  #   true, if word is uncountable
+  #
+  # @api public
+  #
+  def self.uncountable?(word)
+    word.empty? || inflections.uncountables.include?(word.downcase)
+  end
+
+  # Convert input to underscored, lowercase string
+  #
+  # Contains main logic for .underscore and .tableize
+  # Does nothing with '::' divider
+  #
+  # @param [String] input
+  #
+  # @example
+  #   Flexus.underscorize("DataMapper")         # => "data_mapper"
+  #   Flexus.underscorize("DataMapper::Errors") # => "data_mapper::errors"
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def self.underscorize(word)
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!('-', '_')
+    word.downcase!
+    word
+  end
+  private_class_method :underscorize
+end
+
+require 'flexus/rules_collection'
+require 'flexus/inflections'
+require 'flexus/defaults'

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: flexus
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta.1
+platform: ruby
+authors:
+- The rails, merb & datamapper team
+- Markus Schirp
+- Andrii Savchenko
+- Abinoam P. Marques Jr.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Inflector for strings
+email:
+- andrey@aejis.eu
+- abinoam@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+- TODO
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Changelog.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO
+- flexus.gemspec
+- lib/flexus.rb
+- lib/flexus/defaults.rb
+- lib/flexus/inflections.rb
+- lib/flexus/rules_collection.rb
+- lib/flexus/version.rb
+homepage: https://github.com/Ptico/flexus
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Inflector for strings
+test_files: []