avm-files 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ae0d20f3f31743dfbf25f94dd24f36dc97dce93da94377fc9f85742b10d3e34
+  data.tar.gz: 23ed109ef8b2691f7b14fdaeaab8e194d4ff8a80739130c043aa109988f57e98
+SHA512:
+  metadata.gz: '085fd89600d3d0cdda2f4cc731eb14380913c578d24d75c2e82acafe690d7600111087622a6e94aad5707dfa0c8f3bb3735f64ad4a364ca356d49390cf590de0'
+  data.tar.gz: b04360ba65b34e9e0678273127b74e1ae5aef1b0a55844ce965c55407e86695ac80b42d395586b410778eb766bceb211f6d59c22df4b89a94d31535c82736dad

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'avm/executables'
+require 'avm/files/formatter/formats/generic_plain'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class Php < ::Avm::Files::Formatter::Formats::GenericPlain
+          VALID_BASENAMES = %w[*.php].freeze
+          VALID_TYPES = ['x-php'].freeze
+
+          def file_apply(file)
+            ::Avm::Executables.php_cs_fixer.command.append(['fix', file]).system!
+            super(file)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'avm/executables'
+require 'avm/files/formatter/formats/generic_plain'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class Python < ::Avm::Files::Formatter::Formats::GenericPlain
+          VALID_BASENAMES = %w[*.py].freeze
+          VALID_TYPES = ['x-python'].freeze
+
+          def internal_apply(files)
+            ::Avm::Executables.yapf.command.append(['--in-place', *files]).system!
+            super(files)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'avm/files/formatter/formats/generic_plain'
+require 'avm/ruby/rubocop'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class Ruby < ::Avm::Files::Formatter::Formats::GenericPlain
+          VALID_BASENAMES = %w[*.gemspec *.rake *.rb Gemfile Rakefile].freeze
+          VALID_TYPES = ['x-ruby'].freeze
+
+          def internal_apply(files)
+            ::Avm::Ruby::Rubocop.new('.', ['-a', '--ignore-parent-exclusion'] + files).run
+            super(files)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'avm/executables'
+require 'avm/files/formatter/formats/generic_plain'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        class Xml < ::Avm::Files::Formatter::Formats::GenericPlain
+          VALID_BASENAMES = %w[*.xml].freeze
+          VALID_TYPES = ['xml'].freeze
+
+          def internal_apply(files)
+            format_command(files).system!
+            super(files)
+          end
+
+          def format_command(files)
+            ::Avm::Executables.tidy.command.append(
+              %w[-xml -modify --indent auto --indent-spaces 2 --wrap 100] + files
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Files
+    class Formatter
+      module Formats
+        require_sub __FILE__
+      end
+    end
+  end
+end

data/lib/avm/files/formatter/utf8_assert.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'eac_fs/file_info'
+
+module Avm
+  module Files
+    class Formatter
+      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
+end

data/lib/avm/files/formatter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/fs/traversable'
+
+module Avm
+  module Files
+    class Formatter
+      include ::EacRubyUtils::Fs::Traversable
+      require_sub __FILE__
+      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
+
+      FORMATS = %w[ruby php html python xml javascript json generic_plain].freeze
+
+      def run
+        clear
+        search_files
+        apply
+        show_results
+      end
+
+      private
+
+      def apply
+        infom "Applying #{@formats_files.count} format(s)... "
+        @formats_files.each do |format, files|
+          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)
+        infov file, format ? format.class : '-' if options[OPTION_VERBOSE]
+        return unless format
+
+        @formats_files[format] ||= []
+        @formats_files[format] << file
+      end
+
+      def clear
+        @formats_files = {}
+        @result = []
+      end
+
+      def find_format(file)
+        formats.each do |c|
+          return c if c.match?(file)
+        end
+        nil
+      end
+
+      def formats_uncached
+        FORMATS.map do |identifier|
+          "avm/files/formatter/formats/#{identifier}".camelize.constantize.new
+        end
+      end
+
+      def search_files
+        infov 'Directories to search', source_paths.count
+        source_paths.each do |source_path|
+          infom "Searching files on \"#{source_path}\"..."
+          traverser_check_path(source_path)
+        end
+      end
+
+      def show_results
+        changed = @result.select(&:changed)
+        changed.each do |h|
+          out h.file.to_s.cyan
+          out " (#{h.format})".yellow
+          puts ' changed'.green
+        end
+        infov('Files changed', "#{changed.count}/#{@result.count}")
+      end
+
+      def traverser_recursive
+        options[OPTION_RECURSIVE]
+      end
+    end
+  end
+end

data/lib/avm/files/rotate.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_ruby_utils/simple_cache'
+
+module Avm
+  module Files
+    class Rotate
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :options, :source_path
+
+      def initialize(source_path, options = {})
+        @source_path = source_path
+        @options = options
+      end
+
+      def run
+        validate_msg = validate
+        return validate_msg if validate_msg.present?
+
+        ::FileUtils.mv(source_path, target_path)
+        check_space_limit
+        nil
+      end
+
+      def space_limit
+        r = options[:space_limit].try(:to_i)
+        return r if r.present? && r.positive?
+
+        r
+      end
+
+      def space_used
+        rotated_files.inject(0) { |a, e| a + ::File.size(e) }
+      end
+
+      def rotated_files
+        ::Dir["#{dirname}/#{source_basename_without_extension}*#{source_extension}"]
+      end
+
+      def oldest_rotated_file
+        rotated_files.min_by { |file| [::File.mtime(file)] }
+      end
+
+      private
+
+      def check_space_limit
+        return unless space_limit
+
+        while space_used > space_limit
+          file = oldest_rotated_file
+          unless file
+            raise 'oldest_rotated_file returned nil ' \
+              "(Limit: #{space_limit}, used: #{space_used})"
+          end
+          ::File.delete(file)
+        end
+      end
+
+      def validate
+        return "Source file \"#{source_path}\" does not exist" unless ::File.exist?(source_path)
+        return "File \"#{source_path}\" is already rotated" if source_rotated?
+
+        nil
+      end
+
+      def source_rotated?
+        source_basename_without_extension.match(/[PN]\d{4}\z/)
+      end
+
+      def source_extension_uncached
+        file_extension(::File.basename(source_path))
+      end
+
+      def source_basename_without_extension
+        ::File.basename(source_path, source_extension)
+      end
+
+      def target_path_uncached
+        ::File.join(dirname, target_basename)
+      end
+
+      def dirname
+        ::File.dirname(source_path)
+      end
+
+      def target_basename
+        source_basename_without_extension + target_suffix + source_extension
+      end
+
+      def target_suffix
+        return '_UNKNOWN_MTIME' unless ::File.exist?(source_path)
+
+        t = ::File.mtime(source_path)
+        t.strftime('_%Y-%m-%d_%H-%M-%S_') + t.strftime('%z').gsub(/\A\+/, 'P').gsub(/\A\-/, 'N')
+      end
+
+      def file_extension(basename)
+        extension = ::File.extname(basename)
+        return '' if extension.blank?
+
+        file_extension(::File.basename(basename, extension)) + extension
+      end
+    end
+  end
+end

data/lib/avm/files/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Avm
+  module Files
+    VERSION = '0.1.0'
+  end
+end

data/lib/avm/files.rb

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

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: avm-files
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Put here the authors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: avm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: eac_fs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: eac_ruby_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.76'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.76'
+- !ruby/object:Gem::Dependency
+  name: eac_templates
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: eac_ruby_gem_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/avm/files.rb
+- lib/avm/files/appendable.rb
+- lib/avm/files/appendable/file_content.rb
+- lib/avm/files/appendable/plain_directory.rb
+- lib/avm/files/appendable/resource_base.rb
+- lib/avm/files/appendable/tar_output_command.rb
+- lib/avm/files/appendable/templatized_directory.rb
+- lib/avm/files/appender.rb
+- lib/avm/files/deploy.rb
+- lib/avm/files/formatter.rb
+- lib/avm/files/formatter/formats.rb
+- lib/avm/files/formatter/formats/base.rb
+- lib/avm/files/formatter/formats/generic_plain.rb
+- lib/avm/files/formatter/formats/html.rb
+- lib/avm/files/formatter/formats/javascript.rb
+- lib/avm/files/formatter/formats/json.rb
+- lib/avm/files/formatter/formats/php.rb
+- lib/avm/files/formatter/formats/python.rb
+- lib/avm/files/formatter/formats/ruby.rb
+- lib/avm/files/formatter/formats/xml.rb
+- lib/avm/files/formatter/utf8_assert.rb
+- lib/avm/files/rotate.rb
+- lib/avm/files/version.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Put here de description.
+test_files: []