lotus-utils 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75c83ed0bc5b3b7e00e70735e023117f38ef9d67
-  data.tar.gz: 17cd9f71360e17c3adddadf260c38fc8b27622b1
+  metadata.gz: c9cbb89b047bc9d6da31d644120a6314aae15e13
+  data.tar.gz: ec85522be16a248f320b93fe5ef0911f7de63853
 SHA512:
-  metadata.gz: 1d25381aa757c98d2549d8619a8ba7525f50d9a752b6473d8e329d8eabb7ada701ceecefae9b301136bdb71b2d836f1a6ee4ba8a0cdeaf71edb66ca127f127e9
-  data.tar.gz: cd21b6ea4701af1949fedad3f91b3d11579de79abef45bc6b4a7c66e8814ecaec88ab765bb0afce36b5804279e9d595124cc5998fdeeb0a47ab62ae3e0849846
+  metadata.gz: 529c56324efb450ead039cf3f1747e101d729a9dd8cef9876273acde10cdce5298a1f8a7c14d7136667e1fc9b2d713ec3a878fa6a96ae57a70c67d5c317f76b2
+  data.tar.gz: cc3c30a6aa45031df28cfc0c5b533ce8e3c9fc5d0b81e9893ac71ee845f15118901cc20b8c6b8baf0c24d33732dd8570ff4fa8aa3afc0bc776ca9673a3c40cd2

data/CHANGELOG.md

@@ -1,6 +1,22 @@
 # Lotus::Utils
 Ruby core extentions and class utilities for Lotus
 
+## v0.6.0 - 2016-01-12
+### Added
+- [Luca Guidi] Official support for Ruby 2.3
+- [Luca Guidi] Custom inflections
+- [Luca Guidi] Introduced `Lotus::Utils::Duplicable` as a safe dup logic for Ruby types
+- [Luca Guidi] Added `Lotus::Utils::String#rsub` replace rightmost occurrence
+
+### Fixed
+- [Luca Guidi] Fix `Lotus::Utils::PathPrefix#join` and `#relative_join` by rejecting arguments that are equal to the separator
+- [Karim Kiatlottiavi] Fix `Encoding::UndefinedConversionError` in `Lotus::Utils::Escape.encode`
+
+### Changed
+- [Luca Guidi] Deprecate Ruby 2.0 and 2.1
+- [Luca Guidi] Removed `Lotus::Utils::Callbacks#add` in favor of `#append`
+- [Luca Guidi] Removed pattern support for `Utils::Class.load!` (eg. `Articles(Controller|::Controller)`)
+
 ## v0.5.2 - 2015-09-30
 ### Added
 - [Luca Guidi] Added `Lotus::Utils::String#capitalize`

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright © 2014-2015 Luca Guidi
+Copyright © 2014-2016 Luca Guidi
 
 MIT License
 

data/README.md

@@ -1,3 +1,4 @@
+
 # Lotus::Utils
 
 Ruby core extentions and class utilities for [Lotus](http://lotusrb.org)
@@ -43,9 +44,78 @@ Or install it yourself as:
 ## Usage
 
 __Lotus::Utils__ is designed to enhance Ruby's code and stdlib.
-By default this gem doesn't load any code, you must require what you need.
+**By default this gem doesn't load any code, you must require what you need.**
+
+## Features
+
+### Lotus::Interactor
+
+Standardized Service Object with small interface and rich returning result. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Interactor)]
+
+### Lotus::Logger
+
+Enhanced version of Ruby's `Logger`. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Logger)]
+
+### Lotus::Utils::Attributes
+
+Set of attributes with indifferent access. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Attributes)]
+
+### Lotus::Utils::BasicObject
+
+Enhanced version of Ruby's `BasicObject`. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/BasicObject)]
+
+### Lotus::Utils::Callbacks
+
+Callbacks to decorate methods with `before` and `after` logic. It supports polymorphic callbacks (methods and procs). [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Callbacks)]
+
+### Lotus::Utils::Class
+
+Load classes from strings. It also supports namespaces. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Class)]
+
+### Lotus::Utils::ClassAttribute
+
+Inheritable class attributes. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/ClassAttribute)]
+
+### Lotus::Utils::Deprecation
+
+Deprecate Lotus features. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Deprecation)]
+
+### Lotus::Utils::Duplicable
+
+Safe `#dup` logic for Ruby objects. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Deprecation)]
+
+
+### Lotus::Utils::Escape
+
+Safe and fast escape for URLs, HTML content and attributes. Based on OWASP/ESAPI code. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Escape)]
+
+### Lotus::Utils::Hash
+
+Enhanced version of Ruby's `Hash`. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Hash)]
+
+### Lotus::Utils::IO
+
+Silence Ruby warnings. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/IO)]
+
+### Lotus::Utils::Inflector
+
+Complete and customizable english inflections (pluralization and singularization). [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Inflector)]
+
+### Lotus::Utils::Kernel
+
+Type coercions for most common Ruby types. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/Kernel)]
+
+### Lotus::Utils::LoadPaths
+
+Manage directories where to find Ruby source code or web static assets. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/LoadPaths)]
+
+### Lotus::Utils::PathPrefix
+
+Safe logic to manage relative URLs. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/PathPrefix)]
+
+### Lotus::Utils::String
 
-Please read the documentation of each module.
+Enhanced version of Ruby's `String`. [[API doc](http://www.rubydoc.info/gems/lotus-utils/Lotus/Utils/String)]
 
 ## Versioning
 
@@ -61,4 +131,4 @@ __Lotus::Utils__ uses [Semantic Versioning 2.0.0](http://semver.org)
 
 ## Copyright
 
-Copyright © 2014-2015 Luca Guidi – Released under MIT License
+Copyright © 2014-2016 Luca Guidi – Released under MIT License

data/lib/lotus/utils/attributes.rb

@@ -27,7 +27,7 @@ module Lotus
       # @example
       #   require 'lotus/utils/attributes'
       #
-      #   attributes = Lotus::Utils::Attributes.new(a: 1, b: { 2 => [3, 4] } })
+      #   attributes = Lotus::Utils::Attributes.new(a: 1, b: { 2 => [3, 4] })
       #   attributes.to_h # => { "a" => 1, "b" => { "2" => [3, 4] } }
       def initialize(hash = {})
         @attributes = Utils::Hash.new(hash, &nil).stringify!

data/lib/lotus/utils/callbacks.rb

@@ -1,5 +1,3 @@
-require 'lotus/utils/deprecation'
-
 module Lotus
   module Utils
     # Before and After callbacks
@@ -60,16 +58,6 @@ module Lotus
           @chain.uniq!
         end
 
-        # @since 0.1.0
-        # @deprecated Use Lotus::Utils::Callbacks::Chain#append as it has the
-        #   same effect, but it's more consistent with the new API.
-        #
-        # @see Lotus::Utils::Callbacks::Chain#append
-        def add(*callbacks, &blk)
-          Utils::Deprecation.new("Lotus::Utils::Callbacks::Chain#add is deprecated, use #append instead.")
-          append(*callbacks, &blk)
-        end
-
         # Prepends the given callbacks to the beginning of the chain.
         #
         # @param callbacks [Array] one or multiple callbacks to add
@@ -133,7 +121,7 @@ module Lotus
         #   params = Hash[id: 23]
         #
         #   chain = Lotus::Utils::Callbacks::Chain.new
-        #   chain.add :authenticate!, :set_article
+        #   chain.append :authenticate!, :set_article
         #
         #   chain.run(action, params)
         #
@@ -143,11 +131,11 @@ module Lotus
         #
         #   chain = Lotus::Utils::Callbacks::Chain.new
         #
-        #   chain.add do
+        #   chain.append do
         #     # some authentication logic
         #   end
         #
-        #   chain.add do |params|
+        #   chain.append do |params|
         #     # some other logic that requires `params`
         #   end
         #
@@ -174,7 +162,7 @@ module Lotus
         #
         #   chain.frozen?  # => true
         #
-        #   chain.add :authenticate! # => RuntimeError
+        #   chain.append :authenticate! # => RuntimeError
         def freeze
           super
           @chain.freeze

data/lib/lotus/utils/class.rb

@@ -1,5 +1,4 @@
 require 'lotus/utils/string'
-require 'lotus/utils/deprecation'
 
 module Lotus
   module Utils
@@ -39,14 +38,7 @@ module Lotus
       #   # with missing constant
       #   Lotus::Utils::Class.load!('Unknown') # => raises NameError
       def self.load!(name, namespace = Object)
-        name = name.to_s
-
-        if name.match(/\|/)
-          Utils::Deprecation.new("Using Lotus::Utils::Class.load! with a pattern is deprecated, please use Lotus::Utils::Class.load_from_pattern!: #{ name }, #{ namespace }")
-          return load_from_pattern!(name, namespace)
-        end
-
-        namespace.const_get(name)
+        namespace.const_get(name.to_s)
       end
 
       # Loads a class from the given pattern name and namespace
@@ -75,17 +67,17 @@ module Lotus
       #   end
       #
       #   # basic usage
-      #   Lotus::Utils::Class.load!('App::Service') # => App::Service
+      #   Lotus::Utils::Class.load_from_pattern!('App::Service') # => App::Service
       #
       #   # with explicit namespace
-      #   Lotus::Utils::Class.load!('Service', App) # => App::Service
+      #   Lotus::Utils::Class.load_from_pattern!('Service', App) # => App::Service
       #
       #   # with pattern
-      #   Lotus::Utils::Class.load!('App::Service(::Endpoint|Endpoint)') # => App::Service::Endpoint
-      #   Lotus::Utils::Class.load!('App::Service(Endpoint|::Endpoint)') # => App::ServiceEndpoint
+      #   Lotus::Utils::Class.load_from_pattern!('App::Service(::Endpoint|Endpoint)') # => App::Service::Endpoint
+      #   Lotus::Utils::Class.load_from_pattern!('App::Service(Endpoint|::Endpoint)') # => App::ServiceEndpoint
       #
       #   # with missing constant
-      #   Lotus::Utils::Class.load!('Unknown') # => raises NameError
+      #   Lotus::Utils::Class.load_from_pattern!('Unknown') # => raises NameError
       def self.load_from_pattern!(pattern, namespace = Object)
         String.new(pattern).tokenize do |token|
           begin

data/lib/lotus/utils/class_attribute.rb

@@ -1,4 +1,5 @@
 require 'set'
+require 'lotus/utils/duplicable'
 
 module Lotus
   module Utils
@@ -74,7 +75,7 @@ module Lotus
         def inherited(subclass)
           class_attributes.each do |attr|
             value = send(attr)
-            value = value.dup rescue value
+            value = Duplicable.dup(value)
             subclass.class_attribute attr
             subclass.send("#{attr}=", value)
           end

data/lib/lotus/utils/duplicable.rb

@@ -0,0 +1,80 @@
+module Lotus
+  module Utils
+    # Safe dup logic
+    #
+    # @since 0.6.0
+    module Duplicable
+      # Duplicates the given value.
+      #
+      # It accepts a block to customize the logic.
+      #
+      # The following types aren't duped:
+      #
+      #   * <tt>NilClass</tt>
+      #   * <tt>FalseClass</tt>
+      #   * <tt>TrueClass</tt>
+      #   * <tt>Symbol</tt>
+      #   * <tt>Numeric</tt>
+      #
+      # All the other types are duped via <tt>#dup</tt>
+      #
+      # @param value [Object] the value to duplicate
+      # @param blk [Proc] the optional block to customize the logic
+      #
+      # @return [Object] the duped value
+      #
+      # @since 0.6.0
+      #
+      # @example Basic Usage With Types That Can't Be Duped
+      #   require 'lotus/utils/duplicable'
+      #
+      #   object = 23
+      #   puts object.object_id # => 47
+      #
+      #   result = Lotus::Utils::Duplicable.dup(object)
+      #
+      #   puts result           # => 23
+      #   puts result.object_id # => 47 - Same object, because numbers can't be duped
+      #
+      # @example Basic Usage With Types That Can Be Duped
+      #   require 'lotus/utils/duplicable'
+      #
+      #   object = "hello"
+      #   puts object.object_id # => 70172661782360
+      #
+      #   result = Lotus::Utils::Duplicable.dup(object)
+      #
+      #   puts result           # => "hello"
+      #   puts result.object_id # => 70172671467020 – Different object
+      #
+      # @example Custom Logic
+      #   require 'lotus/utils/duplicable'
+      #   require 'lotus/utils/hash'
+      #
+      #   hash = { a: 1 }
+      #   puts hash.object_id # => 70207105061680
+      #
+      #   result = Lotus::Utils::Duplicable.dup(hash) do |value|
+      #     case value
+      #     when Lotus::Utils::Hash
+      #       value.deep_dup
+      #     when ::Hash
+      #       Lotus::Utils::Hash.new(value).deep_dup.to_h
+      #     end
+      #   end
+      #
+      #   puts result           # => "{:a=>1}"
+      #   puts result.object_id # => 70207105185500 – Different object
+      def self.dup(value, &blk)
+        case value
+        when NilClass, FalseClass, TrueClass, Symbol, Numeric
+          value
+        when v = blk && blk.call(value)
+          v
+        else
+          value.dup
+        end
+      end
+    end
+  end
+end

data/lib/lotus/utils/escape.rb

@@ -528,7 +528,10 @@ module Lotus
       # @since 0.4.0
       # @api private
       def self.encode(input)
-        input.to_s.encode(Encoding::UTF_8)
+        return '' if input.nil?
+        input.encode(Encoding::UTF_8)
+      rescue Encoding::UndefinedConversionError
+        input.dup.force_encoding(Encoding::UTF_8)
       end
 
       # Encode the given UTF-8 char.

data/lib/lotus/utils/hash.rb

@@ -1,8 +1,24 @@
+require 'lotus/utils/duplicable'
+
 module Lotus
   module Utils
     # Hash on steroids
     # @since 0.1.0
     class Hash
+      # @since 0.6.0
+      # @api private
+      #
+      # @see Lotus::Utils::Hash#deep_dup
+      # @see Lotus::Utils::Duplicable
+      DUPLICATE_LOGIC = Proc.new do |value|
+        case value
+        when Hash
+          value.deep_dup
+        when ::Hash
+          Hash.new(value).deep_dup.to_h
+        end
+      end.freeze
+
       # Initialize the hash
       #
       # @param hash [#to_h] the value we want to use to initialize this instance
@@ -145,7 +161,7 @@ module Lotus
       #   duped['u_hash'].class # => Lotus::Utils::Hash
       def deep_dup
         Hash.new.tap do |result|
-          @hash.each {|k, v| result[k] = duplicate(v) }
+          @hash.each {|k, v| result[k] = Duplicable.dup(v, &DUPLICATE_LOGIC) }
         end
       end
 
@@ -278,22 +294,6 @@ module Lotus
       def respond_to_missing?(m, include_private=false)
         @hash.respond_to?(m, include_private)
       end
-
-      private
-      # @api private
-      # @since 0.3.1
-      def duplicate(value)
-        case value
-        when NilClass, FalseClass, TrueClass, Symbol, Numeric
-          value
-        when Hash
-          value.deep_dup
-        when ::Hash
-          Hash.new(value).deep_dup.to_h
-        else
-          value.dup
-        end
-      end
     end
   end
 end

data/lib/lotus/utils/inflector.rb

@@ -1,30 +1,36 @@
+require 'lotus/utils/class_attribute'
+
 module Lotus
   module Utils
     # String inflector
     #
     # @since 0.4.1
-    # @api private
     module Inflector
-      # Rule for irregular plural
+      # Rules for irregular plurals
       #
-      # @since 0.4.1
+      # @since 0.6.0
       # @api private
-      class IrregularRule
-        # @since 0.4.1
+      class IrregularRules
+        # @since 0.6.0
         # @api private
         def initialize(rules)
           @rules = rules
-          @rules.freeze
         end
 
-        # @since 0.4.1
+        # @since 0.6.0
+        # @api private
+        def add(key, value)
+          @rules[key.downcase] = value.downcase
+        end
+
+        # @since 0.6.0
         # @api private
         def ===(other)
           key = other.downcase
           @rules.key?(key) || @rules.value?(key)
         end
 
-        # @since 0.4.1
+        # @since 0.6.0
         # @api private
         def apply(string)
           key    = string.downcase
@@ -34,30 +40,6 @@ module Lotus
         end
       end
 
-      # Rule for irregular plural, that uses a suffix.
-      #
-      # @since 0.4.1
-      # @api private
-      class SuffixRule < IrregularRule
-        def initialize(matcher, replacement, rules)
-          super(rules)
-          @matcher     = matcher
-          @replacement = replacement
-        end
-
-        # @since 0.4.1
-        # @api private
-        def ===(other)
-          @rules.key?(other.downcase)
-        end
-
-        # @since 0.4.1
-        # @api private
-        def apply(string)
-          string.sub(@matcher, @replacement)
-        end
-      end
-
       # Matcher for blank strings
       #
       # @since 0.4.1
@@ -80,6 +62,10 @@ module Lotus
       # @api private
       EAUX = 'eaux'.freeze
 
+      # @since 0.6.0
+      # @api private
+      ES   = 'es'.freeze
+
       # @since 0.4.1
       # @api private
       F    = 'f'.freeze
@@ -136,6 +122,14 @@ module Lotus
       # @api private
       MINA = 'mina'.freeze
 
+      # @since 0.6.0
+      # @api private
+      NA   = 'na'.freeze
+
+      # @since 0.6.0
+      # @api private
+      NON  = 'non'.freeze
+
       # @since 0.4.1
       # @api private
       O    = 'o'.freeze
@@ -160,6 +154,10 @@ module Lotus
       # @api private
       SSES = 'sses'.freeze
 
+      # @since 0.6.0
+      # @api private
+      TA   = 'ta'.freeze
+
       # @since 0.4.1
       # @api private
       UM   = 'um'.freeze
@@ -188,66 +186,14 @@ module Lotus
       # @api private
       Y    = 'y'.freeze
 
-      # Plural rule "is" => "es"
-      #
-      # @since 0.4.1
-      # @api private
-      PLURAL_IS_ES = SuffixRule.new( /is\z/, 'es', {
-        'analysis'    => true,
-        'axis'        => true,
-        'basis'       => true,
-        'crisis'      => true,
-        'diagnosis'   => true,
-        'ellipsis'    => true,
-        'hypothesis'  => true,
-        'oasis'       => true,
-        'paralysis'   => true,
-        'parenthesis' => true,
-        'synopsis'    => true,
-        'synthesis'   => true,
-        'thesis'      => true,
-      })
+      include Utils::ClassAttribute
 
-      # Plural rule "is" => "ides"
+      # Irregular rules for plurals
       #
-      # @since 0.4.1
+      # @since 0.6.0
       # @api private
-      PLURAL_IS_IDES = SuffixRule.new( /is\z/, 'ides', {
-        'clitoris' => true,
-        'iris'     => true,
-      })
-
-      # Plural rule "f" => "s"
-      #
-      # @since 0.4.1
-      # @api private
-      PLURAL_F_S = SuffixRule.new( /\z/, 's', {
-        'chief' => true,
-        'spoof' => true,
-      })
-
-      # Plural rule "o" => "oes"
-      #
-      # @since 0.4.1
-      # @api private
-      PLURAL_O_OES = SuffixRule.new( /\z/, 'es', {
-        'buffalo'  => true,
-        'domino'   => true,
-        'echo'     => true,
-        'embargo'  => true,
-        'hero'     => true,
-        'mosquito' => true,
-        'potato'   => true,
-        'tomato'   => true,
-        'torpedo'  => true,
-        'veto'     => true,
-      })
-
-      # Irregular rules
-      #
-      # @since 0.4.1
-      # @api private
-      PLURAL_IRREGULAR = IrregularRule.new({
+      class_attribute :plurals
+      self.plurals = IrregularRules.new({
         # irregular
         'cactus'       => 'cacti',
         'child'        => 'children',
@@ -276,96 +222,14 @@ module Lotus
         'series'       => 'series',
         'sheep'        => 'sheep',
         'species'      => 'species',
-        # a            => ae
-        'alumna'       => 'alumnae',
-        'alga'         => 'algae',
-        'vertebra'     => 'vertebrae',
-        'persona'      => 'personae',
-        'antenna'      => 'antennae',
-        'formula'      => 'formulae',
-        'nebula'       => 'nebulae',
-        'vita'         => 'vitae',
-        # on           => a
-        'criterion'    => 'criteria',
-        'perihelion'   => 'perihelia',
-        'aphelion'     => 'aphelia',
-        'phenomenon'   => 'phenomena',
-        'prolegomenon' => 'prolegomena',
-        'noumenon'     => 'noumena',
-        'organon'      => 'organa',
-        'asyndeton'    => 'asyndeta',
-        'hyperbaton'   => 'hyperbata',
-        # us           => i
-        'alumnus'      => 'alumni',
-        'alveolus'     => 'alveoli',
-        'bacillus'     => 'bacilli',
-        'bronchus'     => 'bronchi',
-        'locus'        => 'loci',
-        'nucleus'      => 'nuclei',
-        'stimulus'     => 'stimuli',
-        'meniscus'     => 'menisci',
-        'thesaurus'    => 'thesauri',
-        # a            => ata
-        'anathema'     => 'anathemata',
-        'enema'        => 'enemata',
-        'oedema'       => 'oedemata',
-        'bema'         => 'bemata',
-        'enigma'       => 'enigmata',
-        'sarcoma'      => 'sarcomata',
-        'carcinoma'    => 'carcinomata',
-        'gumma'        => 'gummata',
-        'schema'       => 'schemata',
-        'charisma'     => 'charismata',
-        'lemma'        => 'lemmata',
-        'soma'         => 'somata',
-        'diploma'      => 'diplomata',
-        'lymphoma'     => 'lymphomata',
-        'stigma'       => 'stigmata',
-        'dogma'        => 'dogmata',
-        'magma'        => 'magmata',
-        'stoma'        => 'stomata',
-        'drama'        => 'dramata',
-        'melisma'      => 'melismata',
-        'trauma'       => 'traumata',
-        'edema'        => 'edemata',
-        'miasma'       => 'miasmata',
-        # s => es
-        'acropolis'    => 'acropolises',
-        'chaos'        => 'chaoses',
-        'lens'         => 'lenses',
-        'aegis'        => 'aegises',
-        'cosmos'       => 'cosmoses',
-        'mantis'       => 'mantises',
-        'alias'        => 'aliases',
-        'dais'         => 'daises',
-        'marquis'      => 'marquises',
-        'asbestos'     => 'asbestoses',
-        'digitalis'    => 'digitalises',
-        'metropolis'   => 'metropolises',
-        'atlas'        => 'atlases',
-        'epidermis'    => 'epidermises',
-        'pathos'       => 'pathoses',
-        'bathos'       => 'bathoses',
-        'ethos'        => 'ethoses',
-        'pelvis'       => 'pelvises',
-        'bias'         => 'biases',
-        'gas'          => 'gases',
-        'polis'        => 'polises',
-        'caddis'       => 'caddises',
-        'rhinoceros'   => 'rhinoceroses',
-        'cannabis'     => 'cannabises',
-        'glottis'      => 'glottises',
-        'sassafras'    => 'sassafrases',
-        'canvas'       => 'canvases',
-        'ibis'         => 'ibises',
-        'trellis'      => 'trellises',
       })
 
-      # Irregular rules
+      # Irregular rules for singulars
       #
-      # @since 0.4.1
+      # @since 0.6.0
       # @api private
-      SINGULAR_IRREGULAR = IrregularRule.new({
+      class_attribute :singulars
+      self.singulars = IrregularRules.new({
         # irregular
         'cacti'   => 'cactus',
         'children'=> 'child',
@@ -395,89 +259,74 @@ module Lotus
         'sheep'       => 'sheep',
         'species'     => 'species',
         'police'      => 'police',
-        # ae => a
-        'alumnae'   => 'alumna',
-        'algae'     => 'alga',
-        'vertebrae' => 'vertebra',
-        'personae'  => 'persona',
-        'antennae'  => 'antenna',
-        'formulae'  => 'formula',
-        'nebulae'   => 'nebula',
-        'vitae'     => 'vita',
-        # a = on
-        'criteria'    => 'criterion',
-        'perihelia'   => 'perihelion',
-        'aphelia'     => 'aphelion',
-        'phenomena'   => 'phenomenon',
-        'prolegomena' => 'prolegomenon',
-        'noumena'     => 'noumenon',
-        'organa'      => 'organon',
-        'asyndeta'    => 'asyndeton',
-        'hyperbata'   => 'hyperbaton',
-        # ses => s
-        'acropolises'  => 'acropolis',
-        'chaoses'      => 'chaos',
-        'lenses'       => 'lens',
-        'aegises'      => 'aegis',
-        'cosmoses'     => 'cosmos',
-        'mantises'     => 'mantis',
-        'aliases'      => 'alias',
-        'daises'       => 'dais',
-        'marquises'    => 'marquis',
-        'asbestoses'   => 'asbestos',
-        'digitalises'  => 'digitalis',
-        'metropolises' => 'metropolis',
-        'atlases'      => 'atlas',
-        'epidermises'  => 'epidermis',
-        'pathoses'     => 'pathos',
-        'bathoses'     => 'bathos',
-        'ethoses'      => 'ethos',
-        'pelvises'     => 'pelvis',
-        'biases'       => 'bias',
-        'gases'        => 'gas',
-        'polises'      => 'polis',
-        'caddises'     => 'caddis',
-        'rhinoceroses' => 'rhinoceros',
-        'cannabises'   => 'cannabis',
-        'glottises'    => 'glottis',
-        'sassafrases'  => 'sassafras',
-        'canvases'     => 'canvas',
-        'ibises'       => 'ibis',
-        'trellises'    => 'trellis',
         # fallback
-        'hives' => 'hive',
-        # ices => ex
-        "codices"    => "codex",
-        "murices"    => "murex",
-        "silices"    => "silex",
-        "apices"     => "apex",
-        "latices"    => "latex",
-        "vertices"   => "vertex",
-        "cortices"   => "cortex",
-        "pontifices" => "pontifex",
-        "vortices"   => "vortex",
-        "indices"    => "index",
-        "simplices"  => "simplex",
-        # ices => ix
-        "radices"    => "radix",
-        "helices"    => "helix",
-        "appendices" => "appendix",
-        # es => is
-        "axes"        => "axis",
-        "analyses"    => "analysis",
-        "bases"       => "basis",
-        "crises"      => "crisis",
-        "diagnoses"   => "diagnosis",
-        "ellipses"    => "ellipsis",
-        "hypotheses"  => "hypothesis",
-        "oases"       => "oasis",
-        "paralyses"   => "paralysis",
-        "parentheses" => "parenthesis",
-        "syntheses"   => "synthesis",
-        "synopses"    => "synopsis",
-        "theses"      => "thesis",
+        'hives'       => 'hive',
+        'horses'      => 'horse',
       })
 
+      # Block for custom inflection rules.
+      #
+      # @param [Proc] blk custom inflections
+      #
+      # @since 0.6.0
+      #
+      # @see Lotus::Utils::Inflector.exception
+      # @see Lotus::Utils::Inflector.uncountable
+      #
+      # @example
+      #   require 'lotus/utils/inflector'
+      #
+      #   Lotus::Utils::Inflector.inflections do
+      #     exception   'analysis', 'analyses'
+      #     exception   'alga',     'algae'
+      #     uncountable 'music', 'butter'
+      #   end
+      def self.inflections(&blk)
+        class_eval(&blk)
+      end
+
+      # Add a custom inflection exception
+      #
+      # @param [String] singular form
+      # @param [String] plural form
+      #
+      # @since 0.6.0
+      #
+      # @see Lotus::Utils::Inflector.inflections
+      # @see Lotus::Utils::Inflector.uncountable
+      #
+      # @example
+      #   require 'lotus/utils/inflector'
+      #
+      #   Lotus::Utils::Inflector.inflections do
+      #     exception 'alga', 'algae'
+      #   end
+      def self.exception(singular, plural)
+        singulars.add(plural, singular)
+        plurals.add(singular, plural)
+      end
+
+      # Add an uncountable word
+      #
+      # @param [Array<String>] words
+      #
+      # @since 0.6.0
+      #
+      # @see Lotus::Utils::Inflector.inflections
+      # @see Lotus::Utils::Inflector.exception
+      #
+      # @example
+      #   require 'lotus/utils/inflector'
+      #
+      #   Lotus::Utils::Inflector.inflections do
+      #     uncountable 'music', 'art'
+      #   end
+      def self.uncountable(*words)
+        Array(words).each do |word|
+          exception(word, word)
+        end
+      end
+
       # Pluralize the given string
       #
       # @param string [String] a string to pluralize
@@ -490,8 +339,8 @@ module Lotus
         return string if string.nil? || string.match(BLANK_STRING_MATCHER)
 
         case string
-        when PLURAL_IRREGULAR
-          PLURAL_IRREGULAR.apply(string)
+        when plurals
+          plurals.apply(string)
         when /\A((.*)[^aeiou])ch\z/
           $1 + CHES
         when /\A((.*)[^aeiou])y\z/
@@ -502,24 +351,24 @@ module Lotus
           $1 + EAUX
         when /\A(.*)x\z/
           $1 + XES
+        when /\A(.*)ma\z/
+          string + TA
         when /\A(.*)(um|#{ A })\z/
           $1 + A
         when /\A(.*)(ouse|#{ ICE })\z/
           $1 + ICE
-        when PLURAL_O_OES
-          PLURAL_O_OES.apply(string)
+        when /\A(buffal|domin|ech|embarg|her|mosquit|potat|tomat)#{ O }\z/i
+          $1 + OES
         when /\A(.*)(en|#{ INA })\z/
           $1 + INA
-        when PLURAL_F_S
-          PLURAL_F_S.apply(string)
         when /\A(.*)(?:([^f]))f[e]*\z/
           $1 + $2 + VES
         when /\A(.*)us\z/
           $1 + USES
-        when PLURAL_IS_ES
-          PLURAL_IS_ES.apply(string)
-        when PLURAL_IS_IDES
-          PLURAL_IS_IDES.apply(string)
+        when /\A(.*)non\z/
+          $1 + NA
+        when /\A((.*)[^aeiou])is\z/
+          $1 + ES
         when /\A(.*)ss\z/
           $1 + SSES
         when /s\z/
@@ -541,8 +390,8 @@ module Lotus
         return string if string.nil? || string.match(BLANK_STRING_MATCHER)
 
         case string
-        when SINGULAR_IRREGULAR
-          SINGULAR_IRREGULAR.apply(string)
+        when singulars
+          singulars.apply(string)
         when /\A.*[^aeiou]#{CHES}\z/
           string.sub(CHES, CH)
         when /\A.*[^aeiou]#{IES}\z/
@@ -573,6 +422,10 @@ module Lotus
           $1 + F
         when /\A(.*)#{I}\z/
           $1 + US
+        when /\A(.*)ae\z/
+          $1 + A
+        when /\A(.*)na\z/
+          $1 + NON
         when /\A(.*)#{A}\z/
           $1 + UM
         when /[^s]\z/

data/lib/lotus/utils/kernel.rb

@@ -978,7 +978,7 @@ module Lotus
         raise TypeError.new "can't convert #{inspect_type_error(arg)}into Pathname"
       end
 
-      # Coerces the argument to be a String.
+      # Coerces the argument to be a Symbol.
       #
       # @param arg [#to_sym] the argument
       #

data/lib/lotus/utils/load_paths.rb

@@ -18,7 +18,7 @@ module Lotus
       # @see http://ruby-doc.org/stdlib/libdoc/pathname/rdoc/Pathname.html
       # @see Lotus::Utils::Kernel.Pathname
       def initialize(*paths)
-        @paths = Array(paths)
+        @paths = Utils::Kernel.Array(paths)
       end
 
       # It specifies the policy for initialize copies of the object, when #clone
@@ -61,7 +61,7 @@ module Lotus
       #
       # @since 0.2.0
       def each
-        Utils::Kernel.Array(@paths).each do |path|
+        @paths.each do |path|
           yield realpath(path)
         end
       end
@@ -111,6 +111,7 @@ module Lotus
       #   paths << '.' << '../..'
       def push(*paths)
         @paths.push(*paths)
+        @paths = Kernel.Array(@paths)
         self
       end
 
@@ -136,6 +137,22 @@ module Lotus
         @paths.freeze
       end
 
+      # @since 0.6.0
+      # @api private
+      def ==(other)
+        case other
+        when self.class
+          other.paths == paths
+        else
+          other == paths
+        end
+      end
+
+      protected
+      # @since 0.6.0
+      # @api private
+      attr_reader :paths
+
       private
       # Allow subclasses to define their own policy to discover the realpath
       # of the given path.

data/lib/lotus/utils/path_prefix.rb

@@ -80,10 +80,13 @@ module Lotus
       def relative_join(strings, separator = @separator)
         raise TypeError if separator.nil?
         prefix = @string.gsub(@separator, separator)
+        result = [prefix, strings]
+        result.flatten!
+        result.compact!
+        result.reject! {|string| string == separator }
 
         self.class.new(
-          [prefix, strings].flatten.compact.join(separator),
-          separator
+          result.join(separator), separator
         ).relative!
       end
 

data/lib/lotus/utils/string.rb

@@ -6,6 +6,12 @@ module Lotus
     #
     # @since 0.1.0
     class String
+      # Empty string for #classify
+      #
+      # @since 0.6.0
+      # @api private
+      EMPTY_STRING        = ''.freeze
+
       # Separator between Ruby namespaces
       #
       # @since 0.1.0
@@ -135,14 +141,14 @@ module Lotus
       #   string = Lotus::Utils::String.new 'lotus_utils'
       #   string.classify # => 'LotusUtils'
       def classify
-        words = split(CLASSIFY_WORD_SEPARATOR).map(&:capitalize)
+        words = split(CLASSIFY_WORD_SEPARATOR).map!(&:capitalize)
         delimiters = scan(CLASSIFY_WORD_SEPARATOR)
 
         delimiters.map! do |delimiter|
-          delimiter == CLASSIFY_SEPARATOR ? nil : NAMESPACE_SEPARATOR
+          delimiter == CLASSIFY_SEPARATOR ? EMPTY_STRING : NAMESPACE_SEPARATOR
         end
 
-        self.class.new words.zip(delimiters).compact.join
+        self.class.new words.zip(delimiters).join
       end
 
       # Return a downcased and underscore separated version of the string
@@ -340,6 +346,51 @@ module Lotus
         end
       end
 
+      # Both forms iterate through str, matching the pattern
+      #
+      # @return [String,nil]
+      #
+      # @see http://www.ruby-doc.org/core/String.html#method-i-scan
+      #
+      # @since 0.6.0
+      def scan(pattern, &blk)
+        @string.scan(pattern, &blk)
+      end
+
+      # Replace the rightmost match of <tt>pattern</tt> with <tt>replacement</tt>
+      #
+      # If the pattern cannot be matched, it returns the original string.
+      #
+      # This method does NOT mutate the original string.
+      #
+      # @param pattern [Regexp, String] the pattern to find
+      # @param replacement [String, Lotus::Utils::String] the string to replace
+      #
+      # @return [Lotus::Utils::String] the replaced string
+      #
+      # @since 0.6.0
+      #
+      # @example
+      #   require 'lotus/utils/string'
+      #
+      #   string = Lotus::Utils::String.new('authors/books/index')
+      #   result = string.rsub(/\//, '#')
+      #
+      #   puts string
+      #     # => #<Lotus::Utils::String:0x007fdb41233ad8 @string="authors/books/index">
+      #
+      #   puts result
+      #     # => #<Lotus::Utils::String:0x007fdb41232ed0 @string="authors/books#index">
+      def rsub(pattern, replacement)
+        if i = rindex(pattern)
+          s    = @string.dup
+          s[i] = replacement
+          self.class.new s
+        else
+          self
+        end
+      end
+
       # Override Ruby's method_missing in order to provide ::String interface
       #
       # @api private

data/lib/lotus/utils/version.rb

@@ -3,6 +3,6 @@ module Lotus
     # Defines the version
     #
     # @since 0.1.0
-    VERSION = '0.5.2'.freeze
+    VERSION = '0.6.0'.freeze
   end
 end

data/lotus-utils.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Luca Guidi', 'Trung Lê', 'Alfonso Uceda']
   spec.email         = ['me@lucaguidi.com', 'trung.le@ruby-journal.com', 'uceda73@gmail.com']
   spec.description   = %q{Lotus utilities}
-  spec.summary       = %q{Ruby core extentions and Louts utilities}
+  spec.summary       = %q{Ruby core extentions and Lotus utilities}
   spec.homepage      = 'http://lotusrb.org'
   spec.license       = 'MIT'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lotus-utils
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Luca Guidi
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-30 00:00:00.000000000 Z
+date: 2016-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ files:
 - lib/lotus/utils/class.rb
 - lib/lotus/utils/class_attribute.rb
 - lib/lotus/utils/deprecation.rb
+- lib/lotus/utils/duplicable.rb
 - lib/lotus/utils/escape.rb
 - lib/lotus/utils/hash.rb
 - lib/lotus/utils/inflector.rb
@@ -106,9 +107,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Ruby core extentions and Louts utilities
+summary: Ruby core extentions and Lotus utilities
 test_files: []
 has_rdoc: