pd1_tools 0.43.0

data/lib/avmtrf1/git/push_large/lfs_commit/pick_source_revision.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class LfsCommit
+        module PickSourceRevision
+          private
+
+          def add_cacheinfo_fail?(result)
+            !result.fetch(:exit_code).zero? && result.fetch(:stderr).include?('add_cacheinfo')
+          end
+
+          def cherry_pick_source_revision_uncached
+            checkout_base
+            return if previous_revision.blank?
+
+            infom message("Cherry pick #{source_commit.sha1}")
+            result = git.execute('cherry-pick', '--allow-empty', '--allow-empty-message',
+                                 '-Xtheirs', source_commit.sha1)
+            check_cherry_pick_result(result)
+          end
+
+          def check_cherry_pick_result(result)
+            return if result.fetch(:exit_code).zero?
+            return on_cherry_pick_conflict if cherry_pick_conflict?
+            return on_add_cacheinfo_fail if add_cacheinfo_fail?(result)
+
+            raise "Cherry pick failed: #{result}"
+          end
+
+          def cherry_pick_conflict?
+            ::File.exist?(::File.join(git, '.git', 'CHERRY_PICK_HEAD'))
+          end
+
+          def on_add_cacheinfo_fail
+            warn message('"add_cacheinfo" fail')
+          end
+
+          def on_cherry_pick_conflict
+            warn message('Cherry pick failed with conflict')
+            resolve_cherry_pick_conflicts
+
+            check_dirty_files
+            check_cherry_continue
+          end
+
+          def resolve_cherry_pick_conflicts
+            git.status_files.each do |scf|
+              if scf.dirty == 'D'
+                remove_file(scf.path)
+              elsif scf.dirty.present?
+                add_file(scf.path)
+              end
+            end
+          end
+
+          def remove_file(path)
+            infov message('Removing file'), path
+            git.execute!('rm', path)
+          end
+
+          def add_file(path)
+            infov message('Adding file'), path
+            git.execute!('add', path)
+          end
+
+          def check_dirty_files
+            infom message('Checking dirty files...')
+            df = dirty_files
+            infov message('Dirty files?'), df.any?
+            return unless df.any?
+
+            df.each do |f|
+              infov message(f.path, 1), "|#{f.stage}|#{f.dirty}|"
+            end
+            raise 'There are dirty files'
+          end
+
+          def dirty_files
+            git.status_files.select { |scf| scf.dirty.present? }
+          end
+
+          def check_cherry_continue
+            infom message('Continuing cherry pick')
+            git.execute!('-c', "core.editor=#{bash_editor}", 'cherry-pick', '--continue')
+            raise 'Still in cherry-pick conflict' if cherry_pick_conflict?
+
+            infom message('Cherry pick continue successful')
+          end
+
+          def bash_editor
+            if source_commit.subject.present?
+              'true'
+            else
+              'bash -c "printf \\"Mensagem original em branco.\\n\\" > $1"'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/lfs_commit/push.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class LfsCommit
+        module Push
+          private
+
+          PACK_ERROR_MESSAGE = 'pack exceeds maximum allowed size'
+          PACK_ERROR_TRUE = 'true'
+          PACK_ERROR_FALSE = 'false'
+
+          def push_ok_uncached
+            commit
+            fresh_push if push_pack_error_cache.read.blank?
+            after_push_banner
+            push_pack_error_cache.read != PACK_ERROR_TRUE
+          end
+
+          def after_push_banner
+            infov message('Commit SHA1'), commit.sha1
+            raise 'Cache of files size not found' if files_size_cache.read.blank?
+
+            infov message('Files size'), PushLarge.bytes_size(files_size_cache.read)
+          end
+
+          def fresh_push
+            fresh_push_banner
+            check_push_result(
+              git.execute(
+                'push', push_large.remote_name, '--force',
+                "#{commit.sha1}:#{push_reference}"
+              )
+            )
+          end
+
+          def fresh_push_banner
+            infom message('Pushing...')
+            fresh_push_commit_banner
+            fresh_push_remote_banner
+          end
+
+          def fresh_push_commit_banner
+            infov message('SHA1', 1), commit.sha1
+            infov message('Files size', 1), PushLarge.bytes_size(commit.files_size)
+          end
+
+          def fresh_push_remote_banner
+            infov message('Remote', 1), push_large.remote_name
+            infov message('Reference', 1), push_reference
+          end
+
+          def push_reference
+            "refs/heads/#{push_large.target_ref}"
+          end
+
+          def check_push_result(result)
+            if result.fetch(:exit_code).zero?
+              on_push_result_ok
+            elsif result.fetch(:stderr).include?(PACK_ERROR_MESSAGE)
+              on_push_result_pack_error
+            else
+              on_push_result_arbitrary_error(result)
+            end
+          end
+
+          def on_push_result_ok
+            push_pack_error_cache.write(PACK_ERROR_FALSE)
+            success(push_message('successful'))
+          end
+
+          def on_push_result_pack_error
+            push_pack_error_cache.write(PACK_ERROR_TRUE)
+            warn(push_message("failed with message \"#{PACK_ERROR_MESSAGE}\""))
+          end
+
+          def on_push_result_arbitrary_error(result)
+            raise result.pretty_inspect.to_s
+          end
+
+          def push_message(suffix)
+            message("Push of #{commit.sha1} (Size: #{commit.files_size}, " \
+                    "Files: #{commit.files.count}): #{suffix}.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/lfs_commit/track_large_files.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class LfsCommit
+        module TrackLargeFiles
+          private
+
+          EXTENSIONS_REQUIRED_TO_TRACK = %w[
+            bak bkp bmp bpm cfm chm dat db doc fla flv gz jar log mp3 mp4 otf pdf ppt psd rar rtf
+            swf ttf wav wmf wmv wmz woff woff2 xmind z zip
+          ].freeze
+
+          def track_large_files_uncached
+            cherry_pick_source_revision
+            if lfs_file_min_size.present?
+
+              source_commit.files.each do |file|
+                next unless track_file_with_lfs?(file)
+
+                track_file(file)
+              end
+              raise 'None file was tracked' unless tracked_files.positive?
+            end
+            infov message('Tracked files'), @tracked_files
+          end
+
+          def track_file(file)
+            infov message('Tracking with LFS'), file
+            git.execute!('rm', '--cached', file.path)
+            git.execute!('lfs', 'track', file.path) unless tracked_file?(file)
+            @tracked_files += 1
+          end
+
+          def track_file_with_lfs?(file)
+            return false unless file.dst_size.positive?
+
+            required_extesion_to_track?(file) || (file.dst_size >= lfs_file_min_size)
+          end
+
+          def required_extesion_to_track?(file)
+            EXTENSIONS_REQUIRED_TO_TRACK.include?(::File.extname(file.path).gsub(/\A\./, ''))
+          end
+
+          def tracked_file?(file)
+            git.execute!('check-attr', '--all', '--', file.path).strip.present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/lfs_commit.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/core_ext'
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class LfsCommit
+        require_sub __FILE__, include_modules: true
+        enable_simple_cache
+        enable_speaker
+
+        common_constructor :source_commit, :lfs_file_min_size do
+          @tracked_files = 0
+          @commit = nil
+        end
+
+        def push_ok?
+          push_ok
+        end
+
+        def start_banner
+          infov '  * LFS push', "revision: #{source_revision}" \
+                                ", lfs_file_min_size: #{PushLarge.bytes_size(lfs_file_min_size)}"
+        end
+
+        private
+
+        def git
+          source_commit.git
+        end
+
+        def push_large
+          source_commit.push_large
+        end
+
+        def previous_revision
+          push_large.last_pushed_revision
+        end
+
+        def source_revision
+          source_commit.sha1
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/source_commit/push.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'filesize'
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class SourceCommit
+        module Push
+          private
+
+          LFS_FILE_MIN_SIZES = [nil, 1_048_576, 524_288, 131_072].freeze
+
+          def pushed_revision_uncached
+            fs_cache.child('pushed_revision')
+          end
+
+          def run_pushs
+            return if LFS_FILE_MIN_SIZES.any? do |lfs_file_min_size|
+              lfs_commit = ::Avmtrf1::Git::PushLarge::LfsCommit.new(self, lfs_file_min_size)
+              lfs_commit.start_banner
+              push_with_lfs(lfs_commit)
+            end
+
+            raise 'Push de todos os commits falharam'
+          end
+
+          def push_with_lfs(lfs_commit)
+            if lfs_commit.push_ok?
+              pushed_revision.write(lfs_commit.commit.sha1)
+              success "  * Pushed: #{pushed_revision.read}"
+              true
+            else
+              warn '  * Push failed'
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/source_commit.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'avm/git/commit'
+require 'avmtrf1/tools/core_ext'
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class SourceCommit < ::Avm::Git::Commit
+        require_sub __FILE__, include_modules: true
+        enable_simple_cache
+        enable_speaker
+
+        attr_reader :push_large, :sha1, :no_lfs_max_size
+
+        def initialize(push_large, sha1)
+          super(push_large.git, sha1)
+          @push_large = push_large
+        end
+
+        def run
+          start_banner
+          if pushed_revision.read.present?
+            success '  * Target revision already pushed'
+          else
+            before_pushs_banner
+            run_pushs
+            after_pushs_banner
+          end
+        end
+
+        def fs_cache
+          @fs_cache ||= push_large.fs_cache.child(sha1)
+        end
+
+        private
+
+        def start_banner
+          infov '  * SHA1', sha1
+          infov '  * Subject', subject
+          infov '  * Author', author_all
+          infov '  * Commiter', commiter_all
+          infov '  * Files', files.count
+        end
+
+        def before_pushs_banner
+          infov '  * Files size', PushLarge.bytes_size(files_size)
+          infov '  * Pushed revision (BEFORE)', pushed_revision.read
+        end
+
+        def after_pushs_banner
+          infov '  * Pushed revision (AFTER)', pushed_revision.read
+          raise 'Target revision is blank' if pushed_revision.read.blank?
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+require 'eac_ruby_utils/patches/module/speaker'
+require 'eac_ruby_utils/require_sub'
+require 'eac_ruby_utils/simple_cache'
+require 'avmtrf1/patches/avm/git/launcher/base'
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      include ::EacRubyUtils::SimpleCache
+      enable_speaker
+
+      ::EacRubyUtils.require_sub(__FILE__)
+
+      attr_reader :git, :remote_name, :source_ref, :target_ref, :last_pushed_revision
+
+      def initialize(git_local_path, remote_name, source_ref, target_ref)
+        @git = ::Avm::Git::Launcher::Base.new(git_local_path)
+        @remote_name = remote_name
+        @source_ref = source_ref
+        @target_ref = target_ref
+        @last_pushed_revision = nil
+      end
+
+      def run
+        start_banner
+        push_revisions
+      end
+
+      def fs_cache_object_id
+        ::File.expand_path(git).parameterize
+      end
+
+      private
+
+      def start_banner
+        infov 'Git local', git
+        infov 'Remote name', remote_name
+        infov 'Source ref.', source_ref
+        infov 'Source rev.', source_rev
+        infov 'Target ref.', target_ref
+        infov 'Revisions to push', revisions.count
+      end
+
+      def push_revisions
+        count = 1
+        revisions.each do |rev|
+          infom "Pushing commit #{count}/#{revisions.count}..."
+          source_commit = ::Avmtrf1::Git::PushLarge::SourceCommit.new(self, rev)
+          source_commit.run
+          @last_pushed_revision = source_commit.pushed_revision.read
+          count += 1
+        end
+      end
+
+      def source_rev
+        git.rev_parse(source_ref)
+      end
+
+      def revisions_uncached
+        git.execute!('--no-pager', 'log', '--reverse', '--pretty=format:%H', source_rev)
+          .each_line.map(&:strip)
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/reference.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Avmtrf1
+  module Git
+    class Reference
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :revision, :fullname
+
+      def initialize(git, fullname, revision)
+        @git = git
+        @fullname = fullname
+        @revision = revision
+      end
+
+      def type_uncached
+        parsed_fullname.type
+      end
+
+      delegate :name, to: :parsed_fullname
+
+      private
+
+      def parsed_fullname_uncached
+        m = %r{\Arefs/([^/]+)s/(.+)\z}.match(fullname)
+        return ::OpenStruct.new(name: m[2], type: m[1]) if m # rubocop:disable Style/OpenStructUse
+
+        raise "\"#{fullname}\" not match ref pattern"
+      end
+    end
+  end
+end

data/lib/avmtrf1/git.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    require 'avmtrf1/git/cached_repository'
+    require 'avmtrf1/git/issue_on_repository'
+    require 'avmtrf1/git/push_large'
+    require 'avmtrf1/git/reference'
+  end
+end

data/lib/avmtrf1/gitlab/commit.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Gitlab
+    class Commit
+      enable_speaker
+      enable_simple_cache
+      common_constructor :repository, :git, :source
+
+      delegate :id, to: :git_commit
+
+      def to_s
+        source
+      end
+
+      # @return [String]
+      def markdown_link(object_type = 'commit')
+        "[#{git_commit.abbreviated_commit_hash}|#{web_url(object_type)}]"
+      end
+
+      # @return [String]
+      def textile_link(object_type = 'commit')
+        "\"#{git_commit.abbreviated_commit_hash}\":#{web_url(object_type)}"
+      end
+
+      def web_url(object_type = 'commit')
+        "#{repository.web_url}/#{object_type}/#{git_commit.commit_hash}"
+      end
+
+      private
+
+      def git_commit_uncached
+        git.commit(git.rev_parse(source))
+      end
+    end
+  end
+end

data/lib/avmtrf1/gitlab/repository.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/core_ext'
+
+module Avmtrf1
+  module Gitlab
+    class Repository
+      class << self
+        # @param uri [String]
+        # @return [Avmtrf1::Gitlab::Address, nil]
+        def by_uri(uri)
+          by_git_uri(uri) || by_https_uri(uri)
+        end
+
+        # @param uri [String]
+        # @return [Avmtrf1::Gitlab::Address, nil]
+        def by_git_uri(uri)
+          /\Agit@(.+):(.+)\z/i.if_match(uri, false) do |m|
+            new(:git, m[1], m[2])
+          end
+        end
+
+        # @param uri [String]
+        # @return [Avmtrf1::Gitlab::Address, nil]
+        def by_https_uri(uri)
+          %r{\Ahttps?://([^\/]+)/(.+)\z}i.if_match(uri, false) do |m|
+            new(:https, m[1], m[2])
+          end
+        end
+      end
+
+      common_constructor :protocol, :authority, :path do
+        self.path = '/' + path.to_s.gsub(/\.git\Z/, '').gsub(%r{\A/+}, '') # rubocop:disable Style/StringConcatenation
+      end
+
+      def web_url
+        "https://#{authority}#{path}"
+      end
+    end
+  end
+end

data/lib/avmtrf1/ini/profile.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+
+module Avmtrf1
+  class Ini
+    class Profile
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :ini, :name, :parent_name, :self_data
+
+      # @param profiles [Avmtrf1::Ini::Profiles
+      def initialize(ini, name, parent_name, self_data)
+        @ini = ini
+        @name = name
+        @parent_name = parent_name
+        @self_data = self_data
+      end
+
+      delegate :[], to: :data
+
+      delegate :fetch, to: :data
+
+      def to_h(prefix = '')
+        data.select { |k, _v| k.start_with?(prefix) }
+          .map { |e| [e[0].gsub(/\A#{Regexp.quote(prefix)}/, ''), e[1]] }.to_h # rubocop:disable Style/MapToHash
+      end
+
+      private
+
+      def data_uncached
+        r = self_data
+        r = parent.data.merge(r) if parent
+        r
+      end
+
+      def parent
+        parent_name ? ini.profiles[parent_name] : nil
+      end
+    end
+  end
+end

data/lib/avmtrf1/ini.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+require 'pp' # rubocop:disable Lint/RedundantRequireStatement
+require 'avmtrf1/ini/profile'
+require 'avmtrf1/patches/inifile'
+
+module Avmtrf1
+  # Leitor de arquivos .ini com suporte a herança de seções/perfis.
+  class Ini
+    include ::EacRubyUtils::SimpleCache
+
+    class << self
+      SECTION_NAME_PATTERN = /\A([^\:]+)(?::([^\:]+))?\z/.freeze
+
+      # @return Um [Array] em que o primeiro elemento é o perfil e o segundo é seu super-perfil.
+      def parse_section_name(section_name)
+        m = SECTION_NAME_PATTERN.match(section_name)
+        return [m[1], m[2]] if m
+
+        raise "Section name pattern \"#{SECTION_NAME_PATTERN}\" not match \"#{section_name}\""
+      end
+
+      # @return [IniFile].
+      def inifile_from_file(path)
+        raise "\"#{path}\" does not exist or is not a file" unless ::File.file?(path)
+
+        r = ::IniFile.load(path)
+        return r if r.is_a?(::IniFile)
+
+        raise "\"#{path}\" not converted to Inifile"
+      end
+    end
+
+    attr_reader :inifile
+
+    # @param ini Um [IniFile] ou um caminho de arquivo .ini.
+    def initialize(inifile)
+      @inifile = inifile.is_a?(::IniFile) ? inifile : self.class.inifile_from_file(inifile.to_s)
+    end
+
+    private
+
+    def profiles_uncached
+      r = {}
+      inifile.each_section do |section|
+        profile_name, profile_parent_name = self.class.parse_section_name(section)
+        r[profile_name] = ::Avmtrf1::Ini::Profile.new(
+          self, profile_name, profile_parent_name, inifile[section]
+        )
+      end
+      r.sort.to_h.freeze
+    end
+  end
+end