eac_tools 0.102.0 → 0.102.1

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

@@ -1,87 +0,0 @@
-# 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

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

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

@@ -1,21 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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

@@ -1,85 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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

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

data/sub/avm/lib/avm/files/appendable/file_content.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Files
-    module Appendable
-      class FileContent < ::Avm::Files::Appendable::ResourceBase
-        attr_reader :target_path, :content
-
-        def initialize(deploy, target_path, content)
-          super(deploy)
-          @target_path = target_path
-          @content = content
-        end
-
-        def write_on(target_dir)
-          target_dir.join(target_path).write(content)
-        end
-
-        protected
-
-        # @return [Enumerable<Symbol>]
-        def to_s_attributes
-          %i[target_path content]
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/files/appendable/plain_directory.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Files
-    module Appendable
-      class PlainDirectory < ::Avm::Files::Appendable::ResourceBase
-        attr_reader :source_path
-
-        def initialize(appender, source_path)
-          super(appender)
-          @source_path = source_path.to_pathname
-        end
-
-        def write_on(target_dir)
-          raise "\"#{source_path}\" is not a directory" unless source_path.directory?
-
-          ::FileUtils.cp_r("#{source_path}/.", target_dir.to_path)
-        end
-
-        # @return [Enumerable<Symbol>]
-        def to_s_attributes
-          [:source_path]
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/files/appendable/resource_base.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Files
-    module Appendable
-      class ResourceBase
-        acts_as_abstract :to_s_attributes
-        common_constructor :appender
-
-        def to_s
-          v_to_s = to_s_attributes.map { |k| "#{k}: #{send(k)}" }.join(', ')
-          "#{self.class.name}[#{v_to_s}]"
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/files/appendable/tar_output_command.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/envs'
-
-module Avm
-  module Files
-    module Appendable
-      class TarOutputCommand < ::Avm::Files::Appendable::ResourceBase
-        attr_reader :command
-
-        def initialize(appender, command)
-          super(appender)
-          @command = command
-        end
-
-        def write_on(target_dir)
-          command.pipe(
-            ::EacRubyUtils::Envs.local.command('tar', '-xf', '-', '-C', target_dir)
-          ).execute!
-        end
-
-        # @return [Enumerable<Symbol>]
-        def to_s_attributes
-          [:command]
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/files/appendable/templatized_directory.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-require 'eac_templates/variables/directory'
-
-module Avm
-  module Files
-    module Appendable
-      class TemplatizedDirectory < ::Avm::Files::Appendable::ResourceBase
-        common_constructor :appender, :source_path, super_args: -> { [appender] }
-
-        # @return [Object]
-        def applier
-          return source_path if source_path.respond_to?(:apply)
-
-          applier_from_path
-        end
-
-        # @return [EacTemplates::Variables::Directory]
-        def applier_from_path
-          raise "\"#{source_path}\" is not a directory" unless ::File.directory?(source_path)
-
-          ::EacTemplates::Variables::Directory.new(source_path)
-        end
-
-        def write_on(target_dir)
-          raise 'Variables source not set' if appender.variables_source.blank?
-
-          applier.apply(appender.variables_source, target_dir)
-        end
-
-        # @return [Enumerable<Symbol>]
-        def to_s_attributes
-          [:source_path]
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/files/appendable.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Files
-    module Appendable
-      require_sub __FILE__
-
-      attr_reader :variables_source
-
-      def appended
-        @appended ||= []
-      end
-
-      def append_templatized_directories(directories)
-        directories.each { |directory| append_templatized_directory(directory) }
-        self
-      end
-
-      def append_plain_directory(directory)
-        appended << ::Avm::Files::Appendable::PlainDirectory.new(self, directory)
-        self
-      end
-
-      def append_tar_output_command(tar_command)
-        appended << ::Avm::Files::Appendable::TarOutputCommand.new(self, tar_command)
-        self
-      end
-
-      def append_templatized_directory(directory)
-        appended << ::Avm::Files::Appendable::TemplatizedDirectory.new(self, directory)
-        self
-      end
-
-      def append_file_content(target_path, content)
-        appended << ::Avm::Files::Appendable::FileContent
-                      .new(self, target_path, content)
-        self
-      end
-
-      def variables_source_set(source)
-        @variables_source = source
-        self
-      end
-
-      def write_appended_on(target_dir)
-        target_dir = target_dir.to_pathname
-        raise "\"#{target_dir}\" is not a directory" unless target_dir.directory?
-
-        appended.each { |append| append.write_on(target_dir) }
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/files/appender.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Files
-    class Appender
-      include ::Avm::Files::Appendable
-    end
-  end
-end

data/sub/avm/lib/avm/files/deploy.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'addressable'
-
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Files
-    class Deploy
-      include ::Avm::Files::Appendable
-      enable_simple_cache
-
-      attr_reader :build_dir, :target_env, :target_path
-
-      common_constructor :target_env, :target_path
-
-      def run
-        on_build_dir do
-          copy_content_to_build_dir
-          mkdir_target
-          clear_content
-          send_untar_package
-          set_target_permission
-        end
-      end
-
-      private
-
-      def on_build_dir
-        @build_dir = ::Dir.mktmpdir
-        yield
-      ensure
-        ::FileUtils.rm_rf(@build_dir)
-      end
-
-      def copy_content_to_build_dir
-        write_appended_on(build_dir)
-      end
-
-      def mkdir_target
-        target_env.command('mkdir', '-p', target_path).execute!
-      end
-
-      def clear_content
-        target_env.command(
-          'find', target_path, '-mindepth', '1', '-maxdepth', '1', '-exec', 'rm', '-rf', '{}', ';'
-        ).execute!
-      end
-
-      def send_untar_package
-        tar_build_command.pipe(untar_build_command).execute!
-      end
-
-      def set_target_permission
-        target_env.command('chmod', '755', target_path).execute!
-      end
-
-      def tar_build_command
-        source_env.command('tar', '-czO', '-C', build_dir, '.')
-      end
-
-      def untar_build_command
-        target_env.command('tar', '-xzf', '-', '-C', target_path)
-      end
-
-      def source_env
-        ::EacRubyUtils::Envs.local
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/files/text_replacer/gsub.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Files
-    class TextReplacer
-      class Gsub
-        common_constructor :from, :to do
-          self.from = from
-          self.to = to
-        end
-
-        def apply(input)
-          input.gsub(from, to)
-        end
-
-        def to_s
-          "\"#{from}\" => \"#{to}\""
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/files/text_replacer.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Files
-    class TextReplacer
-      require_sub __FILE__
-      enable_immutable
-
-      immutable_accessor :replacement, type: :array
-
-      def apply(input)
-        replacements.inject(input) { |a, e| e.apply(a) }
-      end
-
-      def file_apply(file) # rubocop:disable Naming/PredicateMethod
-        file = file.to_pathname
-        input = file.read
-        output = apply(file.read)
-        return false if output == input
-
-        file.write(output)
-        true
-      end
-
-      def gsub(from, to)
-        replacement(::Avm::Files::TextReplacer::Gsub.new(from, to))
-      end
-    end
-  end
-end