ehbrs-tools 0.19.0 → 0.23.0

data/vendor/eac_ruby_base0/spec/spec_helper.rb

@@ -97,4 +97,7 @@ RSpec.configure do |config|
   #   # test failures related to randomization by passing the same `--seed` value
   #   # as the one that triggered the failure.
   #   Kernel.srand config.seed
+
+  require 'eac_ruby_gem_support/rspec'
+  ::EacRubyGemSupport::Rspec.setup(::File.expand_path('..', __dir__), config)
 end

data/vendor/eac_ruby_utils/eac_ruby_utils.gemspec

@@ -17,8 +17,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'activesupport', '>= 4.0'
   s.add_dependency 'addressable', '~> 2.6'
-  s.add_dependency 'colorize', '~> 0.8.1'
-  s.add_dependency 'docopt', '~> 0.6.1'
+  s.add_dependency 'filesize'
   s.add_dependency 'net-ssh', '~> 4.2'
-  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.1', '>= 0.1.1'
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/context.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class Context
+    def current
+      optional_current || raise('No elements in context')
+    end
+
+    def optional_current
+      stack.last
+    end
+
+    delegate :pop, to: :stack
+    delegate :push, to: :stack
+
+    def on(obj)
+      push(obj)
+      begin
+        yield
+      ensure
+        pop
+      end
+    end
+
+    private
+
+    def stack
+      @stack ||= []
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/contextualizable.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
+require 'eac_ruby_utils/context'
+
 module EacRubyUtils
-  # Provides the method context which search and call a method in self and ancestor objects.
   module Contextualizable
-    def context(method)
-      current = self
-      while current
-        return current.send(method) if current.respond_to?(method)
+    common_concern
+
+    module ClassMethods
+      def context
+        @context ||= ::EacRubyUtils::Context.new
+      end
+    end
 
-        current = current.respond_to?(:parent) ? current.parent : nil
+    module InstanceMethods
+      def context
+        self.class.context
       end
-      raise "Context method \"#{method}\" not found for #{self.class}"
     end
   end
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/command.rb

@@ -10,7 +10,6 @@ module EacRubyUtils
   module Envs
     class Command
       require_sub __FILE__, include_modules: true
-      enable_console_speaker
 
       def initialize(env, command, extra_options = {})
         @env = env
@@ -61,17 +60,17 @@ module EacRubyUtils
 
       def execute(options = {})
         c = command(options)
-        puts "BEFORE: #{c}".light_red if debug?
+        debug_print("BEFORE: #{c}")
         t1 = Time.now
         r = ::EacRubyUtils::Envs::Process.new(c).to_h
         i = Time.now - t1
-        puts "AFTER [#{i}]: #{c}".light_red if debug?
+        debug_print("AFTER [#{i}]: #{c}")
         r
       end
 
       def spawn(options = {})
         c = command(options)
-        puts "SPAWN: #{c}".light_red if debug?
+        debug_print("SPAWN: #{c}")
         ::EacRubyUtils::Envs::Spawn.new(c)
       end
 
@@ -83,7 +82,7 @@ module EacRubyUtils
 
       def system(options = {})
         c = command(options)
-        puts c.light_red if debug?
+        debug_print(c)
         Kernel.system(c)
       end
 
@@ -109,6 +108,12 @@ module EacRubyUtils
         ENV['DEBUG'].to_s.strip != ''
       end
 
+      # Print a message if debugging is enabled.
+      def debug_print(message)
+        message = message.to_s
+        puts message.if_respond(:light_red, message) if debug?
+      end
+
       def append_command_options(command, options)
         command = options[:input].command + ' | ' + command if options[:input]
         if options[:input_file]

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/filesystem_cache.rb

@@ -24,6 +24,12 @@ module EacRubyUtils
       ::File.read(content_path)
     end
 
+    def read_or_cache
+      write(yield) unless cached?
+
+      read
+    end
+
     def write(value)
       assert_directory_on_path
       ::File.write(content_path, value)

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/fs/logs.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/filters'
+require 'eac_ruby_utils/fs/temp'
+require 'filesize'
+
+module EacRubyUtils
+  module Fs
+    class Logs
+      TRUNCATE_DEFAULT_LENGTH = 1000
+      TRUNCATE_APPEND_TEXT = '(...) '
+
+      def [](label)
+        log_set.fetch(sanitize_label(label))
+      end
+
+      def add(label)
+        log_set[sanitize_label(label)] = ::EacRubyUtils::Fs::Temp.file
+
+        self
+      end
+
+      def remove_all
+        log_set.each_key { |label| remove(label) }
+
+        self
+      end
+
+      def remove(label)
+        log_set.fetch(sanitize_label(label)).remove
+        log_set.delete(sanitize_label(label))
+      end
+
+      def truncate(label, length = TRUNCATE_DEFAULT_LENGTH)
+        content = self[label].read.strip
+        return content if content.length <= TRUNCATE_DEFAULT_LENGTH
+
+        TRUNCATE_APPEND_TEXT + content[content.length - length + TRUNCATE_APPEND_TEXT.length,
+                                       length - TRUNCATE_APPEND_TEXT.length]
+      end
+
+      def truncate_all(length = TRUNCATE_DEFAULT_LENGTH)
+        s = "Files: #{log_set.length}\n"
+        log_set.each do |label, path|
+          x = truncate(label, length)
+          y = [label, path, ::Filesize.from("#{path.size} B").pretty].join(' / ')
+          s += x.blank? ? ">>> #{y} (Blank) <<<" : ">>> #{y}\n#{x}\n<<< #{y}\n"
+        end
+        s
+      end
+
+      private
+
+      def sanitize_label(label)
+        label.to_sym
+      end
+
+      def log_set
+        @log_set ||= {}
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/inflector.rb

@@ -7,11 +7,19 @@ module EacRubyUtils
     class << self
       VARIABLE_NAME_PATTERN = /[_a-z][_a-z0-9]*/i.freeze
 
-      def variableize(string)
+      # Convert a string to a variable format: first character as a lowercase letter or underscore
+      # and other as a lowercase letter, underscore or numbers.
+      # @param string [String] The source string.
+      # @param validate [Boolean] Affect the outcome when the result builded is not in a valid
+      #   variable format. If `true`, it raises a {ArgumentError}. If `false`, return `nil`.
+      # @return [String, nil]
+      # @raise [ArgumentError]
+      def variableize(string, validate = true)
         r = ::ActiveSupport::Inflector.transliterate(string).gsub(/[^_a-z0-9]/i, '_')
                                       .gsub(/_+/, '_').gsub(/_\z/, '').gsub(/\A_/, '').downcase
         m = VARIABLE_NAME_PATTERN.match(r)
         return r if m
+        return nil unless validate
 
         raise ::ArgumentError, "Invalid variable name \"#{r}\" was generated " \
           "from string \"#{string}\""

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/listable/list.rb

@@ -54,8 +54,9 @@ module EacRubyUtils
       end
 
       def value_validate!(value, error_class = ::StandardError)
-        value_valid?(value) ||
-          raise(error_class, "Invalid value: \"#{value}\" (Valid: #{values_to_s})")
+        return value if value_valid?(value)
+
+        raise(error_class, "Invalid value: \"#{value}\" (Valid: #{values_to_s})")
       end
 
       def values_to_s

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/local_time_zone.rb

@@ -10,26 +10,36 @@ module EacRubyUtils
     class << self
       TIMEDATECTL_TIMEZONE_LINE_PATTERN = %r{\s*Time zone:\s*(\S+/\S+)\s}.freeze
 
+      # @return [ActiveSupport::TimeZone]
       def auto
         %w[tz_env debian_config offset].lazy.map { |s| send("by_#{s}") }.find(&:present?)
       end
 
+      def auto_set
+        ::Time.zone = auto
+      end
+
+      # @return [ActiveSupport::TimeZone]
       def by_debian_config
         path = ::Pathname.new(DEBIAN_CONFIG_PATH)
-        path.exist? ? path.read.strip.presence : nil
+        path.exist? ? path.read.strip.if_present { |v| ::ActiveSupport::TimeZone[v] } : nil
       end
 
+      # @return [ActiveSupport::TimeZone]
       def by_offset
-        ::ActiveSupport::TimeZone[::Time.now.getlocal.gmt_offset].name
+        ::ActiveSupport::TimeZone[::Time.now.getlocal.gmt_offset]
       end
 
+      # @return [ActiveSupport::TimeZone]
       def by_timedatectl
         executable = ::EacRubyUtils::Envs.local.executable('timedatectl', '--version')
         return nil unless executable.exist?
 
         TIMEDATECTL_TIMEZONE_LINE_PATTERN.if_match(executable.command.execute!) { |m| m[1] }
+                                         .if_present { |v| ::ActiveSupport::TimeZone[v] }
       end
 
+      # @return [ActiveSupport::TimeZone]
       def by_tz_env
         ENV['TZ'].presence
       end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/class/settings_provider.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/settings_provider'
+
+class Class
+  def enable_settings_provider
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::SettingsProvider)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/kernel/nyi.rb

@@ -2,7 +2,9 @@
 
 module Kernel
   # Raise exception with text "Not yet implemented".
-  def nyi
-    raise "Not yet implemented (Called in #{caller.first})"
+  def nyi(message = nil)
+    s = "Not yet implemented (Called in #{caller.first})"
+    s += ": #{message}" if message
+    raise s
   end
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/common_concern.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/common_concern'
-require 'eac_ruby_utils/console/speaker'
 
 class Module
   def common_concern(&after_callback)

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/context.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/contextualizable'
+
+class Module
+  # Patches module with [EacRubyUtils::Contextualizable].
+  def enable_context
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::Contextualizable)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/speaker.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/speaker/sender'
+
+class Module
+  def enable_speaker
+    include ::EacRubyUtils::Speaker::Sender
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/if_nil.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Object
+  # @return +block.call(self)+ if +self+ is not nil, +default_value+ otherwise.
+  def if_not_nil(default_value = nil)
+    return default_value if nil?
+
+    block_given? ? yield(self) : self
+  end
+
+  # @return +yield+ if +self+ is nil, +self+ otherwise.
+  def if_nil
+    return yield if nil? && block_given?
+
+    self
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/pathname/parent_n.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  # Apply .parent n times.
+  # @return [Pathname]
+  def parent_n(n) # rubocop:disable Naming/MethodParameterName
+    n.times.inject(self) { |a, _e| a.parent }
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/regexp/to_parser.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/regexp_parser'
+
+class Regexp
+  # @return [::EacRubyUtils::RegexpParser]
+  def to_parser(&block)
+    ::EacRubyUtils::RegexpParser.new(self, &block)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/string/inflector.rb

@@ -3,7 +3,9 @@
 require 'eac_ruby_utils/inflector'
 
 class String
-  def variableize
-    ::EacRubyUtils::Inflector.variableize(self)
+  # Shortcut to `EacRubyUtils::Inflector.variableize(self, ...)`.
+  # @see EacRubyUtils::Inflector.variableize
+  def variableize(validate = true)
+    ::EacRubyUtils::Inflector.variableize(self, validate)
   end
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/time/required_zone.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/local_time_zone'
+
+class Time
+  class << self
+    def required_zone
+      zone || ::EacRubyUtils::LocalTimeZone.auto || raise('No zone set or discovered')
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/regexp_parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class RegexpParser
+    attr_reader :pattern, :builder_proc
+
+    def initialize(pattern, &builder_proc)
+      @pattern = pattern
+      @builder_proc = builder_proc
+    end
+
+    def parse(string)
+      internal_parse(string)[1]
+    end
+
+    def parse!(string)
+      match, result = internal_parse(string)
+      return result if match
+
+      raise ::ArgumentError, "String \"#{string}\" does not match pattern \"#{pattern}\""
+    end
+
+    private
+
+    def internal_parse(string)
+      m = pattern.match(string)
+      if m
+        [true, builder_proc ? builder_proc.call(m) : m]
+      else
+        [false, nil]
+      end
+    end
+  end
+end