ehbrs-tools 0.5.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa659c13e85b5935fb4c1f79c3dacece337e2a2c4305d3696447a63585d8cf9f
-  data.tar.gz: 760fe597d4e550c63c5ecc5a6a94d22b5ee70d2d5ea73a3b036c7a21c7bf3d92
+  metadata.gz: 6f3e4b8b8c20622926deed970635cf35570dc1171177cd99ee276a78a40d916e
+  data.tar.gz: 62f890aa3e488464d788a1f7ea5a055ba99e22ca1e48427fdf6ff30643c4290c
 SHA512:
-  metadata.gz: 84aaa531f252a3a05242866c3593056cb33df6cce824a186067d610cf51a2ad01b5077f61d726d23fd19b75218809df0a44bf7cab842780da47642e1f274a80d
-  data.tar.gz: 7ccbf1c9fe7be6a41a1a6acffdcabff9ca4c821ee313606e3ddaf8cc3d89daa3d7357ea77b972b0c824499e8c39836f9d97b5094eceac57b5f03b522a46294b5
+  metadata.gz: b5c33b1f44b74bd9b3a1b89739dcb4cb1b013ce99aadec47d0ccfc6fe6d430d265749141d4ddddf73d498771582586146652a00c9de19b2da5a8968b86da578e
+  data.tar.gz: f8cd84b153932edb1a1ce1b20ca7df3dc707899a6d2d801b6d771d24ee3eb3cdc0a718ccaaf850f68ef86a9e132d50b296210c2dcd15eacc9b673fcc79300ce2

data/lib/ehbrs/executables.rb

@@ -15,8 +15,10 @@ module Ehbrs
       private
 
       {
+        '-?' => %w[rar],
+        '-h' => %w[unzip],
         '-version' => %w[ffmpeg ffprobe],
-        '--version' => %w[flips-linux wit]
+        '--version' => %w[flips tar wit]
       }.each do |validate_arg, commands|
         commands.each do |command|
           define_method("#{command}_uncached") do
@@ -24,6 +26,10 @@ module Ehbrs
           end
         end
       end
+
+      def sevenzip_uncached
+        env.executable('7z', '--help')
+      end
     end
   end
 end

data/lib/ehbrs/fs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Ehbrs
+  module Fs
+    require_sub __FILE__
+  end
+end

data/lib/ehbrs/fs/compressed_package.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'avm/files/info'
+require 'eac_ruby_utils/core_ext'
+
+module Ehbrs
+  module Fs
+    class CompressedPackage < ::Avm::Files::Info
+      MIME_TYPES = {
+        'application/zip' => :zip,
+        'application/x-7z-compressed' => :sevenzip,
+        'application/x-rar' => :rar,
+        'application/x-tar' => :tar
+      }.freeze
+
+      def extract_to(target)
+        target = target.to_pathname
+        target.mkpath
+        sub_extract_to(target)
+      end
+
+      private
+
+      def sub_extract_to(target)
+        MIME_TYPES[content_type.mime_type].if_present do |v|
+          return send("#{v}_extract_command", target).execute!
+        end
+        raise "Unknown how to extract \"#{path}\" (#{content_type})"
+      end
+
+      def sevenzip_extract_command(target_dir)
+        ::Ehbrs::Executables.sevenzip.command('x', path, '-o', target_dir)
+      end
+
+      def tar_extract_command(target_dir)
+        ::Ehbrs::Executables.tar.command('-xf', path, '-C', target_dir)
+      end
+
+      def rar_extract_command(target_dir)
+        ::Ehbrs::Executables.rar.command('x', path.expand_path).chdir(target_dir)
+      end
+
+      def zip_extract_command(target_dir)
+        ::Ehbrs::Executables.unzip.command(path, '-d', target_dir)
+      end
+    end
+  end
+end

data/lib/ehbrs/gems.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_gems_utils/gem'
+
+module Ehbrs
+  module Gems
+    class << self
+      enable_simple_cache
+
+      def app_path
+        ::Pathname.new('../..').expand_path(__dir__)
+      end
+
+      def vendor_gems_root
+        app_path.join('vendor')
+      end
+
+      private
+
+      def app_uncached
+        ::EacRubyGemsUtils::Gem.new(app_path)
+      end
+
+      def all_uncached
+        vendor_gems + [app]
+      end
+
+      def vendor_gems_uncached
+        r = []
+        vendor_gems_root.each_child.each do |child|
+          r << ::EacRubyGemsUtils::Gem.new(child) if child.directory?
+        end
+        r
+      end
+    end
+  end
+end

data/lib/ehbrs/observers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Ehbrs
+  module Fs
+    module Observers
+      require_sub __FILE__
+    end
+  end
+end

data/lib/ehbrs/observers/base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'ostruct'
+
+module Ehbrs
+  module Observers
+    class Base
+      include ::EacRubyUtils::Listable
+
+      lists.add_string :blank_value, :add, :ignore, :raise
+
+      attr_reader :records, :blank_value, :last_check_time
+
+      common_constructor :options, default: [{}] do
+        @records = options[:records] || []
+        @blank_value = options[:blank_value].if_present(BLANK_VALUE_ADD) do |v|
+          v = v.to_s
+          ::Ehbrs::Observers::Base.lists.blank_value.value_validate!(v)
+          v
+        end
+      end
+
+      def check(value, date = ::Time.zone.now)
+        @last_check_time = date
+        send("check_with_blank_value_#{blank_value}", value, date)
+      end
+
+      def changing_value?(value)
+        records.if_present(true) do
+          last_value.if_present(value.present?) { |v| v != value }
+        end
+      end
+
+      def last_change_time
+        records.last.if_present(&:time)
+      end
+
+      def last_value
+        records.last.if_present(&:value)
+      end
+
+      private
+
+      def check_with_blank_value_add(value, time)
+        return false unless changing_value?(value)
+
+        records << ::OpenStruct.new(value: value, time: time)
+        true
+      end
+
+      def check_with_blank_value_ignore(value, date)
+        return false if value.blank? ? false : check_with_blank_value_add(value, date)
+      end
+
+      def check_with_blank_value_raise(value, date)
+        raise(::ArgumentError, "Blank value checked (Value: #{value}, Class: #{value.class})") if
+        value.blank?
+
+        check_with_blank_value_add(value, date)
+      end
+    end
+  end
+end

data/lib/ehbrs/observers/with_persistence.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'ehbrs/observers/base'
+
+module Ehbrs
+  module Observers
+    class WithPersistence < ::Ehbrs::Observers::Base
+      attr_reader :path
+
+      def initialize(path, options = {})
+        super(options)
+        @path = path.to_pathname
+        load
+      end
+
+      def check(value, date = ::Time.zone.now)
+        save if super(value, date)
+      end
+
+      def load
+        save unless path.exist?
+        data = ::YAML.load_file(path.to_path)
+        @records = data.fetch(:records).map { |h| ::OpenStruct.new(h) }
+        @last_check_time = data.fetch(:last_check_time)
+      end
+
+      def save
+        path.parent.mkpath
+        path.write({ records: records.map(&:to_h), last_check_time: last_check_time }.to_yaml)
+      end
+    end
+  end
+end

data/lib/ehbrs/runner/fs.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_cli/default_runner'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/console/docopt_runner'
+
+module Ehbrs
+  class Runner < ::EacRubyUtils::Console::DocoptRunner
+    class Fs < ::EacRubyUtils::Console::DocoptRunner
+      include ::EacCli::DefaultRunner
+      require_sub __FILE__
+
+      runner_definition do
+        desc 'Ferramentas para o sistema de arquivos.'
+        subcommands
+      end
+    end
+  end
+end

data/lib/ehbrs/runner/fs/used_space.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'ehbrs/self/observers/used_space'
+require 'filesize'
+
+module Ehbrs
+  class Runner < ::EacRubyUtils::Console::DocoptRunner
+    class Fs < ::EacRubyUtils::Console::DocoptRunner
+      class UsedSpace < ::EacRubyUtils::Console::DocoptRunner
+        include ::EacCli::DefaultRunner
+
+        runner_definition do
+          desc 'Verifica e anota alterações de espaço usado de um objeto de sistema de arquivos.'
+          bool_opt '-c', '--check', 'Anota o espaço em disco.'
+          bool_opt '-v', '--verbose', 'Verbose.'
+          pos_arg :paths, repeat: true
+        end
+
+        def run
+          root_banner
+          paths.each(&:run)
+        end
+
+        def check?
+          options.fetch('--check')
+        end
+
+        private
+
+        def root_banner
+          return unless verbose?
+
+          infov 'Paths', paths.count
+          infov 'Check?', check?
+          infov 'Verbose?', verbose?
+        end
+
+        def path_class
+          verbose? ? PathVerbose : PathUnverbose
+        end
+
+        def paths_uncached
+          options.fetch('<paths>').map { |path| path_class.new(self, path) }
+        end
+
+        def verbose?
+          options.fetch('--verbose')
+        end
+
+        class PathBase
+          enable_simple_cache
+          enable_console_speaker
+          common_constructor :runner, :path do
+            self.path = path.to_pathname
+          end
+
+          private
+
+          def last_change_time
+            time_label(observer.observer.last_change_time)
+          end
+
+          def last_check
+            time_label(observer.observer.last_check_time)
+          end
+
+          def last_value
+            bytes_label(observer.observer.last_value)
+          end
+
+          def current_value
+            bytes_label(observer.current_value).colorize(
+              observer.changing_value? ? :green : :light_black
+            )
+          end
+
+          def changing_value?
+            changing_label(observer.changing_value?)
+          end
+
+          def observer_uncached
+            ::Ehbrs::Self::Observers::UsedSpace.new(path)
+          end
+
+          def changing_label(bool)
+            bool.to_s.colorize(bool ? :green : :light_black)
+          end
+
+          def time_label(time)
+            time.if_present('-', &:to_s)
+          end
+        end
+
+        class PathVerbose < PathBase
+          def run
+            infom path.to_s
+            on_speaker_node do |node|
+              node.stderr_line_prefix = '  '
+              banner
+              check
+            end
+          end
+
+          private
+
+          def banner
+            { 'Path' => observer.path,
+              'Persistence path' => observer.persistence_path,
+              'Last check' => last_check,
+              'Last change' => last_change_time,
+              'Last value' => last_value,
+              'Current value' => current_value,
+              'Changing?' => changing_value? }.each do |k, v|
+              infov k, v
+            end
+          end
+
+          def check
+            return unless runner.check?
+
+            infom 'Checking...'
+            if observer.check_current_value
+              success 'A new value was recorded'
+            else
+              info 'No new value was recorded'
+            end
+          end
+
+          def bytes_label(number)
+            number.if_present('-') { |v| "#{v} (#{::Filesize.from("#{v} B").pretty})" }
+          end
+        end
+
+        class PathUnverbose < PathBase
+          def run
+            self.puts output_line
+          end
+
+          def output_line
+            [path.to_s.cyan, last_change_time, last_value, current_value, check_result]
+              .reject(&:blank?).join('|')
+          end
+
+          def check_result
+            return nil unless runner.check?
+
+            observer.check_current_value ? 'Recorded'.green : 'Unchanged'.light_black
+          end
+
+          def bytes_label(number)
+            number.if_present('-') { |v| ::Filesize.from("#{v} B").pretty }
+          end
+
+          def time_label(time)
+            time.if_present('-') { |t| t.strftime('%d/%m/%y %H:%M') }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/runner/self.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_cli/default_runner'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/console/docopt_runner'
+
+module Ehbrs
+  class Runner < ::EacRubyUtils::Console::DocoptRunner
+    class Self < ::EacRubyUtils::Console::DocoptRunner
+      require_sub __FILE__
+      include ::EacCli::DefaultRunner
+
+      runner_definition do
+        desc 'Self utilities'
+        subcommands
+      end
+    end
+  end
+end