eac_tools 0.101.2 → 0.102.0

data/sub/avm/lib/avm/entries/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+
+module Avm
+  module Entries
+    module Base
+      require_sub __FILE__, require_mode: :kernel
+      common_concern
+
+      module ClassMethods
+        def uri_components_entries_values(prefix, extra_fields = [])
+          ::Avm::Entries::Base::UriComponentsEntriesValues.new(self, prefix, extra_fields).result
+        end
+      end
+
+      def entries_provider_id
+        id
+      end
+
+      # @raise
+      # @return [void]
+      def entries_provider_id!
+        return entries_provider_id unless
+        entries_provider_id.include?(::EacConfig::EntryPath::PART_SEPARATOR)
+
+        raise ".entries_provider_id \"#{entries_provider_id}\" cannot have " \
+              "\"#{::EacConfig::EntryPath::PART_SEPARATOR}\" (EacConfig::EntryPath::PART_SEPARATOR)"
+      end
+
+      def entry(suffix, options = {})
+        ::Avm::Entries::Entry.new(self, suffix, options)
+      end
+
+      def path_prefix
+        @path_prefix ||= [entries_provider_id!].freeze
+      end
+
+      def read_entry(entry_suffix, options = {})
+        entry(entry_suffix, options).value
+      end
+
+      def read_entry_optional(entry_suffix, options = {})
+        entry(entry_suffix, options).optional_value
+      end
+
+      def full_entry_path(entry_suffix)
+        unless entry_suffix.is_a?(::Array)
+          entry_suffix = ::EacConfig::PathsHash.parse_entry_key(entry_suffix.to_s)
+        end
+        (path_prefix + entry_suffix).join('.')
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/entry/no_context_entry.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    class Entry
+      class NoContextEntry
+        def found?
+          false
+        end
+
+        def value
+          nil
+        end
+
+        def value!
+          raise('No context entry - there is no value')
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/entry.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'eac_config/node'
+
+module Avm
+  module Entries
+    class Entry
+      common_constructor :parent, :suffix, :options
+
+      def auto_value
+        auto_value_entry.value
+      end
+
+      def auto_value_entry
+        @auto_value_entry ||= ::Avm::Entries::AutoValues::Entry.new(parent, suffix)
+      end
+
+      # @return [Boolean]
+      def context_found?
+        context_entry.found?
+      end
+
+      # @return [Boolean]
+      def found?
+        context_found?
+      end
+
+      def full_path
+        (parent.path_prefix + suffix_as_array).join('.')
+      end
+
+      def optional_value
+        context_entry.found? ? context_entry.value : auto_value
+      end
+
+      def read
+        context_entry.value
+      end
+
+      def suffix_as_array
+        if suffix.is_a?(::Array)
+          suffix.dup
+        else
+          ::EacConfig::PathsHash.parse_entry_key(suffix.to_s)
+        end
+      end
+
+      def value
+        optional_value || read
+      end
+
+      def value!
+        optional_value.if_present { |v| return v }
+        context_entry.value!
+      end
+
+      def write(value)
+        context_entry.value = value
+      end
+
+      private
+
+      def context_entry
+        current_node = ::EacConfig::Node.context.optional_current
+        return current_node.entry(full_path) if current_node.present?
+
+        ::Avm::Entries::Entry::NoContextEntry.new
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/jobs/base.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+
+module Avm
+  module Entries
+    module Jobs
+      module Base
+        common_concern do
+          include ::ActiveSupport::Callbacks
+          include ::Avm::Entries::Jobs::WithVariablesSource
+
+          enable_speaker
+          enable_simple_cache
+          enable_listable
+          common_constructor :instance, :options, default: [{}] do
+            if option_list.present?
+              self.options = option_list.hash_keys_validate!(options.symbolize_keys)
+            end
+          end
+          define_callbacks(*jobs)
+        end
+
+        module ClassMethods
+          def jobs
+            const_get('JOBS').dup
+          end
+        end
+
+        module InstanceMethods
+          def option_list
+            nil
+          end
+
+          def run
+            start_banner if respond_to?(:start_banner)
+            run_jobs
+            ::Avm::Result.success('Done!')
+          rescue ::Avm::Result::Error => e
+            e.to_result
+          end
+
+          protected
+
+          def run_jobs
+            jobs.each do |job|
+              run_callbacks job do
+                send(job)
+              end
+            end
+          end
+
+          def jobs
+            self.class.jobs
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/jobs/variables_source/read_entry.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Jobs
+      class VariablesSource
+        class ReadEntry
+          enable_method_class
+          common_constructor :variables_source, :path, :options, default: [{}]
+          delegate :instance, :job, to: :variables_source
+
+          def result
+            return result_from_job if result_from_job?
+            return result_from_instance_method if result_from_instance_method?
+
+            result_from_instance_entry
+          end
+
+          private
+
+          def path_method_name
+            path.gsub('.', '_').underscore
+          end
+
+          def result_from_instance_entry
+            instance.read_entry(path, options)
+          end
+
+          def result_from_instance_method
+            instance.send(path_method_name)
+          end
+
+          def result_from_instance_method?
+            instance.respond_to?(path_method_name, true)
+          end
+
+          def result_from_job
+            job.send(path_method_name)
+          end
+
+          def result_from_job?
+            job.respond_to?(path_method_name, true)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/jobs/variables_source.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Jobs
+      class VariablesSource
+        require_sub __FILE__, require_dependency: true
+        common_constructor :job
+        delegate :instance, to: :job
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/jobs/with_variables_source.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Jobs
+      module WithVariablesSource
+        def variables_source
+          ::Avm::Entries::Jobs::VariablesSource.new(self)
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/jobs.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Jobs
+    end
+  end
+end

data/sub/avm/lib/avm/entries/keys_constants_set.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    class KeysConstantsSet
+      common_constructor :entries_provider_class, :prefix, :suffixes
+
+      # @return [Array<String>]
+      def result
+        if suffixes.is_a?(::Hash)
+          keys_consts_set_from_hash
+        elsif suffixes.is_a?(::Enumerable)
+          keys_consts_set_from_enum
+        else
+          raise "Unmapped suffixes class: #{suffixes.class}"
+        end
+      end
+
+      private
+
+      # @return [String]
+      def key_const_set(prefix, suffix)
+        key = [prefix, suffix].compact_blank.join('.')
+        entries_provider_class.const_set(key.gsub('.', '_').upcase, key)
+        key
+      end
+
+      # @return [Array<String>]
+      def keys_consts_set_from_enum
+        suffixes.map { |suffix| key_const_set(prefix, suffix) }
+      end
+
+      # @return [Array<String>]
+      def keys_consts_set_from_hash
+        suffixes.flat_map do |k, v|
+          self.class.new(entries_provider_class, prefix.to_s + (k.blank? ? '' : ".#{k}"), v).result
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/uri_builder.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    class UriBuilder
+      FIELDS = %w[scheme user password host port path query fragment].freeze
+      FIELDS_TRANSLATIONS = {
+        username: :user, hostname: :host
+      }.freeze
+      ENTRIES_FIELDS = FIELDS.map do |field|
+        FIELDS_TRANSLATIONS.key(field.to_sym).if_present(field).to_s
+      end
+
+      class << self
+        def from_all_fields(&block)
+          r = new
+          ENTRIES_FIELDS.each do |field_name|
+            field_value = block.call(field_name)
+            r.field_set(field_name, field_value) if field_value.present?
+          end
+          r
+        end
+
+        def from_source(source)
+          if source.is_a?(::Addressable::URI)
+            from_source_uri(source)
+          elsif source.blank?
+            new
+          else
+            raise "Unexpected source: #{source}"
+          end
+        end
+
+        def from_source_uri(source_uri)
+          new(source_uri.to_hash)
+        end
+      end
+
+      common_constructor :data, default: [{}]
+
+      def avm_field_get(avm_field)
+        field_get(translate_field(avm_field))
+      end
+
+      # @return [String, nil]
+      def field_get(name)
+        v = data[name.to_sym]
+        v&.to_s
+      end
+
+      def field_set(field, value)
+        tfield = translate_field(field)
+        if FIELDS.include?(tfield)
+          main_field_set(tfield, value)
+        else
+          sub_field_set(tfield, value)
+        end
+      end
+
+      def translate_field(field)
+        if FIELDS_TRANSLATIONS.key?(field.to_sym)
+          FIELDS_TRANSLATIONS.fetch(field.to_sym).to_s
+        else
+          field.to_s
+        end
+      end
+
+      # @return [Addressable::URI, nil]
+      def to_uri
+        to_required_uri
+      rescue ::Addressable::URI::InvalidURIError
+        nil
+      end
+
+      # @return [Addressable::URI]
+      def to_required_uri
+        ::Addressable::URI.new(FIELDS.to_h { |f| [f.to_sym, field_get(f)] })
+      end
+
+      private
+
+      def main_field_set(name, value)
+        data[name.to_sym] = value
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+  end
+end

data/sub/avm/lib/avm/executables.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Avm
+  module Executables
+    class << self
+      include ::EacRubyUtils::SimpleCache
+
+      def env
+        ::EacRubyUtils::Envs.local
+      end
+
+      private
+
+      %w[xdg-open].each do |program|
+        define_method("#{program.underscore}_uncached") do
+          env.executable(program, '--version')
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/file_formats/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'eac_fs/file_info'
+require 'ostruct'
+
+module Avm
+  module FileFormats
+    class Base
+      enable_abstract_methods
+      compare_by :class
+
+      # @params files [Enumerable<Pathname>]
+      # @return [Enumerable<Avm::FileFormats::FileResult>]
+      def apply(_files)
+        raise_abstract_method __method__
+      end
+
+      # @param path [Pathname]
+      # @return [Avm::FileFormats::FileWith]
+      def file_resource_name(path)
+        path.to_pathname.to_path
+      end
+
+      def name
+        self.class.name.demodulize
+      end
+
+      # @param file [Pathname]
+      # @return [Boolean]
+      def match?(_file)
+        raise_abstract_method __method__
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/file_formats/file_result.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'eac_fs/file_info'
+require 'ostruct'
+
+module Avm
+  module FileFormats
+    class FileResult
+      common_constructor :file, :format, :changed
+    end
+  end
+end

data/sub/avm/lib/avm/file_formats/search_formatter.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'eac_fs/traversable'
+
+module Avm
+  module FileFormats
+    class SearchFormatter
+      include ::EacFs::Traversable
+
+      enable_simple_cache
+      enable_speaker
+      enable_listable
+      lists.add_symbol :option, :apply, :recursive, :verbose
+      common_constructor :source_paths, :options, default: [{}] do
+        options.assert_valid_keys(self.class.lists.option.values)
+      end
+
+      def run
+        clear
+        search_files
+        apply
+        show_results
+      end
+
+      private
+
+      def apply
+        speak(:infom, "Applying #{@formats_files.count} format(s)... ")
+        @formats_files.each do |format, files|
+          speak(:infom, "Applying format #{format.name} (Files matched: #{files.count})...")
+          next unless options[OPTION_APPLY]
+
+          @result += format.apply(files)
+        end
+      end
+
+      def traverser_check_file(file)
+        format = find_format(file)
+        speak(:infov, file, format ? format.class : '-')
+        return unless format
+
+        @formats_files[format] ||= []
+        @formats_files[format] << file
+      end
+
+      def clear
+        @formats_files = {}
+        @result = []
+      end
+
+      # @return [Avm::FileFormats::Base, nil]
+      def find_format(file)
+        ::Avm::Registry.file_formats.detect_optional(file)
+      end
+
+      def search_files
+        speak(:infov, 'Directories to search', source_paths.count)
+        source_paths.each do |source_path|
+          speak(:infom, "Searching files on \"#{source_path}\"...")
+          traverser_check_path(source_path)
+        end
+      end
+
+      def show_results
+        changed = @result.select(&:changed)
+        changed.each do |h|
+          speak(:out, h.file.to_s.cyan)
+          speak(:out, " (#{h.format})".yellow)
+          speak(:puts, ' changed'.green)
+        end
+        speak(:infov, 'Files changed', "#{changed.count}/#{@result.count}")
+      end
+
+      def traverser_recursive
+        options[OPTION_RECURSIVE]
+      end
+
+      def speak(method, *method_args)
+        return unless options[OPTION_VERBOSE].to_bool
+
+        send(method, *method_args)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/file_formats/unknown.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Avm
+  module FileFormats
+    class Unknown < ::Avm::FileFormats::Base
+      # @params files [Enumerable<Pathname>]
+      # @return [Enumerable<Avm::FileFormats::FileResult>]
+      def apply(files)
+        files.map do |file|
+          ::Avm::FileFormats::FileResult.new(file, self.class, false)
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/file_formats/utf8_assert.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'eac_fs/file_info'
+
+module Avm
+  module FileFormats
+    class Utf8Assert
+      UTF8_CHARSET = 'utf-8'
+      UTF8_CHARSETS = [UTF8_CHARSET, 'us-ascii'].freeze
+
+      class << self
+        def assert_files(files)
+          asserters = files.map { |file| new(file) }
+          begin
+            asserters.each(&:assert)
+            yield
+          ensure
+            asserters.each(&:revert)
+          end
+        end
+      end
+
+      enable_simple_cache
+      common_constructor :path
+
+      def assert
+        return if original_utf8?
+
+        convert_self(original_charset, UTF8_CHARSET)
+      end
+
+      def revert
+        return if original_utf8?
+
+        convert_self(UTF8_CHARSET, original_charset)
+      end
+
+      private
+
+      def original_info_uncached
+        ::EacFs::FileInfo.new(path)
+      end
+
+      def original_charset_uncached
+        return original_info.content_type.charset if original_info.content_type.charset.present?
+
+        raise 'No charset found'
+      rescue StandardError => e
+        raise "Unable to determine the charset of #{path} (#{e.message})"
+      end
+
+      def original_utf8?
+        UTF8_CHARSETS.include?(original_charset)
+      end
+
+      def convert_file(from_path, from_charset, to_path, to_charset)
+        File.open(from_path, "r:#{from_charset}") do |input|
+          File.open(to_path, "w:#{to_charset}") do |output|
+            output.write(input.read)
+          end
+        end
+      end
+
+      def convert_self(from_charset, to_charset)
+        temp = ::Tempfile.new
+        temp.close
+        convert_file(path, from_charset, temp.path, to_charset)
+        ::FileUtils.mv(temp.path, path)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/file_formats.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Avm
+  module FileFormats
+  end
+end