dapp 0.11.0 → 0.12.0

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

@@ -1,7 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class Base < ::Dapp::Config::Base; end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class Dimg < Base
-        include Validation
-        include InstanceMethods
-
-        attr_reader :_name
-
-        def initialize(name, dapp:)
-          self._name = name
-          super(dapp: dapp)
-        end
-
-        def _name=(name)
-          return if name.nil?
-          reg = '^[[[:alnum:]]_.-]*$'
-          raise Error::Config, code: :dimg_name_incorrect, data: { name: name, reg: reg } unless name =~ /#{reg}/
-          @_name = name
-        end
-      end
-    end
-  end
-end

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

@@ -1,179 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class Dimg < Base
-        module InstanceMethods
-          attr_reader :_builder
-          attr_reader :_chef, :_shell, :_docker, :_git_artifact, :_mount, :_artifact
-          attr_reader :_artifact_groups
-
-          def dev_mode
-            @_dev_mode = true
-          end
-
-          def chef(&blk)
-            builder(:chef)
-            directive_eval(_chef, &blk)
-          end
-
-          def shell(&blk)
-            builder(:shell)
-            directive_eval(_shell, &blk)
-          end
-
-          def docker(&blk)
-            directive_eval(_docker, &blk)
-          end
-
-          def artifact(&blk)
-            pass_to_custom(ArtifactGroup.new(dapp: dapp), :clone_to_artifact).tap do |artifact_group|
-              _artifact_groups << directive_eval(artifact_group, &blk)
-            end
-          end
-
-          def git(url = nil, &blk)
-            type = url.nil? ? :local : :remote
-            _git_artifact.public_send(type, url.to_s, &blk)
-          end
-
-          def mount(to, &blk)
-            Directive::Mount.new(to, dapp: dapp, &blk).tap do |mount|
-              _mount << mount
-            end
-          end
-
-          def _dev_mode
-            !!@_dev_mode
-          end
-
-          def _builder
-            @_builder || :none
-          end
-
-          def _chef
-            @_chef ||= Directive::Chef.new(dapp: dapp)
-          end
-
-          def _shell
-            @_shell ||= Directive::Shell::Dimg.new(dapp: dapp)
-          end
-
-          def _docker
-            @_docker ||= Directive::Docker::Dimg.new(dapp: dapp)
-          end
-
-          def _mount
-            @_mount ||= []
-          end
-
-          def _git_artifact
-            @_git_artifact ||= GitArtifact.new(dapp: dapp)
-          end
-
-          [:build_dir, :tmp_dir].each do |mount_type|
-            define_method "_#{mount_type}_mount" do
-              _mount.select { |m| m._type == mount_type }
-            end
-          end
-
-          def _artifact_groups
-            @_artifact_groups ||= []
-          end
-
-          def _artifact
-            _artifact_groups.map(&:_export).flatten
-          end
-
-          [:before, :after].each do |order|
-            [:setup, :install].each do |stage|
-              define_method "_#{order}_#{stage}_artifact" do
-                _artifact.select do |art|
-                  art.public_send("_#{order}") == stage
-                end
-              end
-            end
-          end
-
-          def _import_artifact
-            _artifact.select(&:not_associated?)
-          end
-
-          class GitArtifact < Directive::Base
-            attr_reader :_local, :_remote
-
-            def initialize(**kwargs, &blk)
-              @_local = []
-              @_remote = []
-
-              super(**kwargs, &blk)
-            end
-
-            def local(_, &blk)
-              Directive::GitArtifactLocal.new(dapp: dapp, &blk).tap do |git|
-                @_local << git
-              end
-            end
-
-            def remote(repo_url, &blk)
-              Directive::GitArtifactRemote.new(repo_url, dapp: dapp, &blk).tap do |git|
-                @_remote << git
-              end
-            end
-
-            def _local
-              @_local.map(&:_export).flatten
-            end
-
-            def _remote
-              @_remote.map(&:_export).flatten
-            end
-
-            def empty?
-              (_local + _remote).empty?
-            end
-
-            def validate!
-              (_local + _remote).each(&:validate!)
-            end
-          end
-
-          protected
-
-          def builder(type)
-            @_builder = type if _builder == :none
-            raise Error::Config, code: :builder_type_conflict unless @_builder == type
-          end
-
-          def pass_to_default(dimg)
-            pass_to_custom(dimg, :clone)
-          end
-
-          def pass_to_custom(obj, clone_method)
-            passed_directives.each do |directive|
-              next if (variable = instance_variable_get(directive)).nil?
-
-              obj.instance_variable_set(directive, begin
-                case variable
-                when Directive::Base, GitArtifact then variable.public_send(clone_method)
-                when Symbol then variable
-                when Array then variable.dup
-                when TrueClass, FalseClass then variable
-                else
-                  raise
-                end
-              end)
-            end
-            obj
-          end
-
-          def passed_directives
-            [:@_chef, :@_shell, :@_docker,
-             :@_git_artifact, :@_mount,
-             :@_artifact_groups, :@_builder, :@_dev_mode]
-          end
-        end # InstanceMethods
-        # rubocop:enable Metrics/ModuleLength
-      end # Dimg
-    end # Config
-  end # Dimg
-end # Dapp

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

@@ -1,126 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class Dimg < Base
-        module Validation
-          def validate!
-            directives_validate!
-            validate_scratch!
-            validate_artifacts!
-            validate_artifacts_artifacts!
-          end
-
-          protected
-
-          def validate_scratch!
-            if _docker._from.nil?
-              validate_scratch_directives!
-              validate_scratch_artifacts!
-            else
-              raise Error::Config, code: :stage_artifact_not_associated unless _import_artifact.empty?
-            end
-          end
-
-          def directives_validate!
-            passed_directives.each do |v|
-              next if (value = instance_variable_get(v)).nil?
-              Array(value).each do |elm|
-                elm.validate! if elm.respond_to?(:validate!)
-              end
-            end
-          end
-
-          def validate_scratch_directives!
-            directives = [[:_shell, :shell], [:_chef, :chef], [:_git_artifact, :git],
-                          [:_tmp_dir_mount, :mount], [:_build_dir_mount, :mount]]
-            directives.each do |name, user_name|
-              raise Error::Config,
-                    code: :scratch_unsupported_directive,
-                    data: { directive: user_name } unless public_send(name).empty?
-            end
-
-            docker_directives = [:_expose, :_env, :_cmd, :_onbuild, :_workdir, :_user, :_entrypoint]
-            docker_directives.each do |directive|
-              value = _docker.public_send(directive)
-              raise Error::Config,
-                    code: :scratch_unsupported_directive,
-                    data: { directive: "docker.#{directive}" } unless value.nil? || value.empty?
-            end
-          end
-
-          def validate_scratch_artifacts!
-            raise Error::Config, code: :scratch_artifact_associated unless _associated_artifacts.empty?
-            raise Error::Config, code: :scratch_artifact_required if _import_artifact.empty?
-            _import_artifact.each do |artifact|
-              raise Error::Config, code: :scratch_artifact_docker_from if artifact._config._docker._from.nil?
-            end
-          end
-
-          def validate_artifacts_artifacts!
-            _artifact.each { |artifact_dimg| artifact_dimg._config.validate! }
-          end
-
-          def validate_artifacts!
-            artifacts = validate_artifact_format(validated_artifacts)
-            loop do
-              break if artifacts.empty?
-              verifiable_artifact = artifacts.shift
-              artifacts.select { |a| a[:to] == verifiable_artifact[:to] }.each do |artifact|
-                next if verifiable_artifact[:index] == artifact[:index]
-                validate_artifact!(verifiable_artifact, artifact)
-                validate_artifact!(artifact, verifiable_artifact)
-              end
-            end
-          end
-
-          def validate_artifact_format(artifacts)
-            artifacts.map do |a|
-              path_format = proc { |path| File.expand_path(File.join('/', path, '/'))[1..-1] }
-
-              path_format.call(a._to) =~ %r{^([^\/]*)\/?(.*)$}
-              to = Regexp.last_match(1)
-              include_paths = a._include_paths.dup
-              include_paths << Regexp.last_match(2) unless Regexp.last_match(2).empty?
-              exclude_paths = a._exclude_paths.dup
-
-              {
-                index: artifacts.index(a),
-                to: to,
-                include_paths: include_paths.map(&path_format),
-                exclude_paths: exclude_paths.map(&path_format)
-              }
-            end
-          end
-
-          def validate_artifact!(verifiable_artifact, artifact)
-            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(Error::Config, code: :artifact_conflict)
-            validate_artifact_path!(verifiable_artifact, artifact[:include_paths]) if verifiable_artifact[:include_paths].empty?
-          end
-
-          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(Error::Config, code: :artifact_conflict) }
-          end
-
-          def _associated_artifacts
-            _artifact.select do |art|
-              !(art._before.nil? && art._after.nil?)
-            end
-          end
-
-          def validated_artifacts
-            _artifact + _git_artifact._local + _git_artifact._remote
-          end
-        end # Validation
-        # rubocop:enable Metrics/ModuleLength
-      end # Dimg
-    end # Config
-  end # Dimg
-end # Dapp

data/lib/dapp/dimg/config/dimg_group.rb

@@ -1,61 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class DimgGroup < DimgGroupBase
-        include Dimg::InstanceMethods
-
-        def chef(&blk)
-          check_dimg_directive_order(:chef)
-          super
-        end
-
-        def shell(&blk)
-          check_dimg_directive_order(:shell)
-          super
-        end
-
-        def docker(&blk)
-          check_dimg_directive_order(:docker)
-          super
-        end
-
-        def artifact(&blk)
-          check_dimg_group_directive_order(:artifact)
-          super
-        end
-
-        def git(url = nil, &blk)
-          check_dimg_directive_order(:git)
-          super
-        end
-
-        def mount(to, &blk)
-          check_dimg_directive_order(:mount)
-          super
-        end
-
-        protected
-
-        def before_dimg_eval(dimg)
-          pass_to_default(dimg)
-        end
-
-        def before_dimg_group_eval(dimg_group)
-          pass_to_default(dimg_group)
-        end
-
-        def check_dimg_directive_order(directive)
-          dapp.log_config_warning(desc: { code: 'wrong_using_base_directive',
-                                          data: { directive: directive },
-                                          context: 'warning' }) if _dimg.any? || _dimg_group.any? || _artifact.any?
-        end
-
-        def check_dimg_group_directive_order(directive)
-          dapp.log_config_warning(desc: { code: 'wrong_using_directive',
-                                          data: { directive: directive },
-                                          context: 'warning' }) if _dimg.any? || _dimg_group.any?
-        end
-      end
-    end
-  end
-end

data/lib/dapp/dimg/config/dimg_group_base.rb

@@ -1,54 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class DimgGroupBase < Base
-        attr_reader :_dimg_group
-
-        def initialize(dapp:)
-          @_dimg = []
-          @_dimg_group = []
-
-          super(dapp: dapp)
-        end
-
-        def dev_mode
-          @_dev_mode = true
-        end
-
-        def dimg(name = nil, &blk)
-          Config::Dimg.new(name, dapp: dapp).tap do |dimg|
-            before_dimg_eval(dimg)
-            dimg.instance_eval(&blk) if block_given?
-            @_dimg << dimg
-          end
-        end
-
-        def dimg_group(&blk)
-          Config::DimgGroup.new(dapp: dapp).tap do |dimg_group|
-            before_dimg_group_eval(dimg_group)
-            dimg_group.instance_eval(&blk) if block_given?
-            @_dimg_group << dimg_group
-          end
-        end
-
-        def _dimg
-          (@_dimg + @_dimg_group.map(&:_dimg)).flatten
-        end
-
-        protected
-
-        def before_dimg_eval(dimg)
-          pass_to_default(dimg)
-        end
-
-        def before_dimg_group_eval(dimg_group)
-          pass_to_default(dimg_group)
-        end
-
-        def pass_to_default(obj)
-          obj.instance_variable_set(:@_dev_mode, @_dev_mode)
-        end
-      end
-    end
-  end
-end