dapp 0.35.21 → 0.35.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaa1f4b1b9ecbae4c4cffcbcf0b4c258433308a64e2111f763ef3c24a0ac7bd7
-  data.tar.gz: 4f9a43099a56de704572f96e3e9d7f839c5db6c1ee79926ee729d36f5ecfa26a
+  metadata.gz: 57be5b4eb14655fa5d40d393d3a4dd013eb96cd0d025770c3db2e3d5a4749bce
+  data.tar.gz: db9f0fe8f87c03c913da3dd8ca14083fab32face1752b810e88079a4bf22cd21
 SHA512:
-  metadata.gz: e4778c9acef18386da9cee0dfe3583978f0c3d72f84827e3111b183d3de94b14fba279d4806c75f1c2630e9a32683fb52be402a0b25cf44fb83c81519678dd59
-  data.tar.gz: 500416d19ce8e06c7bec777141576f380721c07d9de6f94a7965b8e2bff0755cf05b388c28e94657bce5ad5cb09c056bd627de69f805f63694679b18875ed7ff
+  metadata.gz: 575993cdd9d454b58d83295110ab47b130e791ef66905a78a0738429ee99ca131c769fa81a95491ec2926b2367d0499575c2daf341b6549e3754bada3698fb6f
+  data.tar.gz: f1ebdd957e12c5a62ab87532a14db8b7bd675a42272dfcaf3fb63d9b93a168ff04206823c8ee240ecee883585c536e6c037ef14e6ca93b4e08db67688bb55547

data/lib/dapp/dimg/build/stage/ga_latest_patch.rb

@@ -29,12 +29,14 @@ module Dapp
 
           def commit_list
             dimg.git_artifacts
-              .select { |ga| ga.repo.commit_exists?(prev_stage.layer_commit(ga)) && ga.patch_any_changes?(self) }
+              .select { |ga| ga.repo.commit_exists?(prev_stage.layer_commit(ga)) && !ga.is_patch_empty(self) }
               .map(&method(:layer_commit))
           end
 
           def git_artifacts_dev_patch_hashes
-            dimg.git_artifacts.map(&:dev_patch_hash)
+            # FIXME: dev-mode support in GitArtifact
+            # dimg.git_artifacts.map(&:dev_patch_hash)
+            nil
           end
         end # GALatestPatch
       end # Stage

data/lib/dapp/dimg/dimg/git_artifact.rb

@@ -28,22 +28,12 @@ module Dapp
         def generate_git_artifacts(repo, omit_empty: true, **git_artifact_options)
           [].tap do |artifacts|
             artifacts << (artifact = ::Dapp::Dimg::GitArtifact.new(repo, self, ignore_signature_auto_calculation: ignore_signature_auto_calculation, **git_artifact_options))
-            if ENV['DAPP_DISABLE_GIT_SUBMODULES']
-              artifacts
-            else
-              artifacts.concat(generate_git_embedded_artifacts(artifact))
-            end
+            artifacts
           end.select do |artifact|
-            !omit_empty || !artifact.empty?
+            !omit_empty || !artifact.is_empty
           end
         end
 
-        def generate_git_embedded_artifacts(artifact)
-          [].tap do |artifacts|
-            artifacts.concat(submodules_artifacts = artifact.embedded_artifacts)
-            artifacts.concat(submodules_artifacts.map(&method(:generate_git_embedded_artifacts)).flatten)
-          end
-        end
       end # GitArtifact
     end # Mod
   end # Dimg

data/lib/dapp/dimg/git_artifact.rb

@@ -14,7 +14,7 @@ module Dapp
       # rubocop:disable Metrics/ParameterLists
       def initialize(repo, dimg, to:, name: nil, branch: nil, tag: nil, commit: nil,
                      cwd: nil, include_paths: nil, exclude_paths: nil, owner: nil, group: nil, as: nil,
-                     stages_dependencies: {}, ignore_signature_auto_calculation: false, disable_go_git: nil)
+                     stages_dependencies: {}, ignore_signature_auto_calculation: false)
         @repo = repo
         @dimg = dimg
         @name = name
@@ -34,175 +34,31 @@ module Dapp
         @as = as
 
         @stages_dependencies = stages_dependencies
-        @disable_go_git = disable_go_git unless disable_go_git.nil?
-      end
-      # rubocop:enable Metrics/ParameterLists
-
-      def embedded_artifacts
-        [submodules_artifacts, nested_git_directory_artifacts].flatten
-      end
-
-      def submodules_artifacts
-        commit = dev_mode? ? nil : latest_commit
-        repo.submodules_params(commit,
-                               paths: include_paths_or_cwd,
-                               exclude_paths: exclude_paths(true)).map(&method(:submodule_artifact))
-      end
-
-      def submodule_artifact(submodule_params)
-        embedded_artifact(**submodule_params, disable_go_git: true)
-      rescue Rugged::InvalidError => e
-        raise Error::Rugged, code: :git_local_incorrect_gitmodules_params, data: { error: e.message }
-      end
-
-      def nested_git_directory_artifacts
-        return [] unless dev_mode?
-        repo
-          .nested_git_directories_patches(paths: include_paths_or_cwd, exclude_paths: exclude_paths(true), **diff_patches_options)
-          .map(&method(:nested_git_directory_artifact))
-      end
-
-      def nested_git_directory_artifact(patch)
-        params = {}.tap do |p|
-          p[:path] = patch.delta.new_file[:path]
-          p[:type] = :local
-        end
-        embedded_artifact(params)
-      end
 
-      def embedded_artifact(embedded_params)
-        embedded_rel_path = embedded_params[:path]
-        embedded_repo     = begin
-          if embedded_params[:type] == :remote
-            GitRepo::Remote.get_or_create(repo.dapp, embedded_rel_path, url: embedded_params[:url])
-          elsif embedded_params[:type] == :local
-            embedded_path = File.join(repo.workdir_path, embedded_params[:path])
-            GitRepo::Local.new(repo.dapp, embedded_rel_path, embedded_path)
-          else
-            raise
-          end
-        end
-
-        self.class.new(embedded_repo, dimg, embedded_artifact_options(embedded_params))
-      end
-
-      def embedded_artifact_options(embedded_params)
-        embedded_rel_path = embedded_params[:path]
-
-        {}.tap do |options|
-          options[:name]                = repo.dapp.consistent_uniq_slugify("embedded-#{embedded_rel_path}")
-          options[:cwd]                 = begin
-            subpath = Pathname(cwd).subpath_of(embedded_rel_path)
-            subpath = '' if subpath == '.'
-            subpath
-          end
-          options[:to]                  = Pathname(cwd).subpath_of?(embedded_rel_path) ? to : File.join(to, embedded_rel_path)
-          options[:include_paths]       = embedded_inherit_paths(include_paths, embedded_rel_path)
-          options[:exclude_paths]       = embedded_inherit_paths(exclude_paths, embedded_rel_path)
-          options[:stages_dependencies] = begin
-            stages_dependencies
-              .map { |stage, paths| [stage, embedded_inherit_paths(paths, embedded_rel_path)] }
-              .to_h
-          end
-          options[:branch]              = embedded_params[:branch]
-          options[:commit]              = embedded_params[:commit]
-          options[:owner]               = owner
-          options[:group]               = group
-
-          options[:ignore_signature_auto_calculation] = ignore_signature_auto_calculation
-          options[:disable_go_git] = embedded_params[:disable_go_git]
-        end
-      end
 
-      def embedded_inherit_paths(paths, embedded_rel_path)
-        paths
-          .select { |path| check_path?(embedded_rel_path, path) || check_subpath?(embedded_rel_path, path) }
-          .map { |path| embedded_inherit_path(path, embedded_rel_path) }
-          .flatten
-          .compact
+        @all_include_paths = base_paths(@include_paths, true)
+        @all_exclude_paths = repo.exclude_paths + base_paths(@exclude_paths, true)
       end
+      # rubocop:enable Metrics/ParameterLists
 
-      def embedded_inherit_path(path, embedded_rel_path)
-        path_parts      = path.split('/')
-        test_path       = nil
-        inherited_paths = []
-
-        until path_parts.empty?
-          current_path_part = path_parts.shift
-          test_path         = [test_path, current_path_part].compact.join('/')
-
-          match = File.fnmatch(test_path, embedded_rel_path, File::FNM_PATHNAME|File::FNM_DOTMATCH)
-          break unless match || File.fnmatch(File.join(test_path, '**', '*'), embedded_rel_path, File::FNM_PATHNAME|File::FNM_DOTMATCH)
-
-          any = (current_path_part == '**')
-
-          if any
-            inherited_paths << [current_path_part, path_parts].flatten.join('/')
-            inherited_paths << path_parts.join('/') unless path_parts.empty?
-          elsif match && !path_parts.empty?
-            inherited_paths << path_parts.join('/')
-            break
-          elsif path_parts.empty?
-            inherited_paths << '**'
-            break
-          end
-        end
-
-        inherited_paths
-      end
-
-      def cwd_type(stage)
-        if dev_mode?
-          p = repo.workdir_path.join(cwd)
-          if p.exist?
-            if p.directory?
-              :directory
-            else
-              :file
-            end
-          end
-        elsif cwd == ''
-          :directory
-        else
-          cwd_type_by_commit(repo.lookup_commit(stage.layer_commit(self)))
-        end
-      end
-
-      def cwd_type_by_commit(commit)
-        cwd_entry = begin
-          commit.tree.path(cwd)
-        rescue Rugged::TreeError
-        end
-
-        if cwd_entry
-          if cwd_entry[:type] == :tree
-            :directory
+      def base_paths(paths, with_cwd = false)
+        [paths].flatten.compact.map do |path|
+          if with_cwd && !cwd.empty?
+            File.join(cwd, path)
           else
-            :file
+            path
           end
+            .chomp('/')
+            .reverse.chomp('/')
+            .reverse
         end
       end
 
-      def disable_go_git?
-        return @disable_go_git unless @disable_go_git.nil?
-
-        @disable_go_git = (dev_mode? || !!ENV["DAPP_DISABLE_GO_GIT"] || begin
-          commit = dev_mode? ? nil : latest_commit
-          repo.submodules(
-            commit,
-            paths: include_paths_or_cwd,
-            exclude_paths: exclude_paths(true)
-          ).any?
-        end)
-      end
-
       def apply_archive_command(stage)
-        return apply_archive_command_old(stage) if disable_go_git?
-
         res = repo.dapp.ruby2go_git_artifact(
           "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
           "method" => "ApplyArchiveCommand",
-          "Stage" => JSON.dump(get_stub_stage_state(stage)),
+          "Stage" => JSON.dump(merge_layer_commit_stub_stage_state(stage.get_ruby2go_state_hash, stage)),
         )
 
         raise res["error"] if res["error"]
@@ -213,48 +69,23 @@ module Dapp
         Array(res["data"]["result"])
       end
 
-      def apply_archive_command_old(stage)
-        [].tap do |commands|
-          if archive_any_changes?(stage)
-            case cwd_type(stage)
-            when :directory
-              stage.image.add_service_change_label(repo.dapp.dimgstage_g_a_type_label(paramshash).to_sym => 'directory')
-
-              commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
-              commands << "#{sudo} #{repo.dapp.tar_bin} -xf #{archive_file(stage)} -C \"#{to}\""
-            when :file
-              stage.image.add_service_change_label(repo.dapp.dimgstage_g_a_type_label(paramshash).to_sym => 'file')
-
-              commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
-              commands << "#{sudo} #{repo.dapp.tar_bin} -xf #{archive_file(stage)} -C \"#{File.dirname(to)}\""
-            end
-          end
-        end
-      end
-
-      def archive_type(stage)
-        stage.prev_stage.image.labels[repo.dapp.dimgstage_g_a_type_label(paramshash)].to_s.to_sym
-      end
+      def merge_layer_commit_stub_stage_state(stage_state, stage)
+        # Data for StubStage specific for ApplyPatchCommand
+        stage_state["LayerCommitMap"] = {
+          paramshash => stage.layer_commit(self),
+        }
+        stage_state["PrevStage"]["LayerCommitMap" ] = {
+          paramshash => stage.prev_stage.layer_commit(self),
+        }
 
-      def get_stub_stage_state(stage)
-        stage.get_ruby2go_state_hash.tap do |stage_state|
-          # Data for StubStage specific for ApplyPatchCommand
-          stage_state["LayerCommitMap"] = {
-            paramshash => stage.layer_commit(self),
-          }
-          stage_state["PrevStage"]["LayerCommitMap" ] = {
-            paramshash => stage.prev_stage.layer_commit(self),
-          }
-        end
+        stage_state
       end
 
       def apply_patch_command(stage)
-        return apply_patch_command_old(stage) if disable_go_git?
-
         res = repo.dapp.ruby2go_git_artifact(
           "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
           "method" => "ApplyPatchCommand",
-          "Stage" => JSON.dump(get_stub_stage_state(stage)),
+          "Stage" => JSON.dump(merge_layer_commit_stub_stage_state(stage.get_ruby2go_state_hash, stage)),
         )
 
         raise res["error"] if res["error"]
@@ -265,48 +96,6 @@ module Dapp
         Array(res["data"]["result"])
       end
 
-      def apply_patch_command_old(stage)
-        [].tap do |commands|
-          if dev_mode?
-            if any_changes?(*dev_patch_stage_commits(stage))
-              case archive_type(stage)
-              when :directory
-                files_to_remove_file_name = file_name('dev_files_to_remove')
-                File.open(dimg.tmp_path('archives', files_to_remove_file_name), File::RDWR | File::CREAT) do |f|
-                  diff_patches(*dev_patch_stage_commits(stage))
-                    .map {|p| File.join(to, cwd, p.delta.new_file[:path])}
-                    .each(&f.method(:puts))
-                end
-
-                commands << "#{repo.dapp.rm_bin} -rf $(#{repo.dapp.cat_bin} #{dimg.container_tmp_path('archives', files_to_remove_file_name)})"
-                commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
-                commands << "#{sudo} #{repo.dapp.tar_bin} -xf #{archive_file(stage)} -C \"#{to}\""
-                commands << "#{repo.dapp.find_bin} \"#{to}\" -empty -type d -delete"
-              when :file
-                commands << "#{repo.dapp.rm_bin} -rf \"#{to}\""
-                commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
-                commands << "#{sudo} #{repo.dapp.tar_bin} -xf #{archive_file(stage)} -C \"#{File.dirname(to)}\""
-              else
-                raise
-              end
-            end
-          else
-            if patch_any_changes?(stage)
-              case archive_type(stage)
-              when :directory
-                commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
-                commands << "#{sudo} #{repo.dapp.git_bin} apply --whitespace=nowarn --directory=\"#{to}\" --unsafe-paths #{patch_file(stage, *patch_stage_commits(stage))}"
-              when :file
-                commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
-                commands << "#{sudo} #{repo.dapp.git_bin} apply --whitespace=nowarn --directory=\"#{File.dirname(to)}\" --unsafe-paths #{patch_file(stage, *patch_stage_commits(stage))}"
-              else
-                raise
-              end
-            end
-          end
-        end
-      end
-
       def calculate_stage_dependencies_checksum(stage)
         res = repo.dapp.ruby2go_git_artifact(
           "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
@@ -324,46 +113,11 @@ module Dapp
       end
 
       def stage_dependencies_checksum(stage)
-        return stage_dependencies_checksum_old(stage) if dev_mode?
         stage_dependencies_key = [stage.name, commit]
         @stage_dependencies_checksums ||= {}
         @stage_dependencies_checksums[stage_dependencies_key] ||= calculate_stage_dependencies_checksum(stage)
       end
 
-      def stage_dependencies_checksum_old(stage)
-        return [] if (stage_dependencies = stages_dependencies[stage.name]).empty?
-
-        paths = base_paths(stage_dependencies, true)
-        commit = dev_mode? ? nil : latest_commit
-
-        stage_dependencies_key = [stage.name, commit]
-
-        @stage_dependencies_warning ||= {}
-        @stage_dependencies_checksums ||= {}
-        @stage_dependencies_checksums[stage_dependencies_key] ||= begin
-          if dev_mode?
-            dev_patch_hash(paths: paths)
-          else
-            if (entries = repo_entries(commit, paths: paths)).empty? && @stage_dependencies_warning[stage.name].nil?
-              @stage_dependencies_warning[stage.name] = true
-              code = cwd_type_by_commit(repo.lookup_commit(commit)) == :file ? :stage_dependencies_file_not_found : :stage_dependencies_not_found
-              repo.dapp.log_warning(desc: { code: code,
-                                            data: { repo: repo.respond_to?(:url) ? repo.url : 'local',
-                                                    dependencies: stage_dependencies.join(', ') } })
-            end
-
-            entries
-              .sort_by {|root, entry| File.join(root, entry[:name])}
-              .reduce(nil) {|prev_hash, (root, entry)|
-                content = nil
-                content = repo.lookup_object(entry[:oid]).content if entry[:type] == :blob
-
-                hexdigest prev_hash, File.join(root, entry[:name]), entry[:filemode].to_s, content
-              }
-          end
-        end
-      end
-
       def patch_size(from_commit)
         res = repo.dapp.ruby2go_git_artifact(
           "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
@@ -378,24 +132,6 @@ module Dapp
         res["data"]["result"]
       end
 
-      def patch_size_old(from_commit)
-        to_commit = dev_mode? ? nil : latest_commit
-        diff_patches(from_commit, to_commit).reduce(0) do |bytes, patch|
-          bytes += patch.delta.deleted? ? patch.delta.old_file[:size] : patch.delta.new_file[:size]
-          bytes
-        end
-      end
-
-      def dev_patch_hash(**options)
-        return unless dev_mode?
-        hexdigest begin
-          diff_patches(nil, nil, **options).map do |patch|
-            file = patch.delta.new_file
-            [file[:path], File.read(File.join(repo.workdir_path, file[:path])), file[:mode]]
-          end
-        end
-      end
-
       def get_ruby2go_state_hash
         {
           "Name" => @name.to_s,
@@ -408,10 +144,9 @@ module Dapp
           "RepoPath" => File.join("/", @cwd.to_s),
           "Owner" => @owner.to_s,
           "Group" => @group.to_s,
-          "IncludePaths" => include_paths(true),
-          "ExcludePaths" => exclude_paths(true),
+          "IncludePaths" => @all_include_paths,
+          "ExcludePaths" => @all_exclude_paths,
           "StagesDependencies" => @stages_dependencies.map {|k, v| [_stages_map[k], Array(v).map(&:to_s)]}.to_h,
-          "Paramshash" => paramshash.to_s,
           "PatchesDir" => dimg.tmp_path('patches'),
           "ContainerPatchesDir" => dimg.container_tmp_path('patches'),
           "ArchivesDir" => dimg.tmp_path('archives'),
@@ -477,307 +212,76 @@ module Dapp
       end
 
       def paramshash
-        hexdigest full_name, to, cwd, *include_paths, *exclude_paths, owner, group
-      end
-
-      def full_name
-        "#{repo.name}#{name ? "_#{name}" : nil}"
-      end
-
-      def archive_any_changes?(stage)
-        repo_entries(stage_commit(stage)).any?
-      end
-
-      def patch_any_changes?(stage)
-        any_changes?(*patch_stage_commits(stage))
-      end
-
-      def empty?
-        repo_entries(latest_commit).empty?
-      end
-
-      protected
-
-      def hexdigest(*args)
-        Digest::SHA256.hexdigest args.compact.map {|arg| arg.to_s.force_encoding("ASCII-8BIT")}.join(":::")
-      end
-
-      attr_reader :dimg
-      attr_reader :to
-      attr_reader :commit
-      attr_reader :branch
-      attr_reader :tag
-      attr_reader :cwd
-      attr_reader :owner
-      attr_reader :group
-      attr_reader :stages_dependencies
-      attr_reader :ignore_signature_auto_calculation
-
-      def sudo
-        repo.dapp.sudo_command(owner: owner, group: group)
-      end
-
-      def credentials
-        [:owner, :group].map { |attr| "--#{attr}=#{send(attr)}" unless send(attr).nil? }.compact
-      end
-
-      def archive_file(stage)
-        commit = stage_commit(stage)
-        if repo.dapp.options[:use_system_tar]
-          archive_file_with_system_tar(stage, commit)
-        else
-          archive_file_with_tar_writer(stage, commit)
-        end
-        dimg.container_tmp_path('archives', archive_file_name(commit))
-      end
-
-      def archive_file_with_tar_writer(stage, commit)
-        tar_write(dimg.tmp_path('archives', archive_file_name(commit))) do |tar|
-          each_archive_entry(stage, commit) do |path, content, mode|
-            relative_path = path.reverse.chomp('/').reverse
-            if mode == 0o120000 # symlink
-              tar.add_symlink relative_path, content, mode
-            else
-              tar.add_file relative_path, mode do |tf|
-                tf.write content
-              end
-            end
-          end
-        end
-      rescue Gem::Package::TooLongFileName => e
-        raise Error::TarWriter, message: e.message
-      end
-
-      def archive_file_with_system_tar(stage, commit)
-        dimg.tmp_path('archives', archive_file_name(commit)).tap do |archive_path|
-          relative_archive_file_path = File.join('archives_files', file_name(commit))
-          each_archive_entry(stage, commit) do |path, content, mode|
-            file_path = dimg.tmp_path(relative_archive_file_path, path)
-
-            if mode == 0o120000 # symlink
-              FileUtils.symlink(content, file_path)
-            else
-              IO.write(file_path, content)
-              FileUtils.chmod(mode, file_path)
-            end
-          end
-
-          repo.dapp.shellout!("tar -C #{dimg.tmp_path(relative_archive_file_path)} -cf #{archive_path} .")
-        end
-      end
+        @paramshash ||= begin
+          res = repo.dapp.ruby2go_git_artifact("GitArtifact" => JSON.dump(get_ruby2go_state_hash), "method" => "GetParamshash")
 
-      def slice_cwd(stage, path)
-        return path if cwd.empty?
-
-        case cwd_type(stage)
-        when :directory
-          path
-            .reverse
-            .chomp(cwd.reverse)
-            .chomp('/')
-            .reverse
-        when :file
-          File.basename(to)
-        else
-          raise
-        end
-      end
+          raise res["error"] if res["error"]
 
-      def archive_file_name(commit)
-        file_name(commit, ext: 'tar')
-      end
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
 
-      def patch_file(stage, from_commit, to_commit)
-        File.open(dimg.tmp_path('patches', patch_file_name(from_commit, to_commit)), File::RDWR | File::CREAT) do |f|
-          diff_patches(from_commit, to_commit).each { |patch| f.write change_patch_new_file_path(stage, patch) }
+          res["data"]["result"]
         end
-        dimg.container_tmp_path('patches', patch_file_name(from_commit, to_commit))
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def change_patch_new_file_path(stage, patch)
-        patch.to_s.lines.tap do |lines|
-          prepare_native_path = proc do |path_with_cwd|
-            case archive_type(stage)
-            when :directory
-              path_with_cwd.sub(cwd, '')
-            when :file
-              File.basename(to)
-            else
-              raise
-            end
-          end
-
-          modify_patch_line = proc do |line_number, path_char|
-            action_part, path_part = lines[line_number].strip.split(' ', 2)
-            if (path_with_cwd = path_part.partition("#{path_char}/").last).start_with?(cwd)
-              prepare_native_path.call(path_with_cwd).tap do |native_path|
-                if native_path
-                  expected_path = File.join(path_char, native_path)
-                  lines[line_number] = [action_part, expected_path].join(' ') + "\n"
-                end
-              end
-            end
-          end
-
-          modify_patch_first_line = proc do
-            old_file_path = prepare_native_path.call(patch.delta.old_file[:path])
-            new_file_path = prepare_native_path.call(patch.delta.new_file[:path])
-            lines[0] = ['diff --git', File.join('a', old_file_path), File.join('b', new_file_path)].join(' ') + "\n"
-          end
-
-          modify_patch = proc do |*modify_patch_line_args|
-            native_paths = modify_patch_line_args.map { |args| modify_patch_line.call(*args) }
-            unless (native_paths = native_paths.compact.uniq).empty?
-              raise Error::Build, code: :unsupported_patch_format, data: { patch: patch.to_s } unless native_paths.one?
-              modify_patch_first_line.call
-            end
-          end
-
-          case
-          when patch.delta.deleted? then modify_patch.call([3, 'a'])
-          when patch.delta.added? then modify_patch.call([4, 'b'])
-          when patch.delta.modified?
-            if patch_file_mode_changed?(patch)
-              if patch.changes.zero?
-                modify_patch_first_line.call
-              else
-                modify_patch.call([4, 'a'], [5, 'b'])
-              end
-            else
-              modify_patch.call([2, 'a'], [3, 'b'])
-            end
-          else
-            raise
-          end
-        end.join
-      end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-      def patch_file_mode_changed?(patch)
-        patch.delta.old_file[:mode] != patch.delta.new_file[:mode]
-      end
+      def full_name
+        @full_name ||= begin
+          res = repo.dapp.ruby2go_git_artifact("GitArtifact" => JSON.dump(get_ruby2go_state_hash), "method" => "FullName")
 
-      def patch_file_name(from_commit, to_commit)
-        file_name(from_commit, to_commit, ext: 'patch')
-      end
+          raise res["error"] if res["error"]
 
-      def file_name(*args, ext: nil)
-        "#{[paramshash, args].flatten.compact.join('_')}#{".#{ext}" unless ext.nil? }"
-      end
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
 
-      def repo_entries(commit, paths: include_paths_or_cwd)
-        (@repo_entries ||= {})[[commit, paths]] ||= begin
-          repo
-            .blobs_entries(commit, paths: paths, exclude_paths: exclude_paths(true))
-            .select { |_, entry| !submodule_mode?(entry[:filemode]) }
+          res["data"]["result"]
         end
       end
 
-      def each_archive_entry(stage, commit)
-        if dev_mode? && stage.name != :g_a_archive
-          diff_patches(commit, nil).each do |patch|
-            file = patch.delta.new_file
-            host_file_path = File.join(repo.workdir_path, file[:path])
-            next unless File.exist?(host_file_path)
+      def is_patch_empty(stage)
+        return @is_patch_empty if !@is_patch_empty.nil?
 
-            content = File.read(host_file_path)
-            yield slice_cwd(stage, file[:path]), content, file[:mode]
-          end
-        else
-          repo_entries(commit).each do |root, entry|
-            next unless entry[:type] == :blob
+        @is_patch_empty = begin
+          res = repo.dapp.ruby2go_git_artifact(
+            "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
+            "method" => "IsPatchEmpty",
+            "Stage" => JSON.dump(merge_layer_commit_stub_stage_state({"PrevStage" => {}}, stage)),
+          )
 
-            entry_file_path = File.join(root, entry[:name])
-            content = repo.lookup_object(entry[:oid]).content
-            yield slice_cwd(stage, entry_file_path), content, entry[:filemode]
-          end
-        end
-      end
+          raise res["error"] if res["error"]
 
-      def diff_patches(from_commit, to_commit, paths: include_paths_or_cwd)
-        (@diff_patches ||= {})[[from_commit, to_commit, paths]] ||= begin
-          repo
-            .patches(from_commit, to_commit, paths: paths, exclude_paths: exclude_paths(true), **diff_patches_options)
-            .select do |patch|
-              file_mode = patch.delta.status == :deleted ? patch.delta.old_file[:mode] : patch.delta.new_file[:mode]
-              !(submodule_mode?(file_mode) || # FIXME: https://github.com/libgit2/rugged/issues/727
-                nested_git_directory_mode?(file_mode))
-            end
-        end
-      end
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
 
-      def diff_patches_options
-        {}.tap do |opts|
-          opts[:force_text] = true
-          if dev_mode?
-            opts[:include_untracked] = true
-            opts[:recurse_untracked_dirs] = true
-          end
+          res["data"]["result"]
         end
       end
 
-      def submodule_mode?(mode) # FIXME
-        mode == 0o160000
-      end
+      def is_empty
+        return @is_empty if !@is_empty.nil?
 
-      def nested_git_directory_mode?(mode)
-        mode == 0o040000
-      end
+        @is_empty = begin
+          res = repo.dapp.ruby2go_git_artifact(
+            "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
+            "method" => "IsEmpty",
+          )
 
-      def include_paths_or_cwd
-        case
-        when !include_paths(true).empty? then include_paths(true)
-        when !cwd.empty? then [cwd]
-        else
-          []
-        end
-      end
-
-      def exclude_paths(with_cwd = false)
-        repo.exclude_paths + base_paths(@exclude_paths, with_cwd)
-      end
+          raise res["error"] if res["error"]
 
-      def include_paths(with_cwd = false)
-        base_paths(@include_paths, with_cwd)
-      end
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
 
-      def base_paths(paths, with_cwd = false)
-        [paths].flatten.compact.map do |path|
-          if with_cwd && !cwd.empty?
-            File.join(cwd, path)
-          else
-            path
-          end
-            .chomp('/')
-            .reverse.chomp('/')
-            .reverse
+          res["data"]["result"]
         end
       end
 
-      def stage_commit(stage)
-        stage.layer_commit(self)
-      end
-
-      def patch_stage_commits(stage)
-        [stage.prev_stage.layer_commit(self), stage.layer_commit(self)]
-      end
-
-      def dev_patch_stage_commits(stage)
-        [stage.prev_stage.layer_commit(self), nil]
-      end
-
-      def any_changes?(from_commit, to_commit)
-        diff_patches(from_commit, to_commit).any?
-      end
-
-      def dev_mode?
-        local? && dimg.dev_mode?
-      end
+      protected
 
-      def local?
-        repo.is_a? GitRepo::Local
-      end
+      attr_reader :dimg
+      attr_reader :to
+      attr_reader :commit
+      attr_reader :branch
+      attr_reader :tag
+      attr_reader :cwd
+      attr_reader :owner
+      attr_reader :group
+      attr_reader :stages_dependencies
+      attr_reader :ignore_signature_auto_calculation
     end
   end
 end

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = "0.35.21"
+  VERSION = "0.35.22"
   BUILD_CACHE_VERSION = 31
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.35.21
+  version: 0.35.22
 platform: ruby
 authors:
 - Dmitry Stolyarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-16 00:00:00.000000000 Z
+date: 2018-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout