sigterm_extensions 0.0.4

data/lib/sigterm_extensions/inflector/acronyms.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SigtermExtensions
+  class Inflector
+    # A set of acronyms
+    #
+    # @since 0.1.2
+    # @api private
+    class Acronyms
+      attr_reader :regex
+
+      # @since 0.1.2
+      # @api private
+      def initialize
+        @rules = {}
+        define_regex_patterns
+      end
+
+      # @since 0.1.2
+      # @api private
+      def apply_to(word, capitalize = true)
+        @rules[word.downcase] || (capitalize ? word.capitalize : word)
+      end
+
+      # @since 0.1.2
+      # @api private
+      def add(rule, replacement)
+        @rules[rule] = replacement
+        define_regex_patterns
+      end
+
+      private
+
+      # @since 0.1.2
+      # @api private
+      def define_regex_patterns
+        regex = @rules.empty? ? /(?=a)b/ : /#{@rules.values.join("|")}/
+        @regex = /(?:(?<=([A-Za-z\d]))|\b)(#{regex})(?=\b|[^a-z])/
+      end
+    end
+  end
+end

data/lib/sigterm_extensions/inflector/inflections.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "rules"
+require_relative "acronyms"
+
+module SigtermExtensions
+  class Inflector
+    # Inflections
+    #
+    # @since 0.1.0
+    class Inflections
+      require_relative "inflections/defaults"
+
+      # Instantiate a set of inflection rules.
+      # It adds the default rules and the optional customizations, passed as a block.
+      #
+      # @param blk [Proc] the optional, custom rules
+      #
+      # @since 0.1.0
+      # @api private
+      def self.build(&blk)
+        new do |inflect|
+          Defaults.call(inflect)
+          blk.call(inflect) if block_given?
+        end
+      end
+
+      # Pluralization rules
+      #
+      # @return [Dry::Inflector::Rules]
+      #
+      # @since 0.1.0
+      # @api private
+      attr_reader :plurals
+
+      # Singularization rules
+      #
+      # @return [Dry::Inflector::Rules]
+      #
+      # @since 0.1.0
+      # @api private
+      attr_reader :singulars
+
+      # Uncountable rules
+      #
+      # @return [Set]
+      #
+      # @since 0.1.0
+      # @api private
+      attr_reader :uncountables
+
+      # Human rules
+      #
+      # @return [Dry::Inflector::Rules]
+      #
+      # @since 0.1.0
+      # @api private
+      attr_reader :humans
+
+      # Acronyms
+      #
+      # @return [Dry::Inflector::Acronyms]
+      #
+      # @since 0.1.2
+      # @api private
+      attr_reader :acronyms
+
+      # Instantiate the rules
+      #
+      # @return [Dry::Inflector::Inflections]
+      # @yieldparam [self]
+      #
+      # @since 0.1.0
+      # @api private
+      def initialize
+        @plurals      = Rules.new
+        @singulars    = Rules.new
+        @humans       = Rules.new
+        @uncountables = Set[]
+        @acronyms     = Acronyms.new
+
+        yield(self) if block_given?
+      end
+
+      # Add a custom pluralization rule
+      #
+      # 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 rule [String, Regexp] the rule
+      # @param replacement [String] the replacement
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require "dry/inflector"
+      #
+      #   inflector = Dry::Inflector.new do |inflections|
+      #     inflections.plural "virus", "viruses"
+      #   end
+      def plural(rule, replacement)
+        rule(rule, replacement, plurals)
+      end
+
+      # Add a custom singularization 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 rule [String, Regexp] the rule
+      # @param replacement [String] the replacement
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require "dry/inflector"
+      #
+      #   inflector = Dry::Inflector.new do |inflections|
+      #     inflections.singular "thieves", "thief"
+      #   end
+      def singular(rule, replacement)
+        rule(rule, replacement, singulars)
+      end
+
+      # Add a custom pluralization rule
+      #
+      # 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.
+      #
+      # @param singular [String] the singular
+      # @param plural [String] the plural
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require "dry/inflector"
+      #
+      #   inflector = Dry::Inflector.new do |inflections|
+      #     inflections.singular "octopus", "octopi"
+      #   end
+      def irregular(singular, plural)
+        uncountables.delete(singular)
+        uncountables.delete(plural)
+
+        add_irregular(singular, plural, plurals)
+        add_irregular(plural, singular, singulars)
+      end
+
+      # Add a custom rule for uncountable words
+      #
+      # Uncountable will not be inflected
+      #
+      # @param [Enumerable<String>] words
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require "dry/inflector"
+      #
+      #   inflector = Dry::Inflector.new do |inflections|
+      #     inflections.uncountable "money"
+      #     inflections.uncountable "money", "information"
+      #     inflections.uncountable %w(money information rice)
+      #   end
+      def uncountable(*words)
+        uncountables.merge(words.flatten)
+      end
+
+      # Add one or more acronyms
+      #
+      # Acronyms affect how basic operations are performed, such
+      # as camelize/underscore.
+      #
+      # @param words [Array<String>] a list of acronyms
+      #
+      # @since 0.1.2
+      #
+      # @example
+      #   require "dry/inflector"
+      #
+      #   inflector = Dry::Inflector.new do |inflections|
+      #     inflections.acronym "HTML"
+      #   end
+      #
+      #   inflector.camelize("html")        # => "HTML"
+      #   inflector.underscore("HTMLIsFun") # => "html_is_fun"
+      def acronym(*words)
+        words.each { |word| @acronyms.add(word.downcase, word) }
+      end
+
+      # Add a custom 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"`)
+      #
+      # @param rule [String, Regexp] the rule
+      # @param replacement [String] the replacement
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require "dry/inflector"
+      #
+      #   inflector = Dry::Inflector.new do |inflections|
+      #     inflections.human(/_cnt$/i, '\1_count')
+      #     inflections.human("legacy_col_person_name", "Name")
+      #   end
+      def human(rule, replacement)
+        humans.insert(0, [rule, replacement])
+      end
+
+      private
+
+      # Add irregular inflection
+      #
+      # @param rule [String] the rule
+      # @param replacement [String] the replacement
+      #
+      # @return [undefined]
+      #
+      # @since 0.1.0
+      # @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 rule [String, Regexp] the rule
+      # @param replacement [String, Regexp] the replacement
+      # @param target [Dry::Inflector::Rules] the target
+      #
+      # @since 0.1.0
+      # @api private
+      def rule(rule, replacement, target)
+        uncountables.delete(rule)
+        uncountables.delete(replacement)
+
+        target.insert(0, [rule, replacement])
+      end
+    end
+  end
+end

data/lib/sigterm_extensions/inflector/inflections/defaults.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module SigtermExtensions
+  class Inflector
+    class Inflections
+      # Default inflections
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      module Defaults
+        # @since 0.1.0
+        # @api private
+        def self.call(inflect)
+          plural(inflect)
+          singular(inflect)
+          irregular(inflect)
+          uncountable(inflect)
+          acronyms(inflect)
+        end
+
+        # @since 0.1.0
+        # @api private
+        def self.plural(inflect)
+          inflect.plural(/\z/, "s")
+          inflect.plural(/s\z/i, "s")
+          inflect.plural(/(ax|test)is\z/i, '\1es')
+          inflect.plural(/(.*)us\z/i, '\1uses')
+          inflect.plural(/(octop|vir|cact)us\z/i, '\1i')
+          inflect.plural(/(octop|vir)i\z/i, '\1i')
+          inflect.plural(/(alias|status)\z/i, '\1es')
+          inflect.plural(/(buffal|domin|ech|embarg|her|mosquit|potat|tomat)o\z/i, '\1oes')
+          inflect.plural(/(?<!b)um\z/i, '\1a')
+          inflect.plural(/([ti])a\z/i, '\1a')
+          inflect.plural(/sis\z/i, "ses")
+          inflect.plural(/(.*)(?:([^f]))f[e]*\z/i, '\1\2ves')
+          inflect.plural(/(hive|proof)\z/i, '\1s') # TODO: proof can be moved in the above regexp
+          inflect.plural(/([^aeiouy]|qu)y\z/i, '\1ies')
+          inflect.plural(/(x|ch|ss|sh)\z/i, '\1es')
+          inflect.plural(/(stoma|epo)ch\z/i, '\1chs')
+          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.plural(/(.*)non\z/i, '\1na')
+          inflect.plural(/(.*)ma\z/i, '\1mata')
+          inflect.plural(/(.*)(eau|eaux)\z/, '\1eaux')
+        end
+
+        # @since 0.1.0
+        # @api private
+        def self.singular(inflect)
+          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)(sis|ses)\z/i, '\1\2sis')
+          inflect.singular(/(^analy)(sis|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)(is|es)\z/i, '\1is')
+          inflect.singular(/(octop|vir)(us|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')
+        end
+
+        # @since 0.1.0
+        # @api private
+        def self.irregular(inflect)
+          inflect.irregular("person", "people")
+          inflect.irregular("man", "men")
+          inflect.irregular("human", "humans") # NOTE: this is here only to override the previous rule
+          inflect.irregular("child", "children")
+          inflect.irregular("sex", "sexes")
+          inflect.irregular("foot", "feet")
+          inflect.irregular("tooth", "teeth")
+          inflect.irregular("goose", "geese")
+          inflect.irregular("forum", "forums") # FIXME: this is here because I need to fix the "um" regexp
+        end
+
+        # @since 0.1.0
+        # @api private
+        def self.uncountable(inflect)
+          inflect.uncountable(%w[hovercraft moose deer milk rain Swiss grass equipment information rice money species series fish sheep jeans])
+        end
+
+        # @since 0.1.2
+        # @api private
+        def self.acronyms(inflect)
+          inflect.acronym(*%w[JSON HTTP OpenSSL HMAC])
+        end
+
+        private_class_method :plural, :singular, :irregular, :uncountable, :acronyms
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/sigterm_extensions/inflector/rules.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SigtermExtensions
+  class Inflector
+    # A set of inflection rules
+    #
+    # @since 0.1.0
+    # @api private
+    class Rules
+      # @since 0.1.0
+      # @api private
+      def initialize
+        @rules = []
+      end
+
+      # @since 0.1.0
+      # @api private
+      def apply_to(word)
+        result = word.dup
+        each { |rule, replacement| break if result.gsub!(rule, replacement) }
+        result
+      end
+
+      # @since 0.1.0
+      # @api private
+      def insert(index, array)
+        @rules.insert(index, array)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def each(&blk)
+        @rules.each(&blk)
+      end
+    end
+  end
+end

data/lib/sigterm_extensions/inflector/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SigtermExtensions
+  class Inflector
+    # @since 0.1.0
+    VERSION = "0.2.0"
+  end
+end