ehbrs-tools 0.23.0 → 0.25.1

data/lib/ehbrs/tools/runner/videos/series.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+
+module Ehbrs
+  module Tools
+    class Runner
+      class Videos
+        class Series
+          require_sub __FILE__
+
+          runner_with :help, :subcommands do
+            desc 'Ferramentas para seriados.'
+            subcommands
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/tools/runner/videos/unsupported.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+require 'ehbrs/videos/unsupported/check_set'
+require 'ehbrs/videos/unsupported/search'
+require 'ehbrs/videos/unsupported/profiles'
+
+module Ehbrs
+  module Tools
+    class Runner
+      class Videos
+        class Unsupported
+          PROFILES = %w[aoc philco samsung].freeze
+
+          runner_with :help do
+            desc 'Procura e converte vídeos não suportados pelas TVs de EHB/RS.'
+            bool_opt '-f', '--fix', 'Converte vídeos para o formato apropriado.'
+            arg_opt '-p', '--profiles', "Seleciona os perfis (#{PROFILES.join(', ')})."
+            pos_arg 'paths', repeat: true
+          end
+
+          def run
+            infov 'Profiles', profiles.join(', ')
+            infov 'Paths', paths
+            paths.each do |d|
+              ::Ehbrs::Videos::Unsupported::Search.new(d, file_options)
+            end
+          end
+
+          private
+
+          def file_check_set_uncached
+            ::Ehbrs::Videos::Unsupported::CheckSet.build(profiles, :file)
+          end
+
+          def track_check_set_uncached
+            ::Ehbrs::Videos::Unsupported::CheckSet.build(profiles, :track)
+          end
+
+          def paths
+            parsed.paths
+          end
+
+          def file_options
+            { file_check_set: file_check_set, track_check_set: track_check_set,
+              fix: parsed.fix? }
+          end
+
+          def profiles_uncached
+            parsed.profiles.if_present(PROFILES) { |v| v.split(',').map(&:strip) }
+                  .map { |name| profile_class(name).instance }
+          end
+
+          def profile_class(profile_name)
+            ::Ehbrs::Videos::Unsupported::Profiles.const_get(profile_name.camelize)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/{runner/web_utils → tools/runner}/videos.rb

@@ -3,13 +3,13 @@
 require 'eac_cli/core_ext'
 
 module Ehbrs
-  class Runner
-    class WebUtils
+  module Tools
+    class Runner
       class Videos
         require_sub __FILE__
 
         runner_with :help, :subcommands do
-          desc 'Ferramentas de vídeos para EHB/RS Utils.'
+          desc 'Video tools for EHB/RS.'
           subcommands
         end
       end

data/lib/ehbrs/tools/runner/web_utils/videos/download.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_base0/core_ext'
+require 'ehbrs_ruby_utils/web_utils/videos/file'
+
+module Ehbrs
+  module Tools
+    class Runner
+      class WebUtils
+        class Videos
+          class Download
+            runner_with :confirmation, :help do
+              desc 'Importa informações de arquivos de vídeo de uma instância EHB/RS Utils.'
+              bool_opt '-d', '--delete', 'Remove vídeos indesejados.'
+              arg_opt '-m', '--move', 'Move vídeos indesejados para o diretório indicado.'
+            end
+
+            def run
+              start_banner
+              to_rename.each { |file| process_rename_file(file) }
+              unwanted.each { |file| process_unwanted_file(file) }
+            end
+
+            private
+
+            def delete?
+              parsed.delete? && !move?
+            end
+
+            def move?
+              parsed.move.present?
+            end
+
+            def start_banner
+              infov 'Files downloaded', files.count
+              infov 'To rename', to_rename.count
+              infov 'Unwanted', unwanted.count
+            end
+
+            def process_rename_file(file)
+              infov "  * #{file.new_path}", file.original_path
+              file.rename if confirm?
+            end
+
+            def process_unwanted_file(file)
+              infov "  * #{file.new_path}", 'UNWANTED'
+              file.remove if delete? && confirm?
+              file.move(parsed.move) if move? && confirm?
+            end
+
+            def files_uncached
+              data.map { |file_data| ::EhbrsRubyUtils::WebUtils::Videos::File.new(file_data) }
+            end
+
+            def to_rename_uncached
+              files.select(&:path_changed?)
+            end
+
+            def unwanted_uncached
+              files.reject { |f| f.type == 'Videos::SeriesDirectory' }.select(&:unwanted)
+            end
+
+            def data_uncached
+              ::JSON.parse(raw_content)
+            end
+
+            def raw_content
+              runner_context.call(:instance).http_request('/videos/files/export').body
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/tools/runner/web_utils/videos/upload.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+require 'ehbrs_ruby_utils/web_utils/videos/files_list'
+require 'json'
+require 'yaml'
+
+module Ehbrs
+  module Tools
+    class Runner
+      class WebUtils
+        class Videos
+          class Upload
+            runner_with :help do
+              desc 'Exporta informações de arquivos de vídeo para uma instância EHB/RS Utils.'
+              bool_opt '-P', '--no-ffprobe', 'Não recupera dados com "ffprobe".'
+            end
+
+            def run
+              %w[movies series].each { |type| upload_files_list(type) }
+            end
+
+            def upload_files_list(type)
+              infom "Uploading \"#{type}\" files list..."
+              files_list_path = send("#{type}_files_list")
+              infov 'Path', files_list_path
+              process_response(upload_request(files_list_path))
+            end
+
+            def upload_request(files_list_path)
+              runner_context.call(:instance).http_request(
+                '/videos/files/import',
+                method: :put,
+                body: {
+                  'videos_tableless_local_import_list[list_file]' => ::File.new(files_list_path)
+                },
+                header: {
+                  'Accept' => 'application/json'
+                }
+              )
+            end
+
+            def process_response(response)
+              infov 'Response status', response.status
+              if response.status == 200
+                pp ::JSON.parse(response.body)
+              else
+                error_file = '/tmp/ehbrsutils.html'
+                ::File.write(error_file, response.body)
+                system('firefox', error_file)
+                fatal_error('Retornou com status de erro: ' + error_file)
+              end
+            end
+
+            def series_files_list_uncached
+              write_files_list('Videos::SeriesDirectory', :series_directory)
+            end
+
+            def movies_files_list_uncached
+              write_files_list('Videos::MovieFile', :movies_directory)
+            end
+
+            def write_files_list(file_class, read_entry)
+              files_list = ::EhbrsRubyUtils::WebUtils::Videos::FilesList.new(
+                file_class,
+                runner_context.call(:instance).read_entry(read_entry),
+                ffprobe: !parsed.no_ffprobe?
+              )
+              infov 'Files found', files_list.data.fetch(:files).count
+              files_list.write_to
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/tools/runner/web_utils/videos.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+
+module Ehbrs
+  module Tools
+    class Runner
+      class WebUtils
+        class Videos
+          require_sub __FILE__
+
+          runner_with :help, :subcommands do
+            desc 'Ferramentas de vídeos para EHB/RS Utils.'
+            subcommands
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/tools/runner/web_utils.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+require 'ehbrs_ruby_utils/web_utils/instance'
+
+module Ehbrs
+  module Tools
+    class Runner
+      class WebUtils
+        require_sub __FILE__
+
+        runner_with :help, :subcommands do
+          desc 'Ferramentas para EHB/RS Utils.'
+          pos_arg :instance_id
+          subcommands
+        end
+
+        private
+
+        def instance_uncached
+          ::EhbrsRubyUtils::WebUtils::Instance.by_id(parsed.instance_id)
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/tools/runner.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_base0/runner'
+require 'ehbrs/tools/application'
+
+module Ehbrs
+  module Tools
+    class Runner
+      require_sub __FILE__
+      include ::EacRubyBase0::Runner
+
+      runner_definition do
+        desc 'Tools for EHB/RS.'
+      end
+
+      def application
+        ::Ehbrs::Tools.application
+      end
+    end
+  end
+end

data/lib/ehbrs/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Ehbrs
   module Tools
-    VERSION = '0.23.0'
+    VERSION = '0.25.1'
   end
 end

data/spec/code/rubocop_spec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+::EacRubyUtils::Rspec.default_setup.describe_rubocop

data/spec/lib/ehbrs/cooking_book/recipe/measure_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'ehbrs/cooking_book/recipe/measure'
+
+RSpec.describe ::Ehbrs::CookingBook::Recipe::Measure do
+  describe '#build'
+  {
+    '1.5 cup' => [1.5, nil, 'cup'],
+    '~' => [nil, nil, nil],
+    '2/ 3 u' => [2, 3, 'u'],
+    '4.5/7.8' => [4.5, 7.8, nil]
+  }.each do |source, expected|
+    context "when source is \"#{source}\"" do
+      let(:instance) { described_class.build(source) }
+
+      it { expect(instance.numerator).to eq(expected[0]) }
+      it { expect(instance.denominator).to eq(expected[1]) }
+      it { expect(instance.unit).to eq(expected[2]) }
+    end
+  end
+end

data/spec/lib/ehbrs/observers/base_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'ehbrs/observers/base'
+
+RSpec.describe ::Ehbrs::Observers::Base do
+  let(:instance) { described_class.new }
+  let(:first_value) { 'a value' }
+  let(:same_value) { first_value.dup }
+  let(:different_value) { 'another value' }
+  let(:first_time) { ::Time.required_zone.local(2020, 5, 1, 12, 45, 0) }
+  let(:second_time) { ::Time.required_zone.local(2020, 5, 1, 12, 45, 0) }
+
+  it { expect(instance.records.count).to be_zero }
+  it { expect(instance.last_change_time).to be_blank }
+  it { expect(instance.last_check_time).to be_blank }
+
+  it { expect(instance).to be_changing_value(nil) }
+  it { expect(instance).to be_changing_value(first_value) }
+  it { expect(instance).to be_changing_value(same_value) }
+  it { expect(instance).to be_changing_value(different_value) }
+
+  context 'when firstly checked' do
+    before { instance.check(first_value, first_time) }
+
+    it { expect(instance.records.count).to eq(1) }
+    it { expect(instance.last_value).to eq(first_value) }
+    it { expect(instance).not_to be_changing_value(same_value) }
+    it { expect(instance).to be_changing_value(different_value) }
+    it { expect(instance.last_change_time).to eq(first_time) }
+    it { expect(instance.last_check_time).to eq(first_time) }
+
+    context 'when same first_value is checked' do
+      before { instance.check(same_value, second_time) }
+
+      it { expect(instance.records.count).to eq(1) }
+      it { expect(instance.last_value).to eq(same_value) }
+      it { expect(instance.last_change_time).to eq(first_time) }
+      it { expect(instance.last_check_time).to eq(second_time) }
+    end
+
+    context 'when different first_value is checked' do
+      before { instance.check(different_value, second_time) }
+
+      it { expect(instance.records.count).to eq(2) }
+      it { expect(instance.last_value).to eq(different_value) }
+      it { expect(instance.last_change_time).to eq(second_time) }
+      it { expect(instance.last_check_time).to eq(second_time) }
+    end
+
+    context 'when checked first_value is blank' do
+      context 'when blank_value == :add' do
+        let(:instance) { described_class.new(blank_value: :add) }
+
+        before { instance.check(nil, second_time) }
+
+        it { expect(instance.records.count).to eq(2) }
+        it { expect(instance.last_value).to eq(nil) }
+        it { expect(instance.last_change_time).to eq(second_time) }
+        it { expect(instance.last_check_time).to eq(second_time) }
+      end
+
+      context 'when blank_value == :ignore' do
+        let(:instance) { described_class.new(blank_value: :ignore) }
+
+        before { instance.check(nil, second_time) }
+
+        it { expect(instance.records.count).to eq(1) }
+        it { expect(instance.last_value).to eq(first_value) }
+        it { expect(instance.last_change_time).to eq(first_time) }
+        it { expect(instance.last_check_time).to eq(second_time) }
+      end
+
+      context 'when blank_value == :raise' do
+        let(:instance) { described_class.new(blank_value: :raise) }
+
+        before do
+          @exception = nil
+          begin
+            instance.check(nil, second_time)
+          rescue StandardError => e
+            @exception = e
+          end
+        end
+
+        it { expect(@exception).to be_a(::ArgumentError) } # rubocop:disable RSpec/InstanceVariable
+        it { expect(instance.records.count).to eq(1) }
+        it { expect(instance.last_value).to eq(first_value) }
+        it { expect(instance.last_change_time).to eq(first_time) }
+        it { expect(instance.last_check_time).to eq(second_time) }
+      end
+    end
+  end
+end