padrino-support 0.13.3.1 → 0.13.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3d089c213dd819144c3f8667c4b783bcba84ffe
-  data.tar.gz: ba764bc92ef86ab5b1e4835006af84806eb30b76
+  metadata.gz: ac419de645c2f3f52edf81364c8b170975b5e374
+  data.tar.gz: dbdec2f4d9e8f5adbbf1025ab416deb14040091f
 SHA512:
-  metadata.gz: 8f634f3097194ef1f71a5f03a614be4be6db5cd564fe9a9f315a8d43218c972568ae8de8a649b6d13e4be945e8a343a1ed9b50fe59f8be59abfc5f266358d4b9
-  data.tar.gz: e107ef8c84a337d6501f1df06ba4f96ab75b1169194238d99dcb9f7b6c2e520382927e570172c27cc84e6ec57f30f75c77f5ba1cb446d5d50987768455afd9dd
+  metadata.gz: 748ed677b332883f78061f4485dc28c5026055ad3b7af3c7abc747f2581d7b36bc3fbe77e0e5b5b00d86f6e347fa9335bface9ed5e8dd45fc61becf334312283
+  data.tar.gz: 586a56f27ab351fbaad2430900de3b87a9b107530cb82e169b5683420bdf27d191ed7c32722f18ad45238ad223774ec9e2665169201f988a2f82b43801795e43

data/lib/padrino-support.rb

@@ -18,7 +18,6 @@ rescue LoadError
 end
 
 
-require 'padrino-support/core_ext/string/inflections'
 require 'padrino-support/core_ext/string/colorize'
 require 'padrino-support/core_ext/object_space'
 require 'padrino-support/file_set'

data/lib/padrino-support/default_inflections.rb

@@ -0,0 +1,49 @@
+##
+# This module is based on Sequel 4.27.0
+# sequel-4.27.0/lib/sequel/model/default_inflections.rb
+#
+module Padrino
+  # Proc that is instance evaled to create the default inflections for both the
+  # model inflector and the inflector extension.
+  DEFAULT_INFLECTIONS_PROC = proc do
+    plural(/$/, 's')
+    plural(/s$/i, 's')
+    plural(/(alias|(?:stat|octop|vir|b)us)$/i, '\1es')
+    plural(/(buffal|tomat)o$/i, '\1oes')
+    plural(/([ti])um$/i, '\1a')
+    plural(/sis$/i, 'ses')
+    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    plural(/(hive)$/i, '\1s')
+    plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    plural(/(x|ch|ss|sh)$/i, '\1es')
+    plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+    plural(/([m|l])ouse$/i, '\1ice')
+
+    singular(/s$/i, '')
+    singular(/([ti])a$/i, '\1um')
+    singular(/(analy|ba|cri|diagno|parenthe|progno|synop|the)ses$/i, '\1sis')
+    singular(/([^f])ves$/i, '\1fe')
+    singular(/([h|t]ive)s$/i, '\1')
+    singular(/([lr])ves$/i, '\1f')
+    singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    singular(/(m)ovies$/i, '\1ovie')
+    singular(/(x|ch|ss|sh)es$/i, '\1')
+    singular(/([m|l])ice$/i, '\1ouse')
+    singular(/buses$/i, 'bus')
+    singular(/oes$/i, 'o')
+    singular(/shoes$/i, 'shoe')
+    singular(/(alias|(?:stat|octop|vir|b)us)es$/i, '\1')
+    singular(/(vert|ind)ices$/i, '\1ex')
+    singular(/matrices$/i, 'matrix')
+
+    irregular('person', 'people')
+    irregular('man', 'men')
+    irregular('child', 'children')
+    irregular('sex', 'sexes')
+    irregular('move', 'moves')
+    irregular('quiz', 'quizzes')
+    irregular('testis', 'testes')
+
+    uncountable(%w(equipment information rice money species series fish sheep news))
+  end
+end

data/lib/padrino-support/inflections.rb

@@ -0,0 +1,179 @@
+##
+# This module is based on Sequel 4.27.0
+# sequel-4.27.0/lib/sequel/model/inflections.rb
+#
+require 'padrino-support/default_inflections'
+
+module Padrino
+  # This module acts as a singleton returned/yielded by Sequel.inflections,
+  # which is used to override or specify additional inflection rules
+  # for Sequel. Examples:
+  #
+  #   Sequel.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.
+  module Inflections
+    CAMELIZE_CONVERT_REGEXP = /(^|_)(.)/.freeze
+    CAMELIZE_MODULE_REGEXP = /\/(.?)/.freeze
+    DASH = '-'.freeze
+    DEMODULIZE_CONVERT_REGEXP = /^.*::/.freeze
+    EMPTY_STRING= ''.freeze
+    SLASH = '/'.freeze
+    VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+    UNDERSCORE = '_'.freeze
+    UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)([A-Z][a-z])/.freeze
+    UNDERSCORE_CONVERT_REGEXP2 = /([a-z\d])([A-Z])/.freeze
+    UNDERSCORE_CONVERT_REPLACE = '\1_\2'.freeze
+    UNDERSCORE_MODULE_REGEXP = /::/.freeze
+
+    @plurals, @singulars, @uncountables = [], [], []
+
+    class << self
+      # Array of two element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of two element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :uncountables
+    end
+
+    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
+    # the options are: :plurals, :singulars, :uncountables
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def self.clear(scope = :all)
+      case scope
+      when :all
+        @plurals, @singulars, @uncountables = [], [], []
+      else
+        instance_variable_set("@#{scope}", [])
+      end
+    end
+
+    # 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.
+    #
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def self.irregular(singular, plural)
+      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    end
+
+    # 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.
+    #
+    # Example:
+    #   plural(/(x|ch|ss|sh)$/i, '\1es')
+    def self.plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # 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.
+    #
+    # Example:
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    def self.singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def self.uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    instance_eval(&DEFAULT_INFLECTIONS_PROC)
+
+    extend self
+
+    # Convert the given string to CamelCase.  Will also convert '/' to '::' which is useful for converting paths to namespaces.
+    def camelize(s)
+      s = s.to_s
+      return s.camelize if s.respond_to?(:camelize)
+      s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase}
+      s
+    end
+
+    # Tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    def constantize(s)
+      s = s.to_s
+      return s.constantize if s.respond_to?(:constantize)
+      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s)
+      Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+    end
+
+    # Removes the module part from the expression in the string
+    def demodulize(s)
+      s = s.to_s
+      return s.demodulize if s.respond_to?(:demodulize)
+      s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
+    end
+
+    # Returns the plural form of the word in the string.
+    def pluralize(s)
+      s = s.to_s
+      return s.pluralize if s.respond_to?(:pluralize)
+      result = s.dup
+      Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
+      result
+    end
+
+    # The reverse of pluralize, returns the singular form of a word in a string.
+    def singularize(s)
+      s = s.to_s
+      return s.singularize if s.respond_to?(:singularize)
+      result = s.dup
+      Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
+      result
+    end
+
+    # The reverse of camelize. Makes an underscored form from the expression in the string.
+    # Also changes '::' to '/' to convert namespaces to paths.
+    def underscore(s)
+      s = s.to_s
+      return s.underscore if s.respond_to?(:underscore)
+      s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE).
+        gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase
+    end
+
+    ##
+    # Capitalizes the first word, turns underscores into spaces, and strips a trailing '_id' if present.
+    #
+    def humanize(s)
+      s = s.to_s
+      return s.humanize if s.respond_to?(:humanize)
+      s.gsub(/_id$/, '').tr('_', ' ').capitalize
+    end
+
+    ##
+    # Create a class name from a plural table name like Rails does for table names to models.
+    #
+    def classify(s)
+      s = s.to_s
+      return s.classify if s.respond_to?(:classify)
+      camelize(singularize(s.sub(/.*\./, '')))
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: padrino-support
 version: !ruby/object:Gem::Version
-  version: 0.13.3.1
+  version: 0.13.3.2
 platform: ruby
 authors:
 - Padrino Team
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-30 00:00:00.000000000 Z
+date: 2016-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -42,8 +42,9 @@ files:
 - lib/padrino-support.rb
 - lib/padrino-support/core_ext/object_space.rb
 - lib/padrino-support/core_ext/string/colorize.rb
-- lib/padrino-support/core_ext/string/inflections.rb
+- lib/padrino-support/default_inflections.rb
 - lib/padrino-support/file_set.rb
+- lib/padrino-support/inflections.rb
 - lib/padrino-support/locale/cs.yml
 - lib/padrino-support/locale/da.yml
 - lib/padrino-support/locale/de.yml

data/lib/padrino-support/core_ext/string/inflections.rb

@@ -1,118 +0,0 @@
-require 'active_support/inflections'                        # load default inflections
-require 'active_support/inflector/methods'                  # constantize
-require 'active_support/inflector/inflections'              # pluralize
-
-##
-# This is an adapted version of active_support/core_ext/string/inflections.rb
-# to prevent loading several dependencies including I18n gem.
-#
-# Issue: https://github.com/rails/rails/issues/1526
-#
-class String
-  ##
-  # Returns the plural form of the word in the string.
-  #
-  #   "post".pluralize             # => "posts"
-  #   "octopus".pluralize          # => "octopi"
-  #   "sheep".pluralize            # => "sheep"
-  #   "words".pluralize            # => "words"
-  #   "the blue mailman".pluralize # => "the blue mailmen"
-  #   "CamelOctopus".pluralize     # => "CamelOctopi"
-  #
-  def pluralize
-    ActiveSupport::Inflector.pluralize(self)
-  end
-
-  ##
-  # Returns the singular form of the word in the string.
-  #
-  #   "posts".singularize            # => "post"
-  #   "octopi".singularize           # => "octopus"
-  #   "sheep".singularize            # => "sheep"
-  #   "words".singularize            # => "word"
-  #   "the blue mailmen".singularize # => "the blue mailman"
-  #   "CamelOctopi".singularize      # => "CamelOctopus"
-  #
-  def singularize
-    ActiveSupport::Inflector.singularize(self)
-  end
-
-  ##
-  # +constantize+ tries to find a declared constant with the name specified
-  # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.
-  #
-  #   "Module".constantize # => Module
-  #   "Class".constantize  # => Class
-  #
-  def constantize
-    ActiveSupport::Inflector.constantize(self)
-  end
-
-  ##
-  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
-  #
-  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
-  #
-  #   "ActiveRecord".underscore         # => "active_record"
-  #   "ActiveRecord::Errors".underscore # => active_record/errors
-  #
-  def underscore
-    ActiveSupport::Inflector.underscore(self)
-  end
-
-  ##
-  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
-  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
-  #
-  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-  #
-  #   "active_record".camelize                # => "ActiveRecord"
-  #   "active_record".camelize(:lower)        # => "activeRecord"
-  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
-  #
-  def camelize(first_letter = :upper)
-    case first_letter
-      when :upper then ActiveSupport::Inflector.camelize(self, true)
-      when :lower then ActiveSupport::Inflector.camelize(self, false)
-    end
-  end
-  alias_method :camelcase, :camelize
-
-  ##
-  # 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+.)
-  #
-  #   "egg_and_hams".classify # => "EggAndHam"
-  #   "posts".classify        # => "Post"
-  #
-  # Singular names are not handled correctly.
-  #
-  #   "business".classify # => "Busines"
-  #
-  def classify
-    ActiveSupport::Inflector.classify(self)
-  end
-
-  ##
-  # Capitalizes the first word, turns underscores into spaces, and strips a trailing '_id' if present.
-  #
-  if ActiveSupport::Inflector.method(:humanize).arity == 1
-    def humanize
-      ActiveSupport::Inflector.humanize(self)
-    end
-  else
-    def humanize(options = {})
-      ActiveSupport::Inflector.humanize(self, options)
-    end
-  end
-
-  ##
-  # Replaces underscores with dashes in the string.
-  #
-  def dasherize
-    ActiveSupport::Inflector.dasherize(self)
-  end
-end