ruby_smart-support 1.0.0

data/lib/ruby_smart/support/core_ext/ruby/hash.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+unless Hash.method_defined? "to_md5"
+  class Hash
+    # returns the md5 of any hash by using the to_s method
+    # @return [String] md5
+    def to_md5
+      Digest::MD5.hexdigest(Hash[self.sort].to_s)
+    end
+  end
+end
+
+# idea by https://stackoverflow.com/questions/9786264/all-possible-combinations-from-a-hash-of-arrays-in-ruby
+unless Hash.method_defined? "product"
+  class Hash
+    # creates a 'product' of all values per existing key as a combination
+    #
+    #   hash = { first: [:a,:b], second: [:x,:c]}
+    #   > [{:first=>:a, :second=>:x}, {:first=>:a, :second=>:c}, {:first=>:b, :second=>:x}, {:first=>:b, :second=>:c}]
+    #
+    # @return [Array] combinations
+    def product
+      product = values[0].product(*values[1..-1])
+      product.map{|p| Hash[keys.zip p]}
+    end
+  end
+end

data/lib/ruby_smart/support/core_ext/ruby/object.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+unless Object.method_defined? "numeric?"
+  class Object
+    # returns true if this object is a numeric or a kind of numeric
+    # @return [Boolean] numeric
+    def numeric?
+      return true if self.is_a?(Numeric)
+      return true if self.to_s =~ /\A\d+\Z/
+      return true if Float(self) rescue false
+
+      false
+    end
+  end
+end
+
+unless Object.method_defined? "boolean?"
+  class Object
+    # return true if object is a boolean class (TrueClass or FalseClass)
+    # @return [Boolean] boolean
+    def boolean?
+      self.is_a?(TrueClass) || self.is_a?(FalseClass)
+    end
+  end
+end
+
+unless Object.method_defined? "missing_method?"
+  class Object
+    # returns true if method is missing.
+    # the second optional parameter <tt>check_ancestors</tt> prevents to check it's ancestors by providing a *false* value
+    # @param [Symbol] name - the method's name to check
+    # @param [Boolean] check_ancestors - check class ancestors (default: true)
+    # @return [Boolean] missing_method
+    def missing_method?(name, check_ancestors = true)
+      !self.instance_methods(check_ancestors).include?(name)
+    end
+  end
+end
+
+unless Object.method_defined? "alias_missing_method"
+  class Object
+    # creates an alias for provided method if it's missing.
+    # the third optional parameter <tt>check_ancestors</tt> prevents to check it's ancestors by providing a *false* value
+    # @param [Symbol] new - new method name
+    # @param [Symbol] old - old method name
+    # @param [Boolean] check_ancestors - check class ancestors (default: true)
+    def alias_missing_method(new, old, check_ancestors = true)
+      alias_method(new, old) if missing_method?(new, check_ancestors)
+    end
+  end
+end

data/lib/ruby_smart/support/core_ext/ruby/string.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+unless String.method_defined? "to_boolean"
+  class String
+    # converts a string to 'boolean'
+    # @return [Boolean] bool
+    def to_boolean
+      ['true','1'].include? self.downcase
+    end
+  end
+end
+
+unless String.method_defined? "to_md5"
+  class String
+    # returns the md5 of this string
+    # @return [String] md5
+    def to_md5
+      ::Digest::MD5.hexdigest(self)
+    end
+  end
+end

data/lib/ruby_smart/support/core_ext.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "core_ext/ruby/array"
+require_relative "core_ext/ruby/float"
+require_relative "core_ext/ruby/hash"
+require_relative "core_ext/ruby/object"
+require_relative "core_ext/ruby/string"
+
+require_relative "gem_info"
+
+# activesupport related stuff
+if RubySmart::Support::GemInfo.loaded?('activesupport')
+  require_relative "core_ext/activesupport/hash"
+end
+
+# load Rails related stuff
+if RubySmart::Support::GemInfo.loaded?('rails')
+  # since the Rails::Info.property block-returns are stored on call we need to wait
+  # until we have information about the rails application.
+  # This is done with the following hook
+  ActiveSupport.on_load(:before_initialize) do
+    require_relative "core_ext/rails/info"
+  end
+end
+
+# load Rake related stuff
+if RubySmart::Support::GemInfo.loaded?('rake')
+  require_relative "core_ext/rake/task"
+end

data/lib/ruby_smart/support/gem_info.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module RubySmart
+  module Support
+    module GemInfo
+
+      # regexp to detect a gems path
+      GEM_PATH_REGEXP = /\/gems\//
+
+      # regexp to resolves a name from a gem path
+      GEM_NAME_REGEXP = /\/gems\/([A-za-z0-9_\-]+)\-[\d\w\-\_\.]+\//
+
+      # regexp to resolves a feature from a gem path
+      FEATURE_NAME_REGEXP = /\/gems\/([A-za-z0-9_\-]+)\-[\d\w\-\_\.]+\/lib\/(?:\1\/(\1)|([A-za-z0-9_\-]+))\.rb/
+
+      # returns a hash of all installed gems with it's versions
+      #
+      #   GemInfo.installed
+      #   > {'bundler' => ['2.2.30', '1.2.3']}
+      #
+      # @return [Hash{<name> => Array[<version>]}] gem name-versions hash
+      def self.installed
+        Hash[::Gem::Specification.reduce({}) { |m, g| m[g.name] ||= []; m[g.name] << g.version.to_s; m }.sort]
+      end
+
+      # returns true if the provided gem name is installed.
+      # the optional version requirement matches against any available version
+      #
+      #   GemInfo.installed?('bundler')
+      #   > true
+      #
+      #   GemInfo.installed?('bundler', '~> 3.0')
+      #   > false
+      #
+      # @param [String] name - the gem name
+      # @param [nil, String] version - optional version requirement
+      # @return [Boolean]
+      def self.installed?(name, version = nil)
+        installed.key?(name) && (version.nil? || installed[name].any? { |gem_version| match?(version, gem_version) })
+      end
+
+      # returns a hash of all loaded gems with its current version
+      #
+      #   GemInfo.loaded
+      #   > {'bundler' => '2.2.30'}
+      #
+      # @return [Hash{<name> => <version>}] gem name-version hash
+      def self.loaded
+        Hash[::Gem.loaded_specs.values.map { |g| [g.name, g.version.to_s] }.sort]
+      end
+
+      # returns true if the provided gem name is loaded.
+      # the optional version requirement matches against the loaded version
+      #
+      #   GemInfo.loaded?('bundler')
+      #   > true
+      #
+      #   GemInfo.loaded?('bundler', '~> 3.0')
+      #   > false
+      #
+      # @param [String] name - the gem name
+      # @param [nil, String] version - optional version requirement
+      # @return [Boolean]
+      def self.loaded?(name, version = nil)
+        loaded.key?(name) && (version.nil? || match?(version, loaded[name]))
+      end
+
+      # returns an array of all active gems
+      #
+      #   GemInfo.active
+      #   > ['bundler']
+      #
+      # @return [Array<name>}] gem names
+      def self.active
+        $LOADED_FEATURES.
+          select { |feature| feature.match(GEM_PATH_REGEXP) }.
+          map { |feature|
+            m = feature.match(GEM_NAME_REGEXP)
+            m ? m[1] : File.dirname(feature).split('/').last
+          }.
+          uniq.
+          sort
+      end
+
+      # returns true if the provided gem name is active.
+      # the optional version requirement matches against the *loaded* version
+      #
+      #   GemInfo.active?('bundler')
+      #   > true
+      #
+      #   GemInfo.active?('bundler', '~> 3.0')
+      #   > false
+      #
+      # @param [String] name - the gem name
+      # @param [nil, String] version - optional version requirement
+      # @return [Boolean] activated?
+      def self.active?(name, version = nil)
+        active.include?(name) && (version.nil? || match?(version, version(name)))
+      end
+
+      # returns an array of all loaded features
+      #
+      #   GemInfo.features
+      #   > ['active_support','bundler']
+      #
+      # @return [Array<String>}] module names
+      def self.features
+        $LOADED_FEATURES.
+          select { |feature| feature.match(GEM_PATH_REGEXP) }.
+          map { |feature|
+            m = feature.match(FEATURE_NAME_REGEXP)
+            m ? (m[2] || m[3]) : nil
+          }.
+          uniq.
+          compact.
+          sort
+      end
+
+      # returns true if the provided feature is loaded.
+      #
+      #   GemInfo.feature?('active_support')
+      #   > true
+      #
+      # @param [String] name - the feature name
+      # @return [Boolean]
+      def self.feature?(name)
+        features.include?(name)
+      end
+
+      # returns the currently loaded gem version
+      #
+      #   GemInfo.version 'bundler'
+      #   > '2.2.30'
+      #
+      # @return [String,nil] current gem version - return nil if the gem wasn't found
+      def self.version(name)
+        loaded[name]
+      end
+
+      # safe requires a feature by provided name & optional gem
+      #
+      #   GemInfo.safe_require('rake')
+      #   > true
+      #
+      #   GemInfo.safe_require('active_support')
+      #   > true
+      #
+      #   GemInfo.safe_require('action_view/helpers/date_helper','actionview', '> 0.1.0')
+      #   > true
+      #
+      # @param [String] path - the resource path
+      # @param [nil,String] gem - optional gem name
+      # @param [nil,String] version - optional gem version compare string
+      # @return [Boolean]
+      def self.safe_require(path, gem = nil, version = nil)
+        # check for missing gem (nicely check if the feature name differs to the gem name)
+        return false if !gem.nil? && path != gem && !active?(gem, version)
+
+        # try to require the feature
+        begin
+          require path
+        rescue LoadError, NameError
+          return false
+        end
+
+        # just the final true result
+        true
+      end
+
+      # compares two versions against each other
+      #
+      #   match?('4.3.0', '4.3.0')
+      #   > true
+      #
+      #   match?('>= 3.0', '4.3.0')
+      #   > true
+      #
+      #   match?( '~> 3.1', '3.3.0')
+      #   > true
+      #
+      #   match?( '~> 1.1.0', '0.1.0')
+      #   > false
+      def self.match?(version_requirement, version_current)
+        return true if version_requirement.nil?
+
+        # split version compare operators
+        version_requirement_str = version_requirement.gsub(/([=~>< ]+)/, '')
+        version_requirement_op  = $1
+
+        # create plain versions without compare operators
+        gem_version_current     = Gem::Version.new(version_current)
+        gem_version_requirement = Gem::Version.new(version_requirement_str)
+
+        # check if required version is PRE & current is NOT
+        if gem_version_requirement.prerelease? && !gem_version_current.prerelease?
+          version_requirement = "#{version_requirement_op}#{gem_version_requirement.release}"
+        elsif gem_version_requirement.prerelease? != gem_version_current.prerelease?
+          # check if required version PRE doesn't equal current version PRE
+          version_current = gem_version_current.release.to_s
+        end
+        # else is not required here: either its PRE && PRE || !PRE && !PRE
+
+        Gem::Dependency.new('', version_requirement).match?('', version_current)
+      end
+    end
+  end
+end

data/lib/ruby_smart/support/gem_version.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubySmart
+  module Support
+    # Returns the version of the currently loaded module as a <tt>Gem::Version</tt>
+    def self.gem_version
+      Gem::Version.new VERSION::STRING
+    end
+
+    module VERSION
+      MAJOR = 1
+      MINOR = 0
+      TINY  = 0
+      PRE   = nil
+
+      STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+
+      def self.to_s
+        STRING
+      end
+    end
+  end
+end

data/lib/ruby_smart/support/thread_info.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module RubySmart
+  module Support
+    module ThreadInfo
+
+      # defines a array of types which will be checked by resolving the current thread type
+      TYPE_ORDER = [:rake, :console, :server].freeze
+
+      # returns true if this is a running rake process
+      # @return [Boolean]
+      def self.rake?
+        !!defined?(Rake.application) && Rake.application.top_level_tasks.any?
+      end
+
+      # returns true if this is a running rails process
+      # @return [Boolean]
+      def self.rails?
+        !!defined?(Rails.application)
+      end
+
+      # returns true if this is a running console process
+      # @return [Boolean]
+      def self.console?
+        irb? || pry? || io_console?
+      end
+
+      # returns true if this is a running IRB process
+      # @return [Boolean]
+      def self.irb?
+        !!defined?(IRB)
+      end
+
+      # returns true if this is a running Pry process
+      # @return [Boolean]
+      def self.pry?
+        !!defined?(Pry)
+      end
+
+      # returns true if this is a running server process.
+      # currently only detects rails
+      # @return [Boolean]
+      def self.server?
+        !!defined?(Rails::Server)
+      end
+
+      # returns true if this is a running rails console process
+      # @return [Boolean]
+      def self.rails_console?
+        console? && !!(defined?(Rails::Console) || ENV['RAILS_ENV'])
+      end
+
+      # returns true if this is a running IO console process
+      # @return [Boolean]
+      def self.io_console?
+        !!defined?(IO.console) && !!IO.console
+      end
+
+      # returns true if this is a running thread process.
+      # as it always should ...
+      # @return [Boolean]
+      def self.thread?
+        !!thread
+      end
+
+      # returns the current thread
+      # @return [Thread]
+      def self.thread
+        ::Thread.current
+      end
+
+      # returns the current thread id
+      # @return [Integer] thread_id
+      def self.thread_id
+        thread? ? thread.object_id : 0
+      end
+
+      # returns the ascertained id
+      # @return [Integer] id
+      def self.process_object_id
+        return Rake.application.top_level_tasks.first.object_id if rake?
+        return Rails.application.object_id if rails?
+        thread_id
+      end
+
+      # returns the OS process id
+      # @return [Integer] id
+      def self.id
+        $$
+      end
+
+      # returns the current thread name
+      # - for rake tasks the task name
+      # - for rails the application name
+      #
+      # @return [String] name
+      def self.name
+        return Rake.application.top_level_tasks.first.to_s if rake?
+        return Rails.application.to_s.split('::').first if rails?
+        ''
+      end
+
+      # returns the current thread by logical order
+      # defined through const TYPE_ORDER
+      # @return [nil, Symbol]
+      def self.type
+        TYPE_ORDER.detect { |type| self.send("#{type}?") } || :unknown
+      end
+
+      # returns the thread type string
+      # @return [String] thread-info string
+      def self.info
+        strs = ["$#{id}", "[##{process_object_id}]","@ #{type}"]
+        strs << " :: #{name}" if name != ''
+        strs.join ' '
+      end
+
+      # returns true if thread has a 'window'
+      # @return [Boolean]
+      def self.windowed?
+        winsize[1] > 0
+      end
+
+      # returns the current windows size, if current IO has a window
+      # @return [Array<rows, columns>] winsize
+      def self.winsize
+        return IO.console.winsize if io_console?
+        return [ENV['ROWS'], ENV['COLUMNS']] unless ENV['ROWS'].nil? && ENV['COLUMNS'].nil?
+        [0, 0]
+      end
+
+      # return true if a log can be send to stdout
+      def self.stdout?
+        console? && windowed?
+      end
+    end
+  end
+end

data/lib/ruby_smart/support/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'gem_version'
+
+module RubySmart
+  module Support
+    # Returns the version of the currently loaded Gem as a <tt>Gem::Version</tt>
+    def self.version
+      gem_version
+    end
+  end
+end

data/lib/ruby_smart/support.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "support/version"
+require_relative "support/core_ext"
+require_relative "support/gem_info"
+require_relative "support/thread_info"
+
+module RubySmart
+  module Support
+  end
+end

data/lib/ruby_smart-support.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'ruby_smart/support'

data/lib/thread_info.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'ruby_smart/support/thread_info'
+
+# Alias to <tt>ruby_smart/support/thread_info</tt>
+ThreadInfo = RubySmart::Support::ThreadInfo

data/ruby_smart-support.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/ruby_smart/support/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby_smart-support"
+  spec.version       = RubySmart::Support.version
+  spec.authors       = ["Tobias Gonsior"]
+  spec.email         = ["info@ruby-smart.org"]
+
+  spec.summary     = "A toolkit of support libraries including GemInfo, ThreadInfo, Ruby core extensions & optionally activesupport extensions"
+  spec.description = <<DESC
+RubySmart::Support is a toolkit of support libraries for Ruby - major features includes GemInfo & ThreadInfo, as well core extensions for Ruby & activesupport (if installed).
+DESC
+
+  spec.homepage              = "https://github.com/ruby-smart/support"
+  spec.license               = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"]      = spec.homepage
+  spec.metadata["source_code_uri"]   = "https://github.com/ruby-smart/support"
+  spec.metadata["changelog_uri"]     = "#{spec.metadata["source_code_uri"]}/blob/main/docs/CHANGELOG.md"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'activesupport', ">= 4.0"
+  spec.add_development_dependency 'rspec',  "~> 3.0"
+  spec.add_development_dependency 'rake', "~> 13.0"
+  spec.add_development_dependency 'simplecov',  '~> 0.21'
+end