ehbrs-tools 0.6.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96df751900aa306378007272674b8421190952ee71b133b05c10fd247397ec50
-  data.tar.gz: 80cce53bd76f46cb08de212d227ac639345198a5c93e9fb3deedd7c214831bf9
+  metadata.gz: 01424b2d17105c7694679a4deb6dda7d0ab4b98f6ee0b32ed5d183bfdac33583
+  data.tar.gz: 271b08e6e6cf9a3868e06d1a13520030e6f1c55d167b86781f1250e92540dee7
 SHA512:
-  metadata.gz: 538ff43fc795b7dac1aa2ab1cd24974aa8155603e0f4929c5a2a8e7186e2f546625293b6db799c73f46198114541a213bd33d9a27b819d91182e6cbf743a81a7
-  data.tar.gz: 2292ab898b428f1afb0c490816c0756d832c2cc40fd81ef7e7aa5dfb90a11b28b257ed09de45563d12d84d915b054081db71475da169dedc26bdaab5aa1945ac
+  metadata.gz: bd53a0486dfec03c0d827ee8f759c5f28a490c93cb2320ea623f8a01ec5f9bdc106dd955f55114d098236b0418d96f62ab47cc2df8248b01da66bd87b3db52d8
+  data.tar.gz: 31dc82bd83f87cb8ea9ab4f2e8d2eac8ceba2477bf2d200156b3c01ada3794ddb673bb1d9581fc72ed9da97c3771393b701ae65f1c3c0447b9aeb344afb11d6a

data/lib/ehbrs/executables.rb

@@ -15,8 +15,10 @@ module Ehbrs
       private
 
       {
+        '-?' => %w[rar],
+        '-h' => %w[unzip],
         '-version' => %w[ffmpeg ffprobe],
-        '--version' => %w[flips 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/google.rb

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

data/lib/ehbrs/google/translate.rb

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

data/lib/ehbrs/google/translate/session.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'aranha/selenium/session'
+
+module Ehbrs
+  module Google
+    module Translate
+      class Session
+        START_URL = 'https://translate.google.com.br/#view=home&op=docs&sl=en&tl=pt'
+        CLOSE_POPUP_CSS = '.dismiss-button'
+        FILE_INPUT_XPATH = '//*[@id = "tlid-file-input"]'
+        SUBMIT_XPATH = '//form[@action="//translate.googleusercontent.com/translate_f"]' \
+          '//input[@type="submit"]'
+        RESULT_XPATHS = [
+          '//script[contains(@src, "https://translate.google.com/translate_a")]',
+          '/html/body/pre'
+        ].freeze
+
+        attr_reader :sub
+
+        def initialize
+          @sub = ::Aranha::Selenium::Session.new
+        end
+
+        def translate(source_document_path)
+          go_to_upload_form
+          input_file(source_document_path)
+          close_changes_alert_popup
+          click_on_translate_button
+          wait_for_load_translation
+          sub.current_source
+        end
+
+        private
+
+        def go_to_upload_form
+          sub.navigate.to START_URL
+          sub.wait_for_element(xpath: FILE_INPUT_XPATH)
+        end
+
+        def input_file(source_document_path)
+          sub.find_element(xpath: FILE_INPUT_XPATH).send_keys(source_document_path)
+        end
+
+        def click_on_translate_button
+          sub.wait_for_click(xpath: SUBMIT_XPATH)
+        end
+
+        def close_changes_alert_popup
+          sub.wait_for_click(css: CLOSE_POPUP_CSS)
+        end
+
+        def wait_for_load_translation
+          sub.wait.until do
+            RESULT_XPATHS.any? { |xpath| sub.find_elements(xpath: xpath).size.positive? }
+          end
+        end
+      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