dapp 0.23.10 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 949df785aff321e34eb685421d3c7c0b396bc62b
-  data.tar.gz: 85336f30a665901ee3c716a9d53512112e58426e
+  metadata.gz: 0a3eb814504194a1734b9bab5b11a53763eef1b7
+  data.tar.gz: 66666ebe9a2afbb29b34345e8183dbdd855ff787
 SHA512:
-  metadata.gz: bcb935ad210325c03aa642906adbd970beef82a2e30c3e0d3ccf14e7a60e0b219fe98e141fa28204421b26fafe270dd16ba207073d60fdff5f4cf6fe1a30b437
-  data.tar.gz: 7f199a77a71b6096989ad44431c1e1e900f7155d1a3840f0fc39eb781b3a2e8cc3e0300c12878efb2df04a42b284b8150daabfdebb28c739a7e49370928dcedf
+  metadata.gz: 0ab24da89ae14385765f1d8424fad856113fbd54ab978f1bc71d7a67b281d9def44e333e3955042bb29f85b469043bb54eea90f0154ced45e4177a74c7001e44
+  data.tar.gz: e3cd721f5989eca155057cb56a16ff396ad7b11ce5b28896fb16e812cf2cbda8cf9108ff98b9920dfedd3f62691c9d64fa91836adab72290634311f6392c4c14

data/bin/dapp

@@ -28,10 +28,6 @@ begin
       $stderr.puts "\033[1m\033[90mStacktrace dumped to #{filename}\033[0m"
     end
 
-    if Dapp::CLI.dapp_object
-      Dapp::CLI.dapp_object.sentry_exception(e)
-    end
-
     raise
   end
 rescue Dapp::Error::Shellout => e

data/config/en/net_status.yml

@@ -80,7 +80,7 @@ en:
       stage_artifact_double_associate: "Can't use `%{stage}` stage for artifact; already used in `%{conflict_stage}` stage!"
       stage_artifact_not_supported_associated_stage: "Bad artifact stage `%{stage}`!"
       git_artifact_remote_branch_with_commit: "Remote git repo: use `commit` or `branch` directive!"
-      artifact_conflict: "Conflict between artifacts!\n\n%{dappfile_context}"
+      artifact_conflict: "Conflict between artifacts paths!"
       scratch_unsupported_directive: "Scratch dimg has unsupported directive `%{directive}`!"
       scratch_artifact_required: "Scratch dimg without artifacts!"
       scratch_artifact_associated: "Scratch artifact can't be associated: not expected `before`/`after` attribute!"
@@ -120,7 +120,9 @@ en:
       commit_not_found_in_remote_git_repository: "Remote git repo `%{url}`: commit `%{commit}` not found!\nIf commit has been rebased: run command `dapp dimg stages cleanup local --improper-git-commit`!"
       branch_not_exist_in_remote_git_repository: "Remote git repo `%{url}`: branch `%{branch}` not exist!"
       rugged_protocol_not_supported: "Rugged has been compiled without support for `%{protocol}`.\nGit repositories will not be reachable via `%{protocol}` (`%{url}`).\nRugged.features should include `%{protocol}`."
-      submodule_not_supported: "Git submodules not supported! (`%{path}`)"
+      incorrect_gitmodules_file: "Local git repo with invalid `.gitmodules` file: `%{error}`."
+      git_repository_without_remote_url: "Git repo `%{name}`: remote url cannot be detected!\nYou should check `remote origin url` in `%{path}` repository."
+      git_repository_not_found: "Git repository `%{path}` not found!\nYou should check `remote origin url` in `%{parent_git_path}` repository."
     lock:
       timeout: "Could not obtain lock for `%{name}` within %{timeout} seconds!"
     app:

data/lib/dapp.rb

@@ -26,8 +26,6 @@ require 'zlib'
 require 'slugify'
 require 'base64'
 require 'io/console'
-require 'sentry-raven'
-require 'toml-rb'
 
 require 'dapp/version'
 require 'dapp/core_ext/hash'
@@ -38,7 +36,6 @@ require 'dapp/helper/sha256'
 require 'dapp/helper/net_status'
 require 'dapp/helper/tar'
 require 'dapp/helper/yaml'
-require 'dapp/helper/url'
 require 'dapp/prctl'
 require 'dapp/error/mod/user'
 require 'dapp/error/base'
@@ -59,7 +56,6 @@ require 'dapp/config/directive/base'
 require 'dapp/config/config'
 require 'dapp/dapp/lock'
 require 'dapp/dapp/ssh_agent'
-require 'dapp/dapp/sentry'
 require 'dapp/dapp/git_artifact'
 require 'dapp/dapp/dappfile'
 require 'dapp/dapp/chef'

data/lib/dapp/cli.rb

@@ -38,10 +38,6 @@ BANNER
            show_options: true,
            exit: 0
 
-    class << self
-      attr_accessor :dapp_object
-    end
-
     def initialize(*args)
       super(*args)
 

data/lib/dapp/cli/command/base.rb

@@ -58,8 +58,6 @@ module Dapp
 
         def run_dapp_command(run_method, options: {}, log_running_time: true, try_host_docker_login: false)
           dapp = ::Dapp::Dapp.new(options: options)
-          ::Dapp::CLI.dapp_object = dapp
-          dapp.sentry_message("Manual usage: `#{options[:dapp_command]}` command") unless ENV['CI']
 
           log_dapp_running_time(dapp, ignore: !log_running_time) do
             begin
@@ -76,10 +74,6 @@ module Dapp
           end
         end
 
-        def run_method
-          class_to_lowercase
-        end
-
         def log_dapp_running_time(dapp, ignore: false)
           return yield if ignore
 
@@ -101,7 +95,7 @@ module Dapp
             self.class.print_error_with_help_and_die! self, "cannot use alias options --run-dir, --build-dir, --deploy-dir at the same time"
           end
 
-          config.merge(build_dir: dirs.compact.first, dapp_command: run_method, **kwargs)
+          config.merge(build_dir: dirs.compact.first, **kwargs)
         end
       end
     end

data/lib/dapp/dapp.rb

@@ -17,13 +17,10 @@ module Dapp
     include Logging::Paint
 
     include SshAgent
-    include Sentry
-
     include Helper::Sha256
-    extend  Helper::Trivia
+    extend Helper::Trivia
     include Helper::Trivia
     include Helper::Tar
-    include Helper::Url
 
     include Deps::Toolchain
     include Deps::Gitartifact
@@ -44,29 +41,19 @@ module Dapp
       self.class.options
     end
 
-    def settings
-      @settings ||= begin
-        settings_path = File.join(self.class.home_dir, "settings.toml")
-
-        if File.exists? settings_path
-          TomlRB.load_file(settings_path)
-        else
-          {}
-        end
-      end
-    end
-
     def name
       @name ||= begin
         n = begin
           if (name = options[:name])
             name
-          elsif git_url
-            repo_name = git_url.split('/').last
-            repo_name = repo_name[/.*(?=\.git)/] if repo_name.end_with? '.git'
-            repo_name
-          elsif git_path
-            File.basename(File.dirname(git_path)).to_s
+          elsif git_own_repo_exist?
+            if git_url
+              repo_name = git_url.split('/').last
+              repo_name = repo_name[/.*(?=\.git)/] if repo_name.end_with? '.git'
+              repo_name
+            else
+              File.basename(File.dirname(git_own_repo.path)).to_s
+            end
           else
             path.basename.to_s
           end
@@ -76,20 +63,19 @@ module Dapp
     end
 
     def git_url
-      return unless git_config
-      (git_config['remote "origin"'] || {})['url']
+      return unless git_own_repo_exist?
+      git_own_repo.remote_origin_url
+    rescue Dimg::Error::Rugged => e
+      return if e.net_status[:code] == :git_repository_without_remote_url
+      raise
     end
 
-    def git_config
-      @git_config ||= begin
-        IniFile.load(File.join(git_path, 'config')) if git_path
-      end
+    def git_own_repo_exist?
+      git_own_repo.exist?
     end
 
-    def git_path
-      defined?(@git_path) ? @git_path : begin
-        @git_path = search_file_upward('.git')
-      end
+    def git_own_repo
+      @git_own_repo ||= Dimg::GitRepo::Own.new(self)
     end
 
     def path(*path)
@@ -101,8 +87,8 @@ module Dapp
       self.class.tmp_base_dir
     end
 
-    def build_dir
-      @build_dir ||= begin
+    def build_path(*path)
+      @build_path ||= begin
         if option_build_dir
           Pathname.new(option_build_dir)
         else
@@ -110,15 +96,12 @@ module Dapp
           Pathname.new(dir)
         end.expand_path.tap(&:mkpath)
       end
-    end
-
-    def build_path(*path)
-      make_path(build_dir, *path)
+      make_path(@build_path, *path)
     end
 
     def local_git_artifact_exclude_paths(&blk)
       super do |exclude_paths|
-        build_path_relpath = Pathname.new(build_path).subpath_of(File.dirname(git_path))
+        build_path_relpath = Pathname.new(build_path).subpath_of(File.dirname(git_own_repo.path))
         exclude_paths << build_path_relpath.to_s if build_path_relpath
 
         yield exclude_paths if block_given?

data/lib/dapp/dapp/option_tags.rb

@@ -1,22 +1,12 @@
 module Dapp
   class Dapp
     module OptionTags
-      def git_local_repo
-        @git_repo ||= ::Dapp::Dimg::GitRepo::Own.new(self)
-      end
-
       def tagging_schemes
         %w(git_tag git_branch git_commit custom ci)
       end
 
       def tags_by_scheme
         @tags_by_scheme_name ||= begin
-          if simple_tags[:custom].any?
-            if settings.fetch("sentry", {}).fetch("detect-push-tag-usage", false)
-              sentry_message("--tag or --tag-slug usage detected", extra: {"slug_tags" => simple_tags})
-            end
-          end
-
           [simple_tags, branch_tags, commit_tags, build_tags, ci_tags].reduce({}) do |some_tags_by_scheme, tags_by_scheme|
             tags_by_scheme.in_depth_merge(some_tags_by_scheme)
           end.tap do |tags_by_scheme|
@@ -38,13 +28,13 @@ module Dapp
 
       def branch_tags
         return {} unless options[:tag_branch]
-        raise Error::Dapp, code: :git_branch_without_name if (branch = git_local_repo.branch) == 'HEAD'
+        raise Error::Dapp, code: :git_branch_without_name if (branch = git_own_repo.branch) == 'HEAD'
         { git_branch: [branch] }
       end
 
       def commit_tags
         return {} unless options[:tag_commit]
-        { git_commit: [git_local_repo.latest_commit] }
+        { git_commit: [git_own_repo.latest_commit] }
       end
 
       def build_tags

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

@@ -32,7 +32,7 @@ module Dapp
           def safe_cp(from, to, owner, group, include_paths = [], exclude_paths = [])
             ''.tap do |cmd|
               cmd << dimg.dapp.rsync_bin
-              cmd << ' --archive --links --inplace'
+              cmd << ' --archive --links'
               cmd << " --chown=#{owner}:#{group}" if owner or group
 
               if include_paths.any?

data/lib/dapp/dimg/builder/chef/cookbook.rb

@@ -87,7 +87,7 @@ module Dapp
             "#{builder.dimg.dapp.mkdir_bin} -p ~/.ssh",
             'echo "Host *" >> ~/.ssh/config',
             'echo "    StrictHostKeyChecking no" >> ~/.ssh/config',
-            *local_paths.map {|path| "#{builder.dimg.dapp.rsync_bin} --inplace --archive --relative #{path} /tmp/local_cookbooks"},
+            *local_paths.map {|path| "#{builder.dimg.dapp.rsync_bin} --archive --relative #{path} /tmp/local_cookbooks"},
             "cd /tmp/local_cookbooks/#{path}",
             "cp #{tmp_berksfile_path} Berksfile",
             "cp #{tmp_metadata_path} metadata.rb",

data/lib/dapp/dimg/cli/command/base.rb

@@ -9,6 +9,10 @@ module Dapp::Dimg::CLI
         self.class.parse_options(self, argv)
         run_dapp_command(run_method, options: cli_options(dimgs_patterns: cli_arguments))
       end
+
+      def run_method
+        class_to_lowercase
+      end
     end
   end
 end

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

@@ -5,6 +5,13 @@ module Dapp
         class ArtifactDimg < Dimg
           def validate_scratch!
           end
+
+          def validate_artifacts_artifacts!
+          end
+
+          def validated_artifacts
+            _git_artifact._local + _git_artifact._remote
+          end
         end
       end
     end

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

@@ -136,7 +136,6 @@ module Dapp
 
             def artifacts_after_parsing!
               _artifacts_auto_excluding!
-              _artifact.map(&:_config).each(&:artifacts_after_parsing!)
             end
 
             protected

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

@@ -4,8 +4,6 @@ module Dapp
       module Directive
         class Dimg < Base
           module Validation
-            include Helper::Trivia
-
             def validate!
               directives_validate!
               validate_scratch!
@@ -73,39 +71,12 @@ module Dapp
                 verifiable_artifact = artifacts.shift
                 artifacts.select { |a| a[:to] == verifiable_artifact[:to] }.each do |artifact|
                   next if verifiable_artifact[:index] == artifact[:index]
-                  begin
-                    validate_artifact!(verifiable_artifact, artifact)
-                    validate_artifact!(artifact, verifiable_artifact)
-                  rescue ::Dapp::Error::Config => e
-                    conflict_between_artifacts!(artifact, verifiable_artifact) if e.net_status[:code] == :artifact_conflict
-                    raise
-                  end
+                  validate_artifact!(verifiable_artifact, artifact)
+                  validate_artifact!(artifact, verifiable_artifact)
                 end
               end
             end
 
-            def conflict_between_artifacts!(*formatted_artifacts)
-              artifacts = formatted_artifacts.flatten.map { |formatted_artifact| formatted_artifact[:related_artifact] }
-              dappfile_context = artifacts.map do |artifact|
-                artifact_directive = []
-                artifact_directive << begin
-                  if artifact.is_a? Artifact::Export
-                    "artifact.export('#{artifact._cwd}') do"
-                  else
-                    "git#{"('#{artifact._url}')" if artifact.respond_to?(:_url)}.add('#{artifact._cwd}') do"
-                  end
-                end
-                [:include_paths, :exclude_paths].each do |directive|
-                  next if (paths = artifact.send("_#{directive}")).empty?
-                  artifact_directive << "  #{directive} '#{paths.join("', '")}'"
-                end
-                artifact_directive << "  to '#{artifact._to}'"
-                artifact_directive << 'end'
-                artifact_directive.join("\n")
-              end.join("\n\n")
-              raise ::Dapp::Error::Config, code: :artifact_conflict, data: { dappfile_context: dappfile_context }
-            end
-
             def validate_artifact_format(artifacts)
               artifacts.map do |a|
                 path_format = proc { |path| File.expand_path(File.join('/', path, '/'))[1..-1] }
@@ -133,20 +104,26 @@ module Dapp
                   index: artifacts.index(a),
                   to: to,
                   include_paths: include_paths,
-                  exclude_paths: exclude_paths,
-                  related_artifact: a
+                  exclude_paths: exclude_paths
                 }
               end
             end
 
             def validate_artifact!(verifiable_artifact, artifact)
-              cases = []
-              cases << verifiable_artifact[:include_paths].any? do |verifiable_path|
-                !ignore_path?(verifiable_path, paths: artifact[:include_paths], exclude_paths: artifact[:exclude_paths])
-              end
-              cases << (verifiable_artifact[:include_paths].empty? && artifact[:include_paths].empty?)
+              verifiable_artifact[:include_paths].each do |verifiable_path|
+                potential_conflicts = artifact[:include_paths].select { |path| path.start_with?(verifiable_path) }
+                validate_artifact_path!(verifiable_artifact, potential_conflicts)
+              end.empty? && verifiable_artifact[:exclude_paths].empty? && raise(::Dapp::Error::Config, code: :artifact_conflict)
+              validate_artifact_path!(verifiable_artifact, artifact[:include_paths]) if verifiable_artifact[:include_paths].empty?
+            end
 
-              raise ::Dapp::Error::Config, code: :artifact_conflict if cases.any?
+            def validate_artifact_path!(verifiable_artifact, potential_conflicts)
+              potential_conflicts.all? do |path|
+                loop do
+                  break if verifiable_artifact[:exclude_paths].include?(path) || ((path = File.dirname(path)) == '.')
+                end
+                verifiable_artifact[:exclude_paths].include?(path)
+              end.tap { |res| res || raise(::Dapp::Error::Config, code: :artifact_conflict) }
             end
 
             def _associated_artifacts

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

@@ -3,23 +3,24 @@ module Dapp
     module Config
       module Directive
         class GitArtifactRemote < GitArtifactLocal
-          include ::Dapp::Helper::Url
-
           attr_reader :_url, :_name, :_branch, :_commit
 
           def initialize(url, **kwargs, &blk)
             @_url  = url
-            @_name = git_url_to_name(url)
+
+            url_without_scheme = url.split("://", 2).last
+            url_without_creds = url_without_scheme.split(":", 2).last
+            @_name = url_without_creds.gsub(%r{.*?([^\/ ]+\/[^\/ ]+)\.git}, '\\1')
 
             super(**kwargs, &blk)
           end
 
           def branch(value)
-            sub_directive_eval { @_branch = value.to_s }
+            sub_directive_eval { @_branch = value }
           end
 
           def commit(value)
-            sub_directive_eval { @_commit = value.to_s }
+            sub_directive_eval { @_commit = value }
           end
 
           def _export
@@ -37,15 +38,15 @@ module Dapp
             attr_accessor :_url, :_name, :_branch, :_commit
 
             def _artifact_options
-              super.merge(name: _name, branch: _branch, commit: _commit)
+              super.merge(name: _name, branch: _branch.to_s, commit: _commit.to_s)
             end
 
             def branch(value)
-              sub_directive_eval { @_branch = value.to_s }
+              sub_directive_eval { @_branch = value }
             end
 
             def commit(value)
-              sub_directive_eval { @_commit = value.to_s }
+              sub_directive_eval { @_commit = value }
             end
 
             def validate!

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

@@ -11,8 +11,10 @@ module Dapp
               log_step_with_indent(repo) do
                 registry = dimg_registry(repo)
 
-                cleanup_repo_by_nonexistent_git_primitive(registry, actual_detailed_dimgs_images_by_scheme(registry))
-                cleanup_repo_by_policies(registry, actual_detailed_dimgs_images_by_scheme(registry))
+                if git_own_repo_exist?
+                  cleanup_repo_by_nonexistent_git_primitive(registry, actual_detailed_dimgs_images_by_scheme(registry))
+                  cleanup_repo_by_policies(registry, actual_detailed_dimgs_images_by_scheme(registry))
+                end
 
                 begin
                   repo_dimgs      = repo_dimgs_images(registry)
@@ -46,7 +48,7 @@ module Dapp
                   case scheme
                     when 'git_tag'    then consistent_git_tags.include?(detailed_dimg_image[:tag])
                     when 'git_branch' then consistent_git_remote_branches.include?(detailed_dimg_image[:tag])
-                    when 'git_commit' then git_local_repo.commit_exists?(detailed_dimg_image[:tag])
+                    when 'git_commit' then git_own_repo.commit_exists?(detailed_dimg_image[:tag])
                     else
                       raise
                   end
@@ -60,7 +62,7 @@ module Dapp
           end
 
           def consistent_git_remote_branches
-            @consistent_git_remote_branches ||= git_local_repo.remote_branches.map(&method(:consistent_uniq_slugify))
+            @consistent_git_remote_branches ||= git_own_repo.remote_branches.map(&method(:consistent_uniq_slugify))
           end
 
           def cleanup_repo_by_nonexistent_git_base(repo_dimgs_images_by_scheme, dapp_tag_scheme)
@@ -80,15 +82,15 @@ module Dapp
                     if scheme == 'git_tag'
                       !consistent_git_tags.include?(dimg[:tag])
                     elsif scheme == 'git_commit'
-                      !git_local_repo.commit_exists?(dimg[:tag])
+                      !git_own_repo.commit_exists?(dimg[:tag])
                     end
                   end
 
                   dimg[:created_at] = begin
                     if scheme == 'git_tag'
-                      git_local_repo.tag_at(git_tag_by_consistent_git_tag(dimg[:tag]))
+                      git_own_repo.tag_at(git_tag_by_consistent_git_tag(dimg[:tag]))
                     elsif scheme == 'git_commit'
-                      git_local_repo.commit_at(dimg[:tag])
+                      git_own_repo.commit_at(dimg[:tag])
                     end
                   end
                   dimg
@@ -120,7 +122,7 @@ module Dapp
           end
 
           def git_tag_by_consistent_tag_name
-            @git_consistent_tags ||= git_local_repo.tags.map { |t| [consistent_uniq_slugify(t), t] }.to_h
+            @git_consistent_tags ||= git_own_repo.tags.map { |t| [consistent_uniq_slugify(t), t] }.to_h
           end
 
           def deployed_docker_images

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

@@ -7,24 +7,36 @@ module Dapp
         end
 
         def local_git_artifacts
-          @local_git_artifact_list ||= begin
+          @local_git_artifact_list ||= [].tap do |artifacts|
             repo = GitRepo::Own.new(self)
             Array(config._git_artifact._local).map do |ga_config|
-              ::Dapp::Dimg::GitArtifact.new(repo, **ga_config._artifact_options)
+              artifacts.concat(generate_git_artifacts(repo, **ga_config._artifact_options))
             end
           end
         end
 
         def remote_git_artifacts
-          @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)
+          @remote_git_artifact_list ||= [].tap do |artifacts|
+            Array(config._git_artifact._remote).each do |ga_config|
+              repo = GitRepo::Remote.get_or_init(self, ga_config._name, url: ga_config._url, branch: ga_config._branch)
+              artifacts.concat(generate_git_artifacts(repo, **ga_config._artifact_options))
             end
           end
         end
+
+        def generate_git_artifacts(repo, **git_artifact_options)
+          [].tap do |artifacts|
+            artifacts << (artifact = ::Dapp::Dimg::GitArtifact.new(repo, **git_artifact_options))
+            artifacts.concat(generate_git_submodules_artifacts(artifact))
+          end
+        end
+
+        def generate_git_submodules_artifacts(artifact)
+          [].tap do |artifacts|
+            artifacts.concat(submodules_artifacts = artifact.submodules_artifacts)
+            artifacts.concat(submodules_artifacts.map(&method(:generate_git_submodules_artifacts)).flatten)
+          end
+        end
       end # GitArtifact
     end # Mod
   end # Dimg

data/lib/dapp/dimg/git_artifact.rb

@@ -3,6 +3,7 @@ module Dapp
     # Git repo artifact
     class GitArtifact
       include Helper::Tar
+      include Helper::Trivia
 
       attr_reader :repo
       attr_reader :name
@@ -32,6 +33,93 @@ module Dapp
       end
       # rubocop:enable Metrics/ParameterLists
 
+      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)
+        submodule_rel_path = submodule_params[:path]
+        submodule_repo     = begin
+          GitRepo::Remote.get_or_init(repo.dimg, submodule_rel_path,
+                                      url: submodule_url(submodule_params[:url]),
+                                      branch: submodule_params[:branch])
+        rescue Rugged::InvalidError => e
+          raise Error::Rugged, code: :incorrect_gitmodules_file, data: { error: e.message }
+        end
+
+        self.class.new(submodule_repo, submodule_artifact_options(submodule_params))
+      end
+
+      def submodule_url(url)
+        if url.start_with?('../')
+          case repo.remote_origin_url_protocol
+          when :http, :https, :git
+            uri = URI.parse(repo.remote_origin_url)
+            uri.path = File.expand_path(File.join(uri.path, url))
+            uri.to_s
+          when :ssh
+            host_with_user, group_and_project = repo.remote_origin_url.split(':', 2)
+            group_and_project = File.expand_path(File.join('/', group_and_project, url))[1..-1]
+            [host_with_user, group_and_project].join(':')
+          else
+            raise
+          end
+        else
+          url
+        end
+      end
+
+      def submodule_artifact_options(submodule_params)
+        submodule_rel_path = submodule_params[:path]
+
+        {}.tap do |options|
+          options[:name]                = repo.dapp.consistent_uniq_slugify("submodule-#{submodule_rel_path}")
+          options[:cwd]                 = submodule_inherit_path(cwd, submodule_rel_path).last
+          options[:to]                  = File.join(to, submodule_rel_path)
+          options[:include_paths]       = submodule_inherit_paths(include_paths, submodule_rel_path)
+          options[:exclude_paths]       = submodule_inherit_paths(exclude_paths, submodule_rel_path)
+          options[:stages_dependencies] = begin
+            stages_dependencies
+              .map { |stage, paths| [stage, submodule_inherit_paths(paths, submodule_rel_path)] }
+              .to_h
+          end
+          options[:branch]              = submodule_params[:branch]
+          options[:owner]               = owner
+          options[:group]               = group
+        end
+      end
+
+      def submodule_inherit_paths(paths, submodule_rel_path)
+        paths
+          .select { |path| check_path?(submodule_rel_path, path) || check_subpath?(submodule_rel_path, path) }
+          .map { |path| submodule_inherit_path(path, submodule_rel_path) }
+          .flatten
+          .compact
+      end
+
+      def submodule_inherit_path(path, submodule_rel_path)
+        path_parts      = path.split('/')
+        test_path       = nil
+        inherited_paths = []
+        until path_parts.empty?
+          last_part_path = path_parts.shift
+          test_path      = [test_path, last_part_path].compact.join('/')
+
+          non_match    = !File.fnmatch(test_path, submodule_rel_path, File::FNM_PATHNAME)
+          part_for_all = (last_part_path == '**')
+
+          if non_match || part_for_all
+            inherited_paths << [last_part_path, path_parts].flatten.join('/')
+            break unless part_for_all
+          end
+        end
+
+        inherited_paths
+      end
+
       def cwd_type(stage)
         if dev_mode?
           p = repo.workdir_path.join(cwd)
@@ -164,7 +252,6 @@ module Dapp
         hexdigest begin
           diff_patches(nil, nil, **options).map do |patch|
             file = patch.delta.new_file
-            raise_if_submodule!(file[:path], file[:mode])
             [file[:path], File.read(File.join(repo.workdir_path, file[:path])), file[:mode]]
           end
         end
@@ -225,7 +312,7 @@ module Dapp
       def archive_file_with_tar_writer(stage, commit)
         tar_write(repo.dimg.tmp_path('archives', archive_file_name(commit))) do |tar|
           each_archive_entry(stage, commit) do |path, content, mode|
-            if mode == 40960 # symlink
+            if mode == 0o120000 # symlink
               tar.add_symlink path, content, mode
             else
               tar.add_file path, mode do |tf|
@@ -244,7 +331,7 @@ module Dapp
           each_archive_entry(stage, commit) do |path, content, mode|
             file_path = repo.dimg.tmp_path(relative_archive_file_path, path)
 
-            if mode == 40960 # symlink
+            if mode == 0o120000 # symlink
               FileUtils.symlink(content, file_path)
             else
               IO.write(file_path, content)
@@ -279,20 +366,11 @@ module Dapp
 
       def patch_file(stage, 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 do |patch|
-            file = patch.delta.new_file
-            raise_if_submodule!(file[:path], file[:mode])
-            f.write change_patch_new_file_path(stage, patch)
-          end
+          diff_patches(from_commit, to_commit).each { |patch| f.write change_patch_new_file_path(stage, patch) }
         end
         repo.dimg.container_tmp_path('patches', patch_file_name(from_commit, to_commit))
       end
 
-      def raise_if_submodule!(relative_file_path, mode) # FIXME
-        return unless mode == 57344
-        raise Error::Rugged, code: :submodule_not_supported, data: { path: repo.path.dirname.join(relative_file_path) }
-      end
-
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def change_patch_new_file_path(stage, patch)
         patch.to_s.lines.tap do |lines|
@@ -356,7 +434,9 @@ module Dapp
 
       def repo_entries(commit, paths: include_paths_or_cwd)
         (@repo_entries ||= {})[[commit, paths]] ||= begin
-          repo.entries(commit, paths: paths, exclude_paths: exclude_paths(true))
+          repo
+            .entries(commit, paths: paths, exclude_paths: exclude_paths(true))
+            .select { |_, entry| !submodule_mode?(entry[:filemode]) }
         end
       end
 
@@ -365,9 +445,7 @@ module Dapp
           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)
-            raise_if_submodule!(file[:path], file[:mode])
 
             content = File.read(host_file_path)
             yield slice_cwd(stage, file[:path]), content, file[:mode]
@@ -377,9 +455,6 @@ module Dapp
             next unless entry[:type] == :blob
 
             entry_file_path = File.join(root, entry[:name])
-
-            raise_if_submodule!(entry_file_path, entry[:filemode])
-
             content = repo.lookup_object(entry[:oid]).content
             yield slice_cwd(stage, entry_file_path), content, entry[:filemode]
           end
@@ -395,10 +470,16 @@ module Dapp
               opts[:recurse_untracked_dirs] = true
             end
           end
-          repo.patches(from_commit, to_commit, paths: paths, exclude_paths: exclude_paths(true), **options)
+          repo
+            .patches(from_commit, to_commit, paths: paths, exclude_paths: exclude_paths(true), **options)
+            .select { |patch| !submodule_mode?(patch.delta.new_file[:mode]) } # FIXME: https://github.com/libgit2/rugged/issues/727
         end
       end
 
+      def submodule_mode?(mode) # FIXME
+        mode == 0o160000
+      end
+
       def include_paths_or_cwd
         case
         when !include_paths(true).empty? then include_paths(true)

data/lib/dapp/dimg/git_repo/base.rb

@@ -36,6 +36,56 @@ module Dapp
           []
         end
 
+        def remote_origin_url
+          @remote_origin_url ||= begin
+            ro_url = url
+            while url_protocol(ro_url) == :noname
+              begin
+                parent_git = Rugged::Repository.discover(ro_url)
+              rescue Rugged::OSError
+                parent_git_path = parent_git ? parent_git.path : path
+                raise Error::Rugged, code: :git_repository_not_found, data: { path: ro_url, parent_git_path: parent_git_path }
+              end
+
+              ro_url = begin
+                git_url(parent_git)
+              rescue Error::Rugged => e
+                break if e.net_status[:code] == :git_repository_without_remote_url # local repository
+                raise
+              end
+            end
+
+            ro_url
+          end
+        end
+
+        def remote_origin_url_protocol
+          url_protocol(remote_origin_url)
+        end
+
+        def submodules_params(commit, paths: [], exclude_paths: [])
+          raise "Workdir not supported for #{self.class}" if commit.nil?
+
+          entry = begin
+            lookup_commit(commit).tree.path('.gitmodules')
+          rescue Rugged::TreeError
+            return []
+          end
+
+          submodules_params_base(lookup_object(entry[:oid]).content, paths: paths, exclude_paths: exclude_paths)
+        end
+
+        def submodules_params_base(gitsubmodule_content, paths: [], exclude_paths: [])
+          IniFile.new.parse(gitsubmodule_content)
+            .to_h
+            .select { |_, params| !ignore_directory?(params['path'], paths: paths, exclude_paths: exclude_paths) }
+            .map do |_, params|
+              params = params.symbolize_keys
+              params[:branch] = params[:branch].to_s if params.key?(:branch)
+              params
+            end
+        end
+
         # FIXME: Убрать логику исключения путей exclude_paths из данного класса,
         # FIXME: т.к. большинство методов не поддерживают инвариант
         # FIXME "всегда выдавать данные с исключенными путями".
@@ -48,7 +98,13 @@ module Dapp
 
         def patches(from, to, paths: [], exclude_paths: [], **kwargs)
           diff(from, to, **kwargs).patches.select do |patch|
-            !ignore_path?(patch.delta.new_file[:path], paths: paths, exclude_paths: exclude_paths)
+            delta_new_file = patch.delta.new_file
+            args = [delta_new_file[:path], paths: paths, exclude_paths: exclude_paths]
+            if delta_new_file[:mode] == 0o040000 # nested git repository in dev mode
+              !ignore_directory?(*args)
+            else
+              !ignore_path?(*args)
+            end
           end
         end
 
@@ -127,6 +183,13 @@ module Dapp
           git.lookup(commit)
         end
 
+        def exist?
+          git
+          true
+        rescue Rugged::OSError
+          false
+        end
+
         protected
 
         attr_reader :manager
@@ -134,6 +197,57 @@ module Dapp
         def git(**kwargs)
           @git ||= Rugged::Repository.new(path.to_s, **kwargs)
         end
+
+        def url
+          @url ||= git_config_remote_origin_url(git)
+        end
+
+        def git_url(git_repo)
+          git_config_remote_origin_url(git_repo)
+        end
+
+        def git_config_remote_origin_url(git_repo)
+          git_repo.config.to_hash['remote.origin.url'].tap do |url|
+            raise Error::Rugged, code: :git_repository_without_remote_url, data: { name: self.class, path: git_repo.path } if url.nil?
+          end
+        end
+
+        def url_protocol(url)
+          if (scheme = URI.parse(url).scheme).nil?
+            :noname
+          else
+            scheme.to_sym
+          end
+        rescue URI::InvalidURIError
+          :ssh
+        rescue Error::Rugged => e
+          return :none if e.net_status[:code] == :git_repository_without_remote_url
+          raise
+        end
+
+        private
+
+        def ignore_directory?(path, paths: [], exclude_paths: [])
+          ignore_path_base(path, exclude_paths: exclude_paths) do
+            paths.empty? || paths.any? { |p| check_path?(path, p) || check_subpath?(path, p) }
+          end
+        end
+
+        def ignore_path?(path, paths: [], exclude_paths: [])
+          ignore_path_base(path, exclude_paths: exclude_paths) do
+            paths.empty? ||
+              paths.any? do |p|
+                File.fnmatch?(p, path, File::FNM_PATHNAME) ||
+                  File.fnmatch?(File.join(p, '**', '*'), path, File::FNM_PATHNAME)
+              end
+          end
+        end
+
+        def ignore_path_base(path, exclude_paths: [])
+          is_exclude_path = exclude_paths.any? { |p| check_path?(path, p) }
+          is_include_path = yield
+          is_exclude_path || !is_include_path
+        end
       end
     end
   end

data/lib/dapp/dimg/git_repo/own.rb

@@ -23,6 +23,13 @@ module Dapp
         # NOTICE: Параметры {from: nil, to: nil} можно указать только для Own repo.
         # NOTICE: Для Remote repo такой вызов не имеет смысла и это ошибка пользователя класса Remote.
 
+        def submodules_params(commit, paths: [], exclude_paths: [])
+          return super unless commit.nil?
+          return []    unless File.file?((gitmodules_file_path = File.join(workdir_path, '.gitmodules')))
+
+          submodules_params_base(File.read(gitmodules_file_path), paths: paths, exclude_paths: exclude_paths)
+        end
+
         def diff(from, to, **kwargs)
           if from.nil? and to.nil?
             mid_commit = latest_commit
@@ -45,6 +52,13 @@ module Dapp
         rescue Rugged::OdbError, TypeError => _e
           raise Error::Rugged, code: :commit_not_found_in_local_git_repository, data: { commit: commit }
         end
+
+        def exist?
+          super
+        rescue Error::Rugged => e
+          return false if e.net_status[:code] == :local_git_repository_does_not_exist
+          raise
+        end
       end
     end
   end

data/lib/dapp/dimg/git_repo/remote.rb

@@ -4,6 +4,11 @@ module Dapp
       class Remote < Base
         CACHE_VERSION = 1
 
+        def self.get_or_init(dimg, name, url:, branch:)
+          key = [url, branch]
+          (@repos ||= {})[key] ||= new(dimg, name, url: url).tap { |repo| repo.fetch!(branch) }
+        end
+
         attr_reader :url
 
         def initialize(dimg, name, url:)
@@ -14,8 +19,8 @@ module Dapp
           _with_lock do
             dapp.log_secondary_process(dapp.t(code: 'process.git_artifact_clone', data: { url: url }), short: true) do
               begin
-                if [:https, :ssh].include?(protocol) && !Rugged.features.include?(protocol)
-                  raise Error::Rugged, code: :rugged_protocol_not_supported, data: { url: url, protocol: protocol }
+                if [:https, :ssh].include?(remote_origin_url_protocol) && !Rugged.features.include?(remote_origin_url_protocol)
+                  raise Error::Rugged, code: :rugged_protocol_not_supported, data: { url: url, url_protocol: remote_origin_url_protocol }
                 end
 
                 Rugged::Repository.clone_at(url, path.to_s, bare: true, credentials: _rugged_credentials)
@@ -32,7 +37,7 @@ module Dapp
 
         def _rugged_credentials
           @_rugged_credentials ||= begin
-            if protocol == :ssh
+            if remote_origin_url_protocol == :ssh
               host_with_user = url.split(':', 2).first
               username = host_with_user.split('@', 2).reverse.last
               Rugged::Credentials::SshKeyFromAgent.new(username: username)
@@ -59,7 +64,11 @@ module Dapp
             end
 
             dapp.log_secondary_process(dapp.t(code: 'process.git_artifact_fetch', data: { url: url }), short: true) do
-              git.fetch('origin', [branch], credentials: _rugged_credentials)
+              begin
+                git.fetch('origin', [branch], credentials: _rugged_credentials)
+              rescue Rugged::SshError => e
+                raise Error::Rugged, code: :rugged_remote_error, data: { url: url, message: e.message.strip }
+              end
               raise Error::Rugged, code: :branch_not_exist_in_remote_git_repository, data: { branch: branch, url: url } unless branch_exist?(branch)
             end
           end unless dimg.ignore_git_fetch || dapp.dry_run?
@@ -90,18 +99,6 @@ module Dapp
         def branch_format(name)
           "origin/#{name.reverse.chomp('origin/'.reverse).reverse}"
         end
-
-        def protocol
-          @protocol ||= begin
-            if (scheme = URI.parse(url).scheme).nil?
-              :noname
-            else
-              scheme.to_sym
-            end
-          rescue URI::InvalidURIError
-            :ssh
-          end
-        end
       end
     end
   end

data/lib/dapp/helper/trivia.rb

@@ -28,28 +28,12 @@ module Dapp
         Pathname.new(File.join(base.to_s, *path.compact.map(&:to_s)))
       end
 
-      def ignore_path?(path, paths: [], exclude_paths: [])
-        ignore_path_base(path, exclude_paths: exclude_paths) do
-          paths.empty? ||
-            paths.any? do |p|
-              File.fnmatch?(p, path, File::FNM_PATHNAME|File::FNM_DOTMATCH) ||
-                File.fnmatch?(File.join(p, '**', '*'), path, File::FNM_PATHNAME|File::FNM_DOTMATCH)
-            end
-        end
-      end
-
-      def ignore_path_base(path, exclude_paths: [])
-        is_exclude_path = exclude_paths.any? { |p| check_path?(path, p) }
-        is_include_path = yield
-        is_exclude_path || !is_include_path
-      end
-
       def check_path?(path, format)
-        path_checker(path) { |checking_path| File.fnmatch(format, checking_path, File::FNM_PATHNAME|File::FNM_DOTMATCH) }
+        path_checker(path) { |checking_path| File.fnmatch(format, checking_path, File::FNM_PATHNAME) }
       end
 
       def check_subpath?(path, format)
-        path_checker(format) { |checking_path| File.fnmatch(checking_path, path, File::FNM_PATHNAME|File::FNM_DOTMATCH) }
+        path_checker(format) { |checking_path| File.fnmatch(checking_path, path, File::FNM_PATHNAME) }
       end
 
       def path_checker(path)

data/lib/dapp/kube/dapp/command/deploy.rb

@@ -116,7 +116,6 @@ module Dapp
                     # Поэтому перехватываем и просто отображаем произошедшую
                     # ошибку для информации пользователю без завершения работы dapp.
                     $stderr.puts(::Dapp::Dapp.paint_string(::Dapp::Helper::NetStatus.message(e), :warning))
-                    sentry_exception(e, extra: {"job-spec" => job.spec})
                   end
 
                 end # Thread

data/lib/dapp/kube/dapp/command/render.rb

@@ -13,8 +13,8 @@ module Dapp
                       template_relative_path_pattern = Pathname(File.expand_path(template_path_pattern)).subpath_of(path('.helm'))
                       template_relative_path_pattern ||= template_path_pattern
 
-                      File.fnmatch?(template_relative_path_pattern, template_path_without_chart_name, File::FNM_PATHNAME|File::FNM_DOTMATCH) ||
-                        File.fnmatch?(template_relative_path_pattern, template_path, File::FNM_PATHNAME|File::FNM_DOTMATCH)
+                      File.fnmatch?(template_relative_path_pattern, template_path_without_chart_name, File::FNM_PATHNAME) ||
+                        File.fnmatch?(template_relative_path_pattern, template_path, File::FNM_PATHNAME)
                     end
                   end
                 else

data/lib/dapp/kube/helm/values.rb

@@ -36,10 +36,10 @@ module Dapp
           elsif ENV["CI_COMMIT_REF_NAME"]
             ci_info["branch"] = ci_info["ref"] = ENV["CI_COMMIT_REF_NAME"]
             ci_info["is_branch"] = true
-          elsif dapp.git_path and dapp.git_local_repo.branch != "HEAD"
+          elsif dapp.git_own_repo_exist? and dapp.git_local_repo.branch != "HEAD"
             ci_info["branch"] = ci_info["ref"] = dapp.git_local_repo.branch
             ci_info["is_branch"] = true
-          elsif dapp.git_path
+          elsif dapp.git_own_repo_exist?
             git = dapp.git_local_repo.send(:git)
 
             tagref = git.references.find do |r|

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = "0.23.10"
-  BUILD_CACHE_VERSION = 26.1
+  VERSION = "0.24.0"
+  BUILD_CACHE_VERSION = 26
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.23.10
+  version: 0.24.0
 platform: ruby
 authors:
 - Dmitry Stolyarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-16 00:00:00.000000000 Z
+date: 2018-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout
@@ -186,34 +186,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.6
-- !ruby/object:Gem::Dependency
-  name: sentry-raven
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.7.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.7.2
-- !ruby/object:Gem::Dependency
-  name: toml-rb
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.1.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.1.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -476,7 +448,6 @@ files:
 - lib/dapp/dapp/logging/paint.rb
 - lib/dapp/dapp/logging/process.rb
 - lib/dapp/dapp/option_tags.rb
-- lib/dapp/dapp/sentry.rb
 - lib/dapp/dapp/shellout/base.rb
 - lib/dapp/dapp/shellout/streaming.rb
 - lib/dapp/dapp/slug.rb
@@ -676,7 +647,6 @@ files:
 - lib/dapp/helper/sha256.rb
 - lib/dapp/helper/tar.rb
 - lib/dapp/helper/trivia.rb
-- lib/dapp/helper/url.rb
 - lib/dapp/helper/yaml.rb
 - lib/dapp/kube.rb
 - lib/dapp/kube/cli/cli.rb

data/lib/dapp/dapp/sentry.rb

@@ -1,112 +0,0 @@
-module Dapp
-  class Dapp
-    module Sentry
-      def sentry_message(msg, **kwargs)
-        return if not ensure_sentry_configured
-        kwargs[:level] ||= "info"
-        Raven.capture_message(msg, _make_sentry_params(**kwargs))
-      end
-
-      def sentry_exception(exception, **kwargs)
-        return if not ensure_sentry_configured
-        (kwargs[:tags] ||= {})['error-code'] = begin
-          net_status = exception.net_status
-          [net_status[:context], net_status[:code]].compact.join('_')
-        end
-        Raven.capture_exception(exception, _make_sentry_params(**kwargs))
-      end
-
-      def ensure_sentry_configured
-        return false unless sentry_settings = settings["sentry"]
-
-        unless @sentry_settings_configured
-          Raven.configure do |config|
-            logger = ::Logger.new(STDOUT)
-            logger.level = ::Logger::WARN
-
-            config.logger = logger
-            config.dsn = sentry_settings["dsn"]
-          end
-
-          @sentry_settings_configured = true
-        end
-
-        return true
-      end
-
-      def _make_sentry_params(level: nil, tags: {}, extra: {}, user: {})
-        {
-          level: level,
-          tags:  _sentry_tags_context.merge(tags),
-          extra: _sentry_extra_context.merge(extra),
-          user:  _sentry_user_context.merge(user),
-        }
-      end
-
-      def _sentry_extra_context
-        @_sentry_extra_context ||= {
-          "pwd" => Dir.pwd,
-          "dapp-dir" => self.work_dir,
-          "options" => self.options,
-          "env-options" => {
-            "DAPP_FORCE_SAVE_CACHE" => ENV["DAPP_FORCE_SAVE_CACHE"],
-            "DAPP_BIN_DAPPFILE_YML" => ENV["DAPP_BIN_DAPPFILE_YML"],
-            "ANSIBLE_ARGS" => ENV["ANSIBLE_ARGS"],
-            "DAPP_CHEF_DEBUG" => ENV["DAPP_CHEF_DEBUG"],
-          },
-        }.tap {|extra|
-          extra["ci-env"] = {"CI" => ENV["CI"]}
-          ENV.select {|k, v| k.start_with?("CI_")}.each do |k, v|
-            extra["ci-env"][k] = v
-          end
-        }
-      end
-
-      def _sentry_tags_context
-        name = options[:name] || 
-        @_sentry_tags_context ||= {
-          "dapp-short-version" => ::Dapp::VERSION.split(".")[0..1].join("."),
-          "dapp-version" => ::Dapp::VERSION,
-          "dapp-build-cache-version" => ::Dapp::BUILD_CACHE_VERSION,
-          "dapp-command" => self.options[:dapp_command],
-        }.tap {|tags|
-          git_config_path = File.join(Dir.pwd, ".git/config")
-
-          tags["dapp-name"] = options[:name]
-
-          if File.exists? git_config_path
-            cfg = IniFile.load(File.join(Dir.pwd, ".git/config"))
-            remote_origin_cfg = cfg['remote "origin"']
-            remote_origin_url = remote_origin_cfg["url"]
-            if remote_origin_url
-              tags["dapp-name"] ||= begin
-                repo_name = remote_origin_url.split('/').last
-                repo_name = repo_name[/.*(?=\.git)/] if repo_name.end_with? '.git'
-                repo_name
-              end
-
-              tags["git-host"] = self.get_host_from_git_url(remote_origin_url)
-
-              git_name = self.git_url_to_name(remote_origin_url)
-
-              tags["git-group"] = git_name.partition("/")[0]
-              tags["git-name"] = git_name
-            end
-          end
-
-          tags["dapp-name"] ||= File.basename(Dir.pwd)
-
-          begin
-            ver = self.class.host_docker_minor_version
-            tags["docker-minor-version"] = ver.to_s
-          rescue ::Exception
-          end
-        }
-      end
-
-      def _sentry_user_context
-        @_sentry_user_context ||= {}
-      end
-    end # Sentry
-  end # Dapp
-end # Dapp

data/lib/dapp/helper/url.rb

@@ -1,23 +0,0 @@
-module Dapp
-  module Helper
-    module Url
-      def git_url_to_name(url)
-        url_without_scheme = url.split("://", 2).last
-        # This may be broken, because "@" should delimit creds, not a ":"
-        url_without_creds = url_without_scheme.split(":", 2).last
-        url_without_creds.gsub(%r{.*?([^\/ ]+\/[^\/ ]+)\.git}, '\\1')
-      end
-
-      def get_host_from_git_url(url)
-        url_without_scheme = url.split("://", 2).last
-        url_without_creds = url_without_scheme.split("@", 2).last
-
-        # Split out part after ":" in this kind of url: github.com:flant/dapp.git
-        url_part = url_without_creds.split(":", 2).first
-
-        # Split out part after first "/": github.com/flant/dapp.git
-        url_part.split("/", 2).first
-      end
-    end # Url
-  end # Helper
-end # Dapp