avm 0.2.0 → 0.4.0

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.rb

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

data/lib/avm/git/auto_commit/commit_info.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module AutoCommit
+      class CommitInfo
+        enable_immutable
+
+        immutable_accessor :fixup, :message
+
+        def git_commit_args
+          r = fixup.if_present([]) { |v| ['--fixup', v.sha1] }
+          r += message.if_present([]) { |v| ['--message', v] }
+          return r if r.any?
+
+          raise 'Argument list is empty'
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit/rules/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module AutoCommit
+      module Rules
+        class Base
+          class << self
+            def keys
+              [long_key, short_key]
+            end
+
+            def long_key
+              name.demodulize.variableize
+            end
+
+            def short_key
+              long_key[0, 1]
+            end
+          end
+
+          def with_file(file)
+            self.class.const_get('WithFile').new(self, file)
+          end
+
+          class WithFile
+            common_constructor :rule, :file
+
+            def new_commit_info
+              ::Avm::Git::AutoCommit::CommitInfo.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit/rules/last.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'avm/git/auto_commit/rules/base'
+
+module Avm
+  module Git
+    module AutoCommit
+      module Rules
+        class Last < ::Avm::Git::AutoCommit::Rules::Base
+          class WithFile < ::Avm::Git::AutoCommit::Rules::Base::WithFile
+            def commit_info
+              file.commits.last.if_present { |v| new_commit_info.fixup(v) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit/rules/manual.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'avm/git/auto_commit/rules/base'
+
+module Avm
+  module Git
+    module AutoCommit
+      module Rules
+        class Manual < ::Avm::Git::AutoCommit::Rules::Base
+          class WithFile < ::Avm::Git::AutoCommit::Rules::Base::WithFile
+            enable_speaker
+
+            COMMIT_FORMAT = '%h - %s (%cr)'
+            SKIP_OPTION = 's'
+
+            def commit_info
+              return nil unless file.commits.any?
+
+              commits_banner
+              input('Which commit?', list: commits_by_position).if_present do |v|
+                new_commit_info.fixup(v)
+              end
+            end
+
+            def commits_banner
+              file.commits.each_with_index do |commit, _index|
+                infov "    #{commit.position}", format_commit(commit)
+              end
+              infov "    #{SKIP_OPTION}", 'skip'
+            end
+
+            def commits_by_position
+              (file.commits.map { |commit| [commit.position.to_s, commit] } + [[SKIP_OPTION, nil]])
+                .to_h
+            end
+
+            def format_commit(commit)
+              commit.format(COMMIT_FORMAT)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit/rules/new.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'avm/git/auto_commit/rules/base'
+require 'avm/git/auto_commit_path'
+
+module Avm
+  module Git
+    module AutoCommit
+      module Rules
+        class New < ::Avm::Git::AutoCommit::Rules::Base
+          class WithFile < ::Avm::Git::AutoCommit::Rules::Base::WithFile
+            def auto_commit_path
+              ::Avm::Git::AutoCommitPath.new(file.git, file.path)
+            end
+
+            def commit_info
+              new_commit_info.message(auto_commit_path.commit_message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit/rules/nth.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'avm/git/auto_commit/rules/base'
+
+module Avm
+  module Git
+    module AutoCommit
+      module Rules
+        class Nth < ::Avm::Git::AutoCommit::Rules::Base
+          SHORT_KEY = 't'
+
+          class << self
+            def short_key
+              SHORT_KEY
+            end
+          end
+
+          common_constructor :number do
+            self.number = number.to_i
+          end
+
+          class WithFile < ::Avm::Git::AutoCommit::Rules::Base::WithFile
+            def commit_info
+              file.commits(number - 1).if_present { |v| new_commit_info.fixup(v) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit/rules/unique.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'avm/git/auto_commit/rules/base'
+
+module Avm
+  module Git
+    module AutoCommit
+      module Rules
+        class Unique < ::Avm::Git::AutoCommit::Rules::Base
+          class WithFile < ::Avm::Git::AutoCommit::Rules::Base::WithFile
+            def commit_info
+              return nil unless file.commits.count == 1
+
+              new_commit_info.fixup(file.commits.first)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit/rules.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+::EacRubyUtils.require_sub __FILE__
+
+module Avm
+  module Git
+    module AutoCommit
+      module Rules
+        RULES_CLASSES = %w[last manual new nth unique]
+                        .map { |key| ::Avm::Git::AutoCommit::Rules.const_get(key.camelcase) }
+
+        class << self
+          def parse(string)
+            parts = string.split(':')
+
+            klass = rule_class_by_key(parts.shift)
+            klass.new(*parts)
+          end
+
+          def rule_class_by_key(key)
+            RULES_CLASSES.find { |klass| klass.keys.include?(key) } ||
+              raise("Rule not find with key \"#{key}\" (Available: " +
+                RULES_CLASSES.flat_map(&:keys).join(', ') + ')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit_path/ruby.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    class AutoCommitPath
+      module Ruby
+        RUBY_CLASS_NAME_PATTERNS = [%r{lib/((?!.*/lib/).+)\.rb\z}, %r{app/[^/]+/(.+)\.rb\z}].freeze
+
+        def ruby_class_name
+          RUBY_CLASS_NAME_PATTERNS.each do |pattern|
+            pattern.if_match(relative_path.to_path, false) { |m| return m[1].camelize }
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/avm/git/auto_commit_path.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    class AutoCommitPath
+      require_sub __FILE__, include_modules: true
+      common_constructor :git, :path do
+        self.path = path.to_pathname
+      end
+
+      def class_name
+        ruby_class_name || relative_path.to_path
+      end
+
+      def commit_message
+        r = class_name
+        r += ': remove' unless path.file?
+        r + '.'
+      end
+
+      def relative_path
+        path.expand_path.relative_path_from(git.root_path.expand_path)
+      end
+    end
+  end
+end