sigterm_extensions 0.0.4

data/lib/sigterm_extensions/core_ext/string/starts_ends_with.rb

@@ -0,0 +1,4 @@
+class String
+  alias_method :starts_with?, :start_with?
+  alias_method :ends_with?, :end_with?
+end

data/lib/sigterm_extensions/core_ext/string/strip.rb

@@ -0,0 +1,25 @@
+class String
+  # Strips indentation in heredocs.
+  #
+  # For example in
+  #
+  #   if options[:usage]
+  #     puts <<-USAGE.strip_heredoc
+  #       This command does such and such.
+  #
+  #       Supported options are:
+  #         -h         This message
+  #         ...
+  #     USAGE
+  #   end
+  #
+  # the user would see the usage message aligned against the left margin.
+  #
+  # Technically, it looks for the least indented non-empty line
+  # in the whole string, and removes that amount of leading whitespace.
+  def strip_heredoc
+    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped|
+      stripped.freeze if frozen?
+    end
+  end
+end

data/lib/sigterm_extensions/core_ext/tryable.rb

@@ -0,0 +1,132 @@
+module ActiveSupport
+  module Tryable #:nodoc:
+    def try(method_name = nil, *args, &b)
+      if method_name.nil? && block_given?
+        if b.arity == 0
+          instance_eval(&b)
+        else
+          yield self
+        end
+      elsif respond_to?(method_name)
+        public_send(method_name, *args, &b)
+      end
+    end
+
+    def try!(method_name = nil, *args, &b)
+      if method_name.nil? && block_given?
+        if b.arity == 0
+          instance_eval(&b)
+        else
+          yield self
+        end
+      else
+        public_send(method_name, *args, &b)
+      end
+    end
+  end
+end
+
+class Object
+  include ActiveSupport::Tryable
+  ##
+  # :method: try
+  #
+  # :call-seq:
+  #   try(*a, &b)
+  #
+  # Invokes the public method whose name goes as first argument just like
+  # +public_send+ does, except that if the receiver does not respond to it the
+  # call returns +nil+ rather than raising an exception.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.try(:name)
+  #
+  # instead of
+  #
+  #   @person.name if @person
+  #
+  # +try+ calls can be chained:
+  #
+  #   @person.try(:spouse).try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.try(:non_existing_method) # => nil
+  #
+  # instead of
+  #
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) # => nil
+  #
+  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
+  # to the method:
+  #
+  #   nil.try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # The number of arguments in the signature must match. If the object responds
+  # to the method the call is attempted and +ArgumentError+ is still raised
+  # in case of argument mismatch.
+  #
+  # If +try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.try do |p|
+  #     ...
+  #   end
+  #
+  # You can also call try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.try { upcase.truncate(50) }
+  #
+  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
+  # with instances of classes that do not have +Object+ among their ancestors,
+  # like direct subclasses of +BasicObject+.
+
+  ##
+  # :method: try!
+  #
+  # :call-seq:
+  #   try!(*a, &b)
+  #
+  # Same as #try, but raises a +NoMethodError+ exception if the receiver is
+  # not +nil+ and does not implement the tried method.
+  #
+  #   "a".try!(:upcase) # => "A"
+  #   nil.try!(:upcase) # => nil
+  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Integer
+end
+
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && @person.children.any? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(_method_name = nil, *, **)
+    nil
+  end
+
+  # Calling +try!+ on +nil+ always returns +nil+.
+  #
+  #   nil.try!(:name) # => nil
+  def try!(_method_name = nil, *, **)
+    nil
+  end
+end
+

data/lib/sigterm_extensions/descendants_tracker.rb

@@ -0,0 +1,108 @@
+require "weakref"
+
+module SigtermExtensions
+  # This module provides an internal implementation to track descendants
+  # which is faster than iterating through ObjectSpace.
+  module DescendantsTracker
+    @@direct_descendants = {}
+
+    class << self
+      def direct_descendants(klass)
+        descendants = @@direct_descendants[klass]
+        descendants ? descendants.to_a : []
+      end
+
+      def descendants(klass)
+        arr = []
+        accumulate_descendants(klass, arr)
+        arr
+      end
+
+      def clear
+        if defined? ActiveSupport::Dependencies
+          @@direct_descendants.each do |klass, descendants|
+            if Dependencies.autoloaded?(klass)
+              @@direct_descendants.delete(klass)
+            else
+              descendants.reject! { |v| Dependencies.autoloaded?(v) }
+            end
+          end
+        else
+          @@direct_descendants.clear
+        end
+      end
+
+      # This is the only method that is not thread safe, but is only ever called
+      # during the eager loading phase.
+      def store_inherited(klass, descendant)
+        (@@direct_descendants[klass] ||= DescendantsArray.new) << descendant
+      end
+
+      private
+        def accumulate_descendants(klass, acc)
+          if direct_descendants = @@direct_descendants[klass]
+            direct_descendants.each do |direct_descendant|
+              acc << direct_descendant
+              accumulate_descendants(direct_descendant, acc)
+            end
+          end
+        end
+    end
+
+    def inherited(base)
+      DescendantsTracker.store_inherited(self, base)
+      super
+    end
+
+    def direct_descendants
+      DescendantsTracker.direct_descendants(self)
+    end
+
+    def descendants
+      DescendantsTracker.descendants(self)
+    end
+
+    # DescendantsArray is an array that contains weak references to classes.
+    class DescendantsArray # :nodoc:
+      include Enumerable
+
+      def initialize
+        @refs = []
+      end
+
+      def initialize_copy(orig)
+        @refs = @refs.dup
+      end
+
+      def <<(klass)
+        @refs << WeakRef.new(klass)
+      end
+
+      def each
+        @refs.reject! do |ref|
+          yield ref.__getobj__
+          false
+        rescue WeakRef::RefError
+          true
+        end
+        self
+      end
+
+      def refs_size
+        @refs.size
+      end
+
+      def cleanup!
+        @refs.delete_if { |ref| !ref.weakref_alive? }
+      end
+
+      def reject!
+        @refs.reject! do |ref|
+          yield ref.__getobj__
+        rescue WeakRef::RefError
+          true
+        end
+      end
+    end
+  end
+end

data/lib/sigterm_extensions/gem_methods.rb

@@ -0,0 +1,47 @@
+module SigtermExtensions
+  module GemMethods
+
+    # This can require a gem that's not in the Gemfile or gemspec
+    def unbundled_require(gem)
+      if defined?(::Bundler)
+        spec_path = Dir.glob("#{Gem.dir}/specifications/#{gem}-*.gemspec").last
+        if spec_path.nil?
+          warn "Couldn't find #{gem}"
+          return
+        end
+
+        spec = Gem::Specification.load spec_path
+        spec.activate
+      end
+
+      begin
+        require gem
+        yield if block_given?
+      rescue Exception => err
+        warn "Couldn't load #{gem}: #{err}"
+      end
+    end
+
+    def load_everything!
+      Gem::Specification.all.each do |gem|
+        gem.load_paths.each do |p|
+          $:.unshift(p) unless $LOAD_PATH.include?(p)
+        end
+      end
+    end
+
+    def add_gems_global_to_path
+      # This will load all global gems to load path
+      if defined?(::Bundler)
+        global_gemset = ENV['GEM_PATH'].split(':').grep(/ruby.*@global/).first
+        if global_gemset
+          all_global_gem_paths = Dir.glob("#{global_gemset}/gems/*")
+          all_global_gem_paths.each do |p|
+            gem_path = "#{p}/lib"
+            $LOAD_PATH << gem_path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sigterm_extensions/hash_binding.rb

@@ -0,0 +1,16 @@
+module SigtermExtensions
+  class HashBinding
+    def initialize(hash)
+      @hash = hash.dup
+    end
+    def method_missing(m, *args, &block)
+      @hash[m.to_s]
+    end
+    def get_binding
+      binding
+    end
+  end
+end
+# while /<%=.*%>/.match(str) != nil
+#   str = ERB.new(str).result(binding)
+# end

data/lib/sigterm_extensions/inflector.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+module SigtermExtensions
+  # inflector
+  #
+  # @since 0.1.0
+  class Inflector
+    require_relative "inflector/version"
+    require_relative "inflector/inflections"
+
+    # Instantiate the inflector
+    #
+    # @param blk [Proc] an optional block to specify custom inflection rules
+    # @yieldparam [SigtermExtensions::Inflector::Inflections] the inflection rules
+    #
+    # @return [SigtermExtensions::Inflector] the inflector
+    #
+    # @since 0.1.0
+    #
+    # @example Basic usage
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #
+    # @example Custom inflection rules
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new do |inflections|
+    #     inflections.plural      "virus",   "viruses" # specify a rule for #pluralize
+    #     inflections.singular    "thieves", "thief"   # specify a rule for #singularize
+    #     inflections.uncountable "inflector"          # add an exception for an uncountable word
+    #   end
+    def initialize(&blk)
+      @inflections = Inflections.build(&blk)
+    end
+
+    # Lower camelize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the lower camelized string
+    #
+    # @since 0.1.3
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.camelize_lower("data_mapper") # => "dataMapper"
+    def camelize_lower(input)
+      internal_camelize(input, false)
+    end
+
+    # Upper camelize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the upper camelized string
+    #
+    # @since 0.1.3
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.camelize_upper("data_mapper") # => "DataMapper"
+    #   inflector.camelize_upper("sigterm_extensions/inflector") # => "SigtermExtensions::Inflector"
+    def camelize_upper(input)
+      internal_camelize(input, true)
+    end
+
+    alias :camelize :camelize_upper
+
+
+    # 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 input [String,Symbol] the input
+    # @return [Class, Module] the class or module
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.constantize("Module")         # => Module
+    #   inflector.constantize("SigtermExtensions::Inflector") # => SigtermExtensions::Inflector
+    def constantize(input)
+      Object.const_get(input)
+    end
+
+    # Classify a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the classified string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.classify("books") # => "Book"
+    def classify(input)
+      camelize(singularize(input.to_s.sub(/.*\./, "")))
+    end
+
+    # Dasherize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the dasherized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.dasherize("sigterm_extensions_inflector") # => "sigterm-extensions-inflector"
+    def dasherize(input)
+      input.to_s.tr("_", "-")
+    end
+
+    # Demodulize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the demodulized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.demodulize("SigtermExtensions::Inflector") # => "Inflector"
+    def demodulize(input)
+      input.to_s.split("::").last
+    end
+
+    # Humanize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the humanized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.humanize("dry_inflector") # => "SigtermExtensions inflector"
+    #   inflector.humanize("author_id")     # => "Author"
+    def humanize(input)
+      input = input.to_s
+      result = inflections.humans.apply_to(input)
+      result.chomp!("_id")
+      result.tr!("_", " ")
+      match = /(?<separator>\W)/.match(result)
+      separator = match ? match[:separator] : DEFAULT_SEPARATOR
+      result.split(separator).map.with_index { |word, index|
+        inflections.acronyms.apply_to(word, index.zero?)
+      }.join(separator)
+    end
+
+    # Creates a foreign key name
+    #
+    # @param input [String, Symbol] the input
+    # @return [String] foreign key
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.foreign_key("Message") => "message_id"
+    def foreign_key(input)
+      "#{underscore(demodulize(input))}_id"
+    end
+
+    # Ordinalize a number
+    #
+    # @param number [Integer] the input
+    # @return [String] the ordinalized number
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.ordinalize(1)  # => "1st"
+    #   inflector.ordinalize(2)  # => "2nd"
+    #   inflector.ordinalize(3)  # => "3rd"
+    #   inflector.ordinalize(10) # => "10th"
+    #   inflector.ordinalize(23) # => "23rd"
+    def ordinalize(number) # rubocop:disable Metrics/MethodLength
+      abs_value = number.abs
+
+      if ORDINALIZE_TH.key?(abs_value % 100)
+        "#{number}th"
+      else
+        case abs_value % 10
+        when 1 then "#{number}st"
+        when 2 then "#{number}nd"
+        when 3 then "#{number}rd"
+        else        "#{number}th"
+        end
+      end
+    end
+
+    # Pluralize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the pluralized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.pluralize("book")  # => "books"
+    #   inflector.pluralize("money") # => "money"
+    def pluralize(input)
+      input = input.to_s
+      return input if uncountable?(input)
+      inflections.plurals.apply_to(input)
+    end
+
+    # Singularize a string
+    #
+    # @param input [String] the input
+    # @return [String] the singularized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.singularize("books") # => "book"
+    #   inflector.singularize("money") # => "money"
+    def singularize(input)
+      input = input.to_s
+      return input if uncountable?(input)
+      inflections.singulars.apply_to(input)
+    end
+
+    # Tableize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the tableized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.tableize("Book") # => "books"
+    def tableize(input)
+      input = input.to_s.gsub(/::/, "_")
+      pluralize(underscore(input))
+    end
+
+    # Underscore a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the underscored string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "sigterm_extensions/inflector"
+    #
+    #   inflector = SigtermExtensions::Inflector.new
+    #   inflector.underscore("sigterm-extensions-inflector") # => "sigterm_extensions_inflector"
+    def underscore(input)
+      input = input.to_s.gsub("::", "/")
+      input.gsub!(inflections.acronyms.regex) do
+        m1 = Regexp.last_match(1)
+        m2 = Regexp.last_match(2)
+        "#{m1 ? '_' : '' }#{m2.downcase}"
+      end
+      input.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      input.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      input.tr!("-", "_")
+      input.downcase!
+      input
+    end
+
+    # Check if the input is an uncountable word
+    #
+    # @param input [String] the input
+    # @return [TrueClass,FalseClass] the result of the check
+    #
+    # @since 0.1.0
+    # @api private
+    def uncountable?(input)
+      !(input =~ /\A[[:space:]]*\z/).nil? || inflections.uncountables.include?(input.downcase)
+    end
+
+    # @return [String]
+    #
+    # @since 0.2.0
+    # @api public
+    def to_s
+      '#<SigtermExtensions::Inflector>'
+    end
+    alias inspect to_s
+
+    private
+
+    # @since 0.1.0
+    # @api private
+    ORDINALIZE_TH = (11..13).each_with_object({}) { |n, ret| ret[n] = true }.freeze
+
+    # @since 0.1.2
+    # @api private
+    DEFAULT_SEPARATOR = " "
+
+    attr_reader :inflections
+
+    # @since 0.1.3
+    # @api private
+    def internal_camelize(input, upper)
+      input = input.to_s.dup
+      input.sub!(/^[a-z\d]*/) { |match| inflections.acronyms.apply_to(match, upper) }
+      input.gsub!(%r{(?:_|(/))([a-z\d]*)}i) do
+        m1 = Regexp.last_match(1)
+        m2 = Regexp.last_match(2)
+        "#{m1}#{inflections.acronyms.apply_to(m2)}"
+      end
+      input.gsub!("/", "::")
+      input
+    end
+
+  end
+end