dapp 0.13.3 → 0.13.4

data/lib/dapp/dimg/config/directive/dimg/instance_methods.rb

@@ -63,7 +63,7 @@ module Dapp
               @_git_artifact ||= GitArtifact.new(dapp: dapp)
             end
 
-            [:build_dir, :tmp_dir].each do |mount_type|
+            [:build_dir, :tmp_dir, :custom_dir].each do |mount_type|
               define_method "_#{mount_type}_mount" do
                 _mount.select { |m| m._type == mount_type }
               end

data/lib/dapp/dimg/config/directive/dimg/validation.rb

@@ -29,11 +29,16 @@ module Dapp
                   elm.validate! if elm.respond_to?(:validate!)
                 end
               end
+              _mount.map(&:_to).tap do |mounts_points|
+                mounts_points.each do |path|
+                  raise Error::Config, code: :mount_duplicate_to, data: { path: path } if mounts_points.count(path) > 1
+                end
+              end
             end
 
             def validate_scratch_directives!
               directives = [[:_shell, :shell], [:_chef, :chef], [:_git_artifact, :git],
-                            [:_tmp_dir_mount, :mount], [:_build_dir_mount, :mount]]
+                            [:_tmp_dir_mount, :mount], [:_build_dir_mount, :mount], [:_custom_dir_mount, :mount]]
               directives.each do |name, user_name|
                 raise Error::Config,
                       code: :scratch_unsupported_directive,

data/lib/dapp/dimg/config/directive/docker/base.rb

@@ -10,8 +10,7 @@ module Dapp
               sub_directive_eval do
                 image = image.to_s
                 raise(Error::Config, code: :docker_from_incorrect, data: { name: image }) unless ::Dapp::Dimg::Image::Docker.image_name?(image)
-                raise(Error::Config, code: :docker_from_without_tag, data: { name: image }) unless image.include?(':')
-                @_from = image
+                @_from = image.include?(':') ? image : [image, 'latest'].join(':')
                 @_from_cache_version = cache_version
               end
             end

data/lib/dapp/dimg/config/directive/git_artifact_local.rb

@@ -3,6 +3,9 @@ module Dapp
     module Config
       module Directive
         class GitArtifactLocal < ArtifactBase
+          def export(absolute_dir_path = '/', &blk)
+            super
+          end
           alias add export
           undef_method :export
 

data/lib/dapp/dimg/config/directive/git_artifact_remote.rb

@@ -13,7 +13,7 @@ module Dapp
           end
 
           def branch(value)
-            sub_directive_eval { @_branch = value }
+            sub_directive_eval { @_branch = value.to_s }
           end
 
           def commit(value)

data/lib/dapp/dimg/config/directive/mount.rb

@@ -4,6 +4,7 @@ module Dapp
       module Directive
         class Mount < Base
           attr_reader :_to
+          attr_reader :_from
           attr_reader :_type
 
           def initialize(to, **kwargs, &blk)
@@ -21,8 +22,15 @@ module Dapp
             end
           end
 
+          def from_path(path)
+            sub_directive_eval do
+              @_from = path_format(path)
+              @_type = :custom_dir
+            end
+          end
+
           def validate!
-            raise Error::Config, code: :mount_from_required if _type.nil?
+            raise Error::Config, code: :mount_from_or_from_path_required if _type.nil?
           end
         end
       end

data/lib/dapp/dimg/dapp/command/build_context/export.rb

@@ -20,27 +20,25 @@ module Dapp
                 end.flatten
 
                 log_secondary_process(:images, short: true) do
-                  Image::Docker.save!(context_images_names, build_context_images_tar)
+                  Image::Docker.save!(context_images_names, build_context_images_tar, verbose: true, quiet: log_quiet?)
                 end unless context_images_names.empty?
               end
             end
 
             def export_build_context_build_tar
               log_secondary_process(:build_dir, short: true) do
-                File.open(build_context_build_tar, File::RDWR | File::CREAT) do |f|
-                  Gem::Package::TarWriter.new(f) do |tar|
-                    Dir.glob(File.join(build_path, '**/*'), File::FNM_DOTMATCH).each do |path|
-                      archive_file_path = path
-                                            .reverse
-                                            .chomp(build_path.to_s.reverse)
-                                            .chomp('/')
-                                            .reverse
-                      if File.directory?(path)
-                        tar.mkdir archive_file_path, File.stat(path).mode
-                      else
-                        tar.add_file archive_file_path, File.stat(path).mode do |tf|
-                          tf.write File.read(path)
-                        end
+                tar_write(build_context_build_tar) do |tar|
+                  Dir.glob(File.join(build_path, '**/*'), File::FNM_DOTMATCH).each do |path|
+                    archive_file_path = path
+                                          .reverse
+                                          .chomp(build_path.to_s.reverse)
+                                          .chomp('/')
+                                          .reverse
+                    if File.directory?(path)
+                      tar.mkdir archive_file_path, File.stat(path).mode
+                    else
+                      tar.add_file archive_file_path, File.stat(path).mode do |tf|
+                        tf.write File.read(path)
                       end
                     end
                   end

data/lib/dapp/dimg/dapp/command/build_context/import.rb

@@ -20,7 +20,7 @@ module Dapp
               if build_context_images_tar.exist?
                 log_secondary_process(:images, short: true) do
                   lock("#{name}.images") do
-                    Image::Docker.load!(build_context_images_tar)
+                    Image::Docker.load!(build_context_images_tar, verbose: true, quiet: log_quiet?)
                   end
                 end
               else
@@ -33,8 +33,8 @@ module Dapp
                 log_secondary_process(:build_dir, short: true) do
                   store_current_build_dir
 
-                  File.open(build_context_build_tar, File::RDONLY) do |f|
-                    Gem::Package::TarReader.new(f).each_entry do |entry|
+                  tar_read(build_context_build_tar) do |tar|
+                    tar.each_entry do |entry|
                       header = entry.header
                       path = File.join(build_path, entry.full_name)
 

data/lib/dapp/dimg/dapp/command/cleanup.rb

@@ -9,7 +9,7 @@ module Dapp
                 dapp_containers_flush
                 dapp_dangling_images_flush
                 remove_images_by_query([
-                  'docker images',
+                  "#{host_docker_bin} images",
                   %(--format '{{if ne "#{stage_cache}" .Repository }}{{.Repository}}:{{.Tag}}{{ end }}'),
                   %(-f "label=dapp=#{stage_dapp_label}")
                 ].join(' ')) # FIXME: negative filter is not currently supported by the Docker CLI

data/lib/dapp/dimg/dapp/command/common.rb

@@ -6,19 +6,19 @@ module Dapp
           protected
 
           def dapp_images_names
-            shellout!(%(docker images --format="{{.Repository}}:{{.Tag}}" #{stage_cache})).stdout.lines.map(&:strip)
+            shellout!(%(#{host_docker_bin} images --format="{{.Repository}}:{{.Tag}}" #{stage_cache})).stdout.lines.map(&:strip)
           end
 
           def dapp_images_ids
-            shellout!(%(docker images #{stage_cache} -q --no-trunc)).stdout.lines.map(&:strip)
+            shellout!(%(#{host_docker_bin} images #{stage_cache} -q --no-trunc)).stdout.lines.map(&:strip)
           end
 
           def dapp_containers_flush
-            remove_containers_by_query(%(docker ps -a -f "label=dapp" -f "name=#{container_name_prefix}" -q), force: true)
+            remove_containers_by_query(%(#{host_docker_bin} ps -a -f "label=dapp" -f "name=#{container_name_prefix}" -q), force: true)
           end
 
           def dapp_dangling_images_flush
-            remove_images_by_query(%(docker images -f "dangling=true" -f "label=dapp=#{stage_dapp_label}" -q), force: true)
+            remove_images_by_query(%(#{host_docker_bin} images -f "dangling=true" -f "label=dapp=#{stage_dapp_label}" -q), force: true)
           end
 
           def remove_images_by_query(images_query, force: false)
@@ -26,7 +26,18 @@ module Dapp
           end
 
           def remove_images(ids, force: false)
-            remove_base('docker rmi%{force_option} %{ids}', ids.uniq, force: force)
+            ids.uniq!
+            check_user_containers!(ids) unless force
+            remove_base("#{host_docker_bin} rmi%{force_option} %{ids}", ids, force: force)
+          end
+
+          def check_user_containers!(images_ids)
+            return if images_ids.empty?
+            log_step_with_indent(:'check user containers') do
+              run_command(%(#{host_docker_bin} ps -a -q #{images_ids.uniq.map { |image_id| "--filter=ancestor=#{image_id}" }.join(' ')})).tap do |res|
+                raise Error::Command, code: :user_containers_detected, data: { ids: res.stdout.strip } if !res.stdout.strip.empty? && !dry_run?
+              end
+            end
           end
 
           def remove_containers_by_query(containers_query, force: false)
@@ -34,7 +45,7 @@ module Dapp
           end
 
           def remove_containers(ids, force: false)
-            remove_base('docker rm%{force_option} %{ids}', ids.uniq, force: force)
+            remove_base("#{host_docker_bin} rm%{force_option} %{ids}", ids.uniq, force: force)
           end
 
           def remove_base(query_format, ids, force: false)

data/lib/dapp/dimg/dapp/command/mrproper.rb

@@ -12,6 +12,7 @@ module Dapp
 
               if proper_all?
                 flush_by_label('dapp')
+                remove_build_dir
               elsif proper_dev_mode_cache?
                 flush_by_label('dapp-dev-mode')
               elsif proper_cache_version?
@@ -31,6 +32,10 @@ module Dapp
             log_step_with_indent(:images) { dapp_images_flush_by_label(label) }
           end
 
+          def remove_build_dir
+            log_step_with_indent(:build_dir) { FileUtils.rm_rf(build_path) }
+          end
+
           def proper_all?
             !!options[:proper_all]
           end
@@ -40,11 +45,11 @@ module Dapp
           end
 
           def dapp_containers_flush_by_label(label)
-            remove_containers_by_query(%(docker ps -a -f "label=#{label}" -q), force: true)
+            remove_containers_by_query(%(#{host_docker_bin} ps -a -f "label=#{label}" -q), force: true)
           end
 
           def dapp_dangling_images_flush_by_label(label)
-            remove_images_by_query(%(docker images -f "dangling=true" -f "label=#{label}" -q), force: true)
+            remove_images_by_query(%(#{host_docker_bin} images -f "dangling=true" -f "label=#{label}" -q), force: true)
           end
 
           def dapp_images_flush_by_label(label)
@@ -54,7 +59,7 @@ module Dapp
 
           def dapp_images_by_label(label)
             @dapp_images ||= begin
-              shellout!(%(docker images -f "dangling=false" --format="{{.Repository}}:{{.Tag}}" -f "label=#{label}"))
+              shellout!(%(#{host_docker_bin} images -f "dangling=false" --format="{{.Repository}}:{{.Tag}}" -f "label=#{label}"))
                 .stdout
                 .lines
                 .map(&:strip)
@@ -63,7 +68,7 @@ module Dapp
 
           def proper_cache_all_images
             shellout!([
-              'docker images',
+              "#{host_docker_bin} images",
               '--format="{{.Repository}}:{{.Tag}}"',
               %(-f "label=dapp-cache-version=#{::Dapp::BUILD_CACHE_VERSION}" -f "dangling=false")
             ].join(' ')).stdout.lines.map(&:strip)

data/lib/dapp/dimg/dapp/command/stages/cleanup_local.rb

@@ -4,15 +4,15 @@ module Dapp
       module Command
         module Stages
           module CleanupLocal
-            def stages_cleanup_local(repo)
-              lock_repo(repo, readonly: true) do
+            def stages_cleanup_local
+              lock_repo(option_repo, readonly: true) do
                 raise Error::Command, code: :stages_cleanup_required_option unless stages_cleanup_option?
 
                 dapp_containers_flush
 
-                proper_cache                 if proper_cache_version?
-                stages_cleanup_by_repo(repo) if proper_repo_cache?
-                proper_git_commit            if proper_git_commit?
+                proper_cache           if proper_cache_version?
+                stages_cleanup_by_repo if proper_repo_cache?
+                proper_git_commit      if proper_git_commit?
               end
             end
 
@@ -28,8 +28,8 @@ module Dapp
               end
             end
 
-            def stages_cleanup_by_repo(repo)
-              registry = registry(repo)
+            def stages_cleanup_by_repo
+              registry = registry(option_repo)
               repo_dimgs = repo_dimgs_images(registry)
 
               lock("#{name}.images") do
@@ -49,16 +49,18 @@ module Dapp
             end
 
             def actual_cache_images
-              shellout!([
-                'docker images',
-                '--format="{{.Repository}}:{{.Tag}}"',
-                %(-f "label=dapp-cache-version=#{::Dapp::BUILD_CACHE_VERSION}"),
-                stage_cache
-              ].join(' ')).stdout.lines.map(&:strip)
+              @actual_cache_images ||= begin
+                shellout!([
+                  "#{host_docker_bin} images",
+                  '--format="{{.Repository}}:{{.Tag}}"',
+                  %(-f "label=dapp-cache-version=#{::Dapp::BUILD_CACHE_VERSION}"),
+                  stage_cache
+                ].join(' ')).stdout.lines.map(&:strip)
+              end
             end
 
             def dapp_images_hash
-              shellout!(%(docker images --format "{{.Repository}}:{{.Tag}};{{.ID}}" --no-trunc #{stage_cache})).stdout.lines.map do |line|
+              shellout!(%(#{host_docker_bin} images --format "{{.Repository}}:{{.Tag}};{{.ID}}" --no-trunc #{stage_cache})).stdout.lines.map do |line|
                 line.strip.split(';')
               end.to_h
             end
@@ -77,7 +79,7 @@ module Dapp
             end
 
             def image_exist?(image_id)
-              shellout!(%(docker inspect #{image_id}))
+              shellout!(%(#{host_docker_bin} inspect #{image_id}))
               true
             rescue ::Dapp::Error::Shellout
               false
@@ -88,7 +90,7 @@ module Dapp
             end
 
             def image_parent(image_id)
-              shellout!(%(docker inspect -f {{.Parent}} #{image_id})).stdout.strip
+              shellout!(%(#{host_docker_bin} inspect -f {{.Parent}} #{image_id})).stdout.strip
             end
 
             def proper_git_commit
@@ -107,7 +109,7 @@ module Dapp
             def dapp_images_detailed
               @dapp_images_detailed ||= {}.tap do |images|
                 dapp_images_names.each do |image_name|
-                  shellout!(%(docker inspect --format='{{json .}}' #{image_name})).stdout.strip.tap do |output|
+                  shellout!(%(#{host_docker_bin} inspect --format='{{json .}}' #{image_name})).stdout.strip.tap do |output|
                     images[image_name] = output == 'null' ? {} : JSON.parse(output)
                   end
                 end

data/lib/dapp/dimg/dapp/command/stages/cleanup_repo.rb

@@ -112,7 +112,7 @@ module Dapp
 
             def remove_repo_images(registry, tags)
               tags.each do |tag|
-                log(tag) if dry_run? || log_verbose?
+                log(tag) if log_verbose? || dry_run?
                 registry.image_delete(tag) unless dry_run?
               end
             end

data/lib/dapp/dimg/dimg.rb

@@ -122,7 +122,7 @@ module Dapp
       end
 
       def run(docker_options, command)
-        cmd = "docker run #{[docker_options, last_stage.image.built_id, command].flatten.compact.join(' ')}"
+        cmd = "#{dapp.host_docker_bin} run #{[docker_options, last_stage.image.built_id, command].flatten.compact.join(' ')}"
         if dapp.dry_run?
           dapp.log(cmd)
         else
@@ -159,7 +159,7 @@ module Dapp
       end
 
       def introspect_image!(image:, options:)
-        cmd = "docker run -ti --rm --entrypoint #{dapp.bash_bin} #{options} #{image}"
+        cmd = "#{dapp.host_docker_bin} run -ti --rm --entrypoint #{dapp.bash_bin} #{options} #{image}"
         system(cmd)
       end
 
@@ -169,9 +169,9 @@ module Dapp
         # Чтобы от них избавиться — запускаем docker-контейнер под root-пользователем
         # и удаляем примонтированную tmp-директорию.
         cmd = "".tap do |cmd|
-          cmd << "docker run --rm"
-          cmd << " --volume #{tmp_base_dir}:#{tmp_base_dir}"
-          cmd << " ubuntu:16.04"
+          cmd << "#{dapp.host_docker_bin} run --rm"
+          cmd << " --volume #{dapp.tmp_base_dir}:#{dapp.tmp_base_dir}"
+          cmd << " alpine:3.6"
           cmd << " rm -rf #{tmp_path}"
         end
         dapp.shellout! cmd

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

@@ -7,17 +7,22 @@ module Dapp
         end
 
         def local_git_artifacts
-          @local_git_artifact_list ||= Array(config._git_artifact._local).map do |ga_config|
+          @local_git_artifact_list ||= begin
             repo = GitRepo::Own.new(self)
-            ::Dapp::Dimg::GitArtifact.new(repo, **ga_config._artifact_options)
+            Array(config._git_artifact._local).map do |ga_config|
+              ::Dapp::Dimg::GitArtifact.new(repo, **ga_config._artifact_options)
+            end
           end
         end
 
         def remote_git_artifacts
-          @remote_git_artifact_list ||= Array(config._git_artifact._remote).map do |ga_config|
-            repo = GitRepo::Remote.new(self, ga_config._name, url: ga_config._url)
-            repo.fetch!(ga_config._branch)
-            ::Dapp::Dimg::GitArtifact.new(repo, **ga_config._artifact_options)
+          @remote_git_artifact_list ||= begin
+            repos = {}
+            Array(config._git_artifact._remote).map do |ga_config|
+              repo_key = [ga_config._url, ga_config._branch]
+              repos[repo_key] ||= GitRepo::Remote.new(self, ga_config._name, url: ga_config._url).tap { |repo| repo.fetch!(ga_config._branch) }
+              ::Dapp::Dimg::GitArtifact.new(repos[repo_key], **ga_config._artifact_options)
+            end
           end
         end
       end # GitArtifact

data/lib/dapp/dimg/dimg/path.rb

@@ -6,17 +6,13 @@ module Dapp
           dapp.path(*path).expand_path
         end
 
-        def tmp_base_dir
-          File.expand_path(dapp.options[:tmp_dir_prefix] || '/tmp')
-        end
-
         def tmp_path(*path)
-          @tmp_path ||= Dir.mktmpdir('dapp-', tmp_base_dir)
+          @tmp_path ||= Dir.mktmpdir('dapp-', dapp.tmp_base_dir)
           make_path(@tmp_path, *path).expand_path.tap { |p| p.parent.mkpath }
         end
 
         def build_path(*path)
-          make_path(dapp.build_path, *path).expand_path.tap { |p| p.parent.mkpath }
+          dapp.build_path(*path).expand_path.tap { |p| p.parent.mkpath }
         end
 
         def container_dapp_path(*path)

data/lib/dapp/dimg/git_artifact.rb

@@ -2,6 +2,8 @@ module Dapp
   module Dimg
     # Git repo artifact
     class GitArtifact
+      include Helper::Tar
+
       attr_reader :repo
       attr_reader :name
 
@@ -31,45 +33,61 @@ module Dapp
 
         [].tap do |commands|
           commands << "#{repo.dimg.dapp.install_bin} #{credentials.join(' ')} -d #{to}"
-          if any_changes?(nil, stage.layer_commit(self))
-            commands << "#{sudo}#{repo.dimg.dapp.tar_bin} -xf #{archive_file(stage.layer_commit(self))} -C #{to}"
+          if archive_any_changes?(stage)
+            commands << "#{sudo}#{repo.dimg.dapp.tar_bin} -xf #{archive_file(*archive_stage_commits(stage))} -C #{to}"
           end
         end
       end
 
       def apply_patch_command(stage)
-        patch_command(stage.prev_g_a_stage.layer_commit(self), stage.layer_commit(self))
-      end
-
-      def apply_dev_patch_command(stage)
-        patch_command(stage.prev_g_a_stage.layer_commit(self), nil)
+        [].tap do |commands|
+          if dev_mode?
+            if any_changes?(*dev_patch_stage_commits(stage))
+              changed_files = diff_patches(*dev_patch_stage_commits(stage)).map {|p| File.join(to, cwd, p.delta.new_file[:path])}
+              commands << "#{sudo}#{repo.dimg.dapp.rm_bin} -rf #{changed_files.join(' ')}"
+              commands << "#{sudo}#{repo.dimg.dapp.tar_bin} -xf #{archive_file(*dev_patch_stage_commits(stage))} -C #{to}"
+            end
+          else
+            if patch_any_changes?(stage)
+              commands << "#{sudo}#{repo.dimg.dapp.git_bin} apply --whitespace=nowarn --directory=#{to} --unsafe-paths #{patch_file(*patch_stage_commits(stage))}"
+            end
+          end
+        end
       end
 
       def stage_dependencies_checksum(stage)
         return [] if (stage_dependencies = stages_dependencies[stage.name]).empty?
 
         paths = (include_paths(true) + base_paths(stage_dependencies, true)).uniq
+        to_commit = dev_mode? ? nil : latest_commit
 
-        to_commit = if repo.is_a? GitRepo::Own and repo.dimg.dev_mode?
-          nil
-        else
-          latest_commit
-        end
+        stage_dependencies_key = [stage.name, to_commit]
+        @stage_dependencies_checksums ||= {}
+        @stage_dependencies_checksums[stage_dependencies_key] = begin
+          if @stage_dependencies_checksums.key?(stage_dependencies_key)
+            @stage_dependencies_checksums[stage_dependencies_key]
+          else
+            if (patches = diff_patches(nil, to_commit, paths: paths)).empty?
+              repo.dimg.dapp.log_warning(desc: { code: :stage_dependencies_not_found,
+                                                 data: { repo: repo.respond_to?(:url) ? repo.url : 'local',
+                                                         dependencies: stage_dependencies.join(', ') } })
+            end
 
-        diff_patches(nil, to_commit, paths: paths)
-          .sort_by {|patch| patch.delta.new_file[:path]}
-          .reduce(nil) {|prev_hash, patch|
-            Digest::SHA256.hexdigest [
-              prev_hash,
-              patch.delta.new_file[:path],
-              patch.delta.new_file[:mode].to_s,
-              patch.to_s
-            ].compact.join(':::')
-          }
+            patches.sort_by {|patch| patch.delta.new_file[:path]}
+              .reduce(nil) {|prev_hash, patch|
+              Digest::SHA256.hexdigest [
+                prev_hash,
+                patch.delta.new_file[:path],
+                patch.delta.new_file[:mode].to_s,
+                patch.to_s
+              ].compact.join(':::')
+            }
+          end
+        end
       end
 
-      def patch_size(from, to)
-        diff_patches(from, to).reduce(0) do |bytes, patch|
+      def patch_size(from_commit, to_commit)
+        diff_patches(from_commit, to_commit).reduce(0) do |bytes, patch|
           patch.hunks.each do |hunk|
             hunk.lines.each do |l|
               bytes +=
@@ -85,8 +103,13 @@ module Dapp
         end
       end
 
-      def dev_patch_hash(stage)
-        Digest::SHA256.hexdigest diff_patches(stage.prev_g_a_stage.layer_commit(self), nil).map(&:to_s).join(':::')
+      def dev_patch_hash
+        return unless dev_mode?
+
+        Digest::SHA256.hexdigest(diff_patches(latest_commit, nil).map do |patch|
+          next unless (path = repo.path.dirname.join(patch.delta.new_file[:path])).file?
+          File.read(path)
+        end.join(':::'))
       end
 
       def latest_commit
@@ -101,8 +124,12 @@ module Dapp
         "#{repo.name}#{name ? "_#{name}" : nil}"
       end
 
-      def any_changes?(from, to = latest_commit)
-        diff_patches(from, to).any?
+      def archive_any_changes?(stage)
+        any_changes?(*archive_stage_commits(stage))
+      end
+
+      def patch_any_changes?(stage)
+        any_changes?(*patch_stage_commits(stage))
       end
 
       protected
@@ -115,35 +142,34 @@ module Dapp
       attr_reader :group
       attr_reader :stages_dependencies
 
-      def patch_command(prev_commit, current_commit)
-        [].tap do |commands|
-          if any_changes?(prev_commit, current_commit)
-            commands << "#{sudo}#{repo.dimg.dapp.git_bin} apply --whitespace=nowarn --directory=#{to} --unsafe-paths " \
-                        "#{patch_file(prev_commit, current_commit)}"
-          end
-        end
-      end
-
       def sudo
         repo.dimg.dapp.sudo_command(owner: owner, group: group)
       end
 
-      def archive_file(to_commit)
-        create_file(repo.dimg.tmp_path('archives', archive_file_name(to_commit))) do |f|
-          Gem::Package::TarWriter.new(f) do |tar|
-            diff_patches(nil, to_commit).each do |patch|
-              entry = patch.delta.new_file
-              if entry[:mode] == 40960 # symlink
-                tar.add_symlink slice_cwd(entry[:path]), repo.lookup_object(entry[:oid]).content, entry[:mode]
+      def archive_file(from_commit, to_commit)
+        tar_write(repo.dimg.tmp_path('archives', archive_file_name(from_commit, to_commit))) do |tar|
+          diff_patches(from_commit, to_commit).each do |patch|
+            entry = patch.delta.new_file
+
+            content = begin
+              if to_commit == nil
+                next unless (path = repo.path.dirname.join(entry[:path])).file?
+                File.read(path)
               else
-                tar.add_file slice_cwd(entry[:path]), entry[:mode] do |tf|
-                  tf.write repo.lookup_object(entry[:oid]).content
-                end
+                repo.lookup_object(entry[:oid]).content
+              end
+            end
+
+            if entry[:mode] == 40960 # symlink
+              tar.add_symlink slice_cwd(entry[:path]), content, entry[:mode]
+            else
+              tar.add_file slice_cwd(entry[:path]), entry[:mode] do |tf|
+                tf.write content
               end
             end
           end
         end
-        repo.dimg.container_tmp_path('archives', archive_file_name(to_commit))
+        repo.dimg.container_tmp_path('archives', archive_file_name(from_commit, to_commit))
       rescue Gem::Package::TooLongFileName => e
         raise Error::TarWriter, message: e.message
       end
@@ -156,15 +182,15 @@ module Dapp
           .reverse
       end
 
-      def archive_file_name(commit)
-        file_name(commit, 'tar')
+      def archive_file_name(from_commit, to_commit)
+        file_name(from_commit, to_commit, 'tar')
       end
 
-      def patch_file(from, to)
-        create_file(repo.dimg.tmp_path('patches', patch_file_name(from, to))) do |f|
-          diff_patches(from, to).each { |patch| f.write change_patch_new_file_path(patch) }
+      def patch_file(from_commit, to_commit)
+        File.open(repo.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(patch) }
         end
-        repo.dimg.container_tmp_path('patches', patch_file_name(from, to))
+        repo.dimg.container_tmp_path('patches', patch_file_name(from_commit, to_commit))
       end
 
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -209,23 +235,25 @@ module Dapp
         patch.delta.old_file[:mode] != patch.delta.new_file[:mode]
       end
 
-      def patch_file_name(from, to)
-        file_name(from, to, 'patch')
+      def patch_file_name(from_commit, to_commit)
+        file_name(from_commit, to_commit, 'patch')
       end
 
       def file_name(*args, ext)
-        "#{[full_name, args].flatten.join('_')}.#{ext}"
+        "#{[paramshash, args].flatten.compact.join('_')}.#{ext}"
       end
 
-      def create_file(file_path, &blk)
-        File.open(file_path, File::RDWR | File::CREAT, &blk)
-      end
-
-      def diff_patches(from, to, paths: include_paths_or_cwd)
-        (@diff_patches ||= {})[[from, to, paths]] ||= repo.patches(from, to,
-                                                                   paths: paths,
-                                                                   exclude_paths: exclude_paths(true),
-                                                                   force_text: true)
+      def diff_patches(from_commit, to_commit, paths: include_paths_or_cwd)
+        (@diff_patches ||= {})[[from_commit, to_commit, paths]] ||= begin
+          options = {}.tap do |opts|
+            opts[:force_text] = true
+            if dev_mode?
+              opts[:include_untracked] = true
+              opts[:recurse_untracked_dirs] = true
+            end
+          end
+          repo.patches(from_commit, to_commit, paths: paths, exclude_paths: exclude_paths(true), **options)
+        end
       end
 
       def include_paths_or_cwd
@@ -257,6 +285,30 @@ module Dapp
             .reverse
         end
       end
+
+      def archive_stage_commits(stage)
+        [nil, stage.layer_commit(self)]
+      end
+
+      def patch_stage_commits(stage)
+        [stage.prev_g_a_stage.layer_commit(self), stage.layer_commit(self)]
+      end
+
+      def dev_patch_stage_commits(stage)
+        [stage.prev_g_a_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? && repo.dimg.dev_mode?
+      end
+
+      def local?
+        repo.is_a? GitRepo::Own
+      end
     end
   end
 end