avm 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76638a50e8427dad6ecb195da51a10def71512b50d6ccfdc077dc8c3cfb7407c
-  data.tar.gz: 858b52227faabeb78f0cb55b3196e3a702b7c58bcd920c2280f53f436f738179
+  metadata.gz: 0a5a8832847c76afcae4e76ef3e8f7d1391d7cfb0b13788c3dc7273f9ef879f1
+  data.tar.gz: 0b89bd147edb92e0e3e4d158d16f0995ef41f0544a680beb053f9fa55b96a282
 SHA512:
-  metadata.gz: 61e68a1e384b360e0923a5d8d9f1d27df603871264e2b424fa117412d38a6c3d9af7efcb43a32c85e871a84e7df743119a2bf5439def816854bb09ad1930c065
-  data.tar.gz: df0bcc88cf7292dc014d4efbe9b8227b51889af7dc5bc41c28bd4dc20ab64ab947e75b43d7174e5f6ea48d22a16e3afb4fc426c87527b5b13e465eaf7b0761de
+  metadata.gz: a70af189af9aee66a693706ba031e5eb7c6d4c8533144099f325dfe2b88b9ef08daae16de8d2f09857f194816d653d3669527d6bc9c07d173566c9ab9121c3f6
+  data.tar.gz: d66a1741ec6295f54166a2007a4d168eddd4e7de30f538f87329067b580faf2572514d99302bb467e0b408dfe1a44dd54a9e4e2abaaed0292b3a7ba69bb02b95

data/lib/avm/app_src/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'eac_git'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module AppSrc
+    class Base
+      enable_simple_cache
+      enable_listable
+      lists.add_symbol :option, :parent
+      common_constructor :path, :options, default: [{}] do
+        self.path = path.to_pathname
+        self.options = self.class.lists.option.hash_keys_validate!(options)
+      end
+
+      delegate :to_s, to: :path
+
+      # @return [Avm::AppSrc::Base]
+      def parent
+        options[OPTION_PARENT]
+      end
+
+      # @return [Pathname]
+      def relative_path
+        return path if parent.blank?
+
+        path.relative_path_from(parent.path)
+      end
+
+      # @return [Enumerable<Avm::AppSrc::Base>]
+      def subs
+        git_repo.subrepos
+                .map { |subrepo| self.class.new(subrepo.subpath.expand_path(path), parent: self) }
+      end
+
+      private
+
+      # @return [EacGit::Local]
+      def git_repo_uncached
+        ::EacGit::Local.new(path)
+      end
+    end
+  end
+end

data/lib/avm/app_src/configuration/_locale.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'avm/patches/eac_ruby_gems_utils/gem'
+require 'i18n'
+
+module Avm
+  module AppSrc
+    class Configuration < ::EacConfig::OldConfigs
+      LOCALE_KEY = :locale
+
+      def locale
+        read_entry(LOCALE_KEY) || ::I18n.default_locale
+      end
+    end
+  end
+end

data/lib/avm/app_src/configuration/_rubocop.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Avm
+  module AppSrc
+    class Configuration < ::EacConfig::OldConfigs
+      RUBOCOP_COMMAND_KEY = 'ruby.rubocop.command'
+      RUBOCOP_GEMFILE_KEY = 'ruby.rubocop.gemfile'
+
+      def rubocop_command
+        read_command(RUBOCOP_COMMAND_KEY)
+      end
+
+      def rubocop_gemfile
+        gemfile_path = read_entry(RUBOCOP_GEMFILE_KEY)
+        return nil if gemfile_path.blank?
+
+        gemfile_path = gemfile_path.to_pathname.expand_path(storage_path.parent)
+        return gemfile_path if gemfile_path.file?
+
+        raise "Gemfile path \"#{gemfile_path}\" does not exist or is not a file"
+      end
+    end
+  end
+end

data/lib/avm/app_src/configuration/_tests.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avm/patches/eac_ruby_gems_utils/gem'
+
+module Avm
+  module AppSrc
+    class Configuration < ::EacConfig::OldConfigs
+      BUNDLE_TEST_COMMAND_KEY = 'test.bundle_command'
+      TEST_COMMAND_KEY = 'test.command'
+
+      def any_test_command
+        bundle_test_command || test_command
+      end
+
+      def test_command
+        read_command(TEST_COMMAND_KEY)
+      end
+
+      def bundle_test_command
+        read_entry(BUNDLE_TEST_COMMAND_KEY).if_present do |v|
+          args = v.is_a?(::Enumerable) ? v.map(&:to_s) : ::Shellwords.split(v)
+          ::EacRubyGemsUtils::Gem.new(::File.dirname(storage_path)).bundle(*args).chdir_root
+        end
+      end
+    end
+  end
+end

data/lib/avm/app_src/configuration.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_config/old_configs'
+require 'eac_ruby_utils/core_ext'
+require 'yaml'
+
+module Avm
+  module AppSrc
+    class Configuration < ::EacConfig::OldConfigs
+      require_sub __FILE__
+
+      FILENAMES = %w[.avm.yml .avm.yaml].freeze
+
+      class << self
+        def find_by_path(path)
+          path = ::Pathname.new(path.to_s) unless path.is_a?(::Pathname)
+          internal_find_path(path.expand_path)
+        end
+
+        def find_in_path(path)
+          absolute_pathname = path.to_pathname.expand_path
+          if absolute_pathname.directory?
+            FILENAMES.each do |filename|
+              file = absolute_pathname.join(filename)
+              return new(file) if file.exist?
+            end
+          end
+          nil
+        end
+
+        private
+
+        def internal_find_path(absolute_pathname)
+          r = find_in_path(absolute_pathname)
+          return r if r.present?
+
+          internal_find_path(absolute_pathname.dirname) unless absolute_pathname.root?
+        end
+      end
+
+      def initialize(path)
+        super(nil, storage_path: path)
+      end
+
+      # Utility to read a configuration as a [EacRubyUtils::Envs::Command].
+      # @return [EacRubyUtils::Envs::Command]
+      def read_command(key)
+        read_entry(key).if_present do |v|
+          args = v.is_a?(::Enumerable) ? v.map(&:to_s) : ::Shellwords.split(v)
+          ::EacRubyUtils::Envs.local.command(args).chdir(::File.dirname(storage_path))
+        end
+      end
+    end
+  end
+end

data/lib/avm/app_src.rb

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

data/lib/avm/executables.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs'
+require 'eac_ruby_utils/simple_cache'
+
+module Avm
+  module Executables
+    class << self
+      include ::EacRubyUtils::SimpleCache
+
+      def env
+        ::EacRubyUtils::Envs.local
+      end
+
+      private
+
+      %w[file git js-beautify latex php-cs-fixer tidy yapf xdg-open].each do |program|
+        define_method(program.underscore + '_uncached') do
+          env.executable(program, '--version')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/files/appendable/resource_base'
+
+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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/files/appendable/resource_base'
+
+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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Files
+    module Appendable
+      class ResourceBase
+        common_constructor :appender
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/envs'
+require 'avm/files/appendable/resource_base'
+
+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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/files/appendable/resource_base'
+require 'eac_templates/directory'
+
+module Avm
+  module Files
+    module Appendable
+      class TemplatizedDirectory < ::Avm::Files::Appendable::ResourceBase
+        attr_reader :source_path
+
+        def initialize(appender, source_path)
+          super(appender)
+          @source_path = source_path
+        end
+
+        def write_on(target_dir)
+          raise 'Variables source not set' if appender.variables_source.blank?
+
+          ::EacTemplates::Directory.new(source_path).apply(
+            appender.variables_source,
+            target_dir
+          )
+        end
+      end
+    end
+  end
+end

data/lib/avm/files/appendable.rb

@@ -0,0 +1,55 @@
+# 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/lib/avm/files/appender.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'avm/files/appendable'
+
+module Avm
+  module Files
+    class Appender
+      include ::Avm::Files::Appendable
+    end
+  end
+end

data/lib/avm/files/deploy.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'avm/files/appendable'
+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/lib/avm/files/formatter/formats/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'eac_fs/file_info'
+require 'ostruct'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class Base
+          def apply(files)
+            old_content = Hash[files.map { |f| [f, File.read(f)] }]
+            ::Avm::Files::Formatter::Utf8Assert.assert_files(files) { internal_apply(files) }
+            files.map { |f| build_file_result(f, old_content[f]) }
+          end
+
+          def name
+            self.class.name.demodulize
+          end
+
+          def match?(file)
+            match_by_filename?(file) || match_by_type?(file)
+          end
+
+          def valid_basenames
+            constant_or_array('VALID_BASENAMES')
+          end
+
+          def valid_types
+            constant_or_array('VALID_TYPES')
+          end
+
+          private
+
+          def constant_or_array(name)
+            return [] unless self.class.const_defined?(name)
+
+            self.class.const_get(name)
+          end
+
+          def build_file_result(file, old_content)
+            ::OpenStruct.new(file: file, format: self.class,
+                             changed: (old_content != File.read(file)))
+          end
+
+          def match_by_filename?(file)
+            valid_basenames.any? do |valid_basename|
+              file.basename.fnmatch?(valid_basename)
+            end
+          end
+
+          def match_by_type?(file)
+            info = ::EacFs::FileInfo.new(file)
+            return unless info.content_type.type == 'text'
+
+            valid_types.include?(info.content_type.subtype)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/files/formatter/formats/generic_plain.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'avm/files/formatter/formats/base'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class GenericPlain < ::Avm::Files::Formatter::Formats::Base
+          VALID_BASENAMES = %w[*.bat *.css.coffee *.java *.js *.rb *.scss *.sql *.tex *.url *.yml
+                               *.yaml].freeze
+
+          VALID_TYPES = %w[plain x-shellscript].freeze
+
+          def internal_apply(files)
+            files.each { |file| file_apply(file) }
+          end
+
+          def file_apply(file)
+            file.write(string_apply(file.read))
+          end
+
+          def string_apply(string)
+            b = ''
+            string.each_line do |line|
+              b += "#{line.rstrip}\n"
+            end
+            "#{b.strip}\n".gsub(/\t/, '  ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/files/formatter/formats/html.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'avm/files/formatter/formats/generic_plain'
+require 'htmlbeautifier'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class Html < ::Avm::Files::Formatter::Formats::GenericPlain
+          VALID_BASENAMES = %w[*.html *.html.erb].freeze
+          VALID_TYPES = ['html'].freeze
+
+          def file_apply(path)
+            input = ::File.read(path)
+            temppath = tempfile_path
+            ::File.open(temppath, 'w') do |output|
+              beautify path, input, output
+            end
+            ::FileUtils.mv(temppath, path)
+            super(path)
+          end
+
+          private
+
+          def beautify(name, input, output)
+            output.puts ::HtmlBeautifier.beautify(input, htmlbeautify_options)
+          rescue StandardError => e
+            raise "Error parsing #{name}: #{e}"
+          end
+
+          def htmlbeautify_options
+            @htmlbeautify_options ||= { indent: '  ' }
+          end
+
+          def tempfile_path
+            tempfile = ::Tempfile.new
+            tempfile.close
+            tempfile.path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/files/formatter/formats/javascript.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'avm/executables'
+require 'avm/files/formatter/formats/generic_plain'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class Javascript < ::Avm::Files::Formatter::Formats::GenericPlain
+          VALID_BASENAMES = %w[*.js].freeze
+          VALID_TYPES = [].freeze
+
+          def internal_apply(files)
+            ::Avm::Executables.js_beautify.command.append(
+              ['--indent-size=2', '--end-with-newline', '--replace', *files]
+            ).system!
+            super(files)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/files/formatter/formats/json.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avm/files/formatter/formats/generic_plain'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class Json < ::Avm::Files::Formatter::Formats::GenericPlain
+          VALID_BASENAMES = %w[*.json].freeze
+          VALID_TYPES = [].freeze
+
+          def file_apply(file)
+            ::File.write(file, ::JSON.pretty_generate(::JSON.parse(::File.read(file))))
+          end
+
+          def json_file?(file)
+            ::JSON.parse(::File.read(file))
+            true
+          rescue JSON::ParserError
+            false
+          end
+        end
+      end
+    end
+  end
+end