dapp 0.6.17 → 0.7.1

data/lib/dapp/config/base.rb

@@ -0,0 +1,19 @@
+module Dapp
+  module Config
+    # Base
+    class Base
+      def initialize(project:, &blk)
+        @project = project
+        instance_eval(&blk) if block_given?
+      end
+
+      protected
+
+      attr_reader :project
+
+      def marshal_dup(obj)
+        Marshal.load(Marshal.dump(obj))
+      end
+    end
+  end
+end

data/lib/dapp/config/dimg.rb

@@ -0,0 +1,23 @@
+module Dapp
+  module Config
+    # Dimg
+    class Dimg < Base
+      include Validation
+      include InstanceMethods
+
+      attr_reader :_name
+
+      def initialize(name, project:)
+        self._name = name
+        super(project: project)
+      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

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

@@ -0,0 +1,179 @@
+module Dapp
+  module Config
+    class Dimg < Base
+      # InstanceMethods
+      module InstanceMethods
+        attr_reader :_builder
+        attr_reader :_chef, :_shell, :_docker, :_git_artifact, :_mount, :_artifact
+        attr_reader :_install_dependencies, :_setup_dependencies
+
+        def install_depends_on(*args)
+          @_install_dependencies.concat(args)
+        end
+
+        def setup_depends_on(*args)
+          @_setup_dependencies.concat(args)
+        end
+
+        def chef(&blk)
+          builder_validation(:chef)
+          directive_eval(_chef, &blk)
+        end
+
+        def shell(&blk)
+          builder_validation(:shell)
+          directive_eval(_shell, &blk)
+        end
+
+        def docker(&blk)
+          directive_eval(_docker, &blk)
+        end
+
+        def artifact(&blk)
+          _artifact.concat begin
+                             pass_to_custom(ArtifactGroup.new(project: project), :clone_to_artifact).tap do |artifact_group|
+                               artifact_group.instance_eval(&blk) if block_given?
+                             end._export
+                           end
+        end
+
+        def git(type_or_repo_url, &blk)
+          type = type_or_repo_url.to_sym == :local ? :local : :remote
+          _git_artifact.send(type, type_or_repo_url, &blk)
+        end
+
+        def mount(to, &blk)
+          _mount << Directive::Mount.new(to, &blk)
+        end
+
+        def _builder
+          @_builder || :none
+        end
+
+        def _chef
+          @_chef ||= Directive::Chef.new
+        end
+
+        def _shell
+          @_shell ||= Directive::Shell::Dimg.new
+        end
+
+        def _docker
+          @_docker ||= Directive::Docker::Dimg.new
+        end
+
+        def _mount
+          @_mount ||= []
+        end
+
+        def _git_artifact
+          @_git_artifact ||= GitArtifact.new
+        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 _install_dependencies
+          @_install_dependencies ||= []
+        end
+
+        def _setup_dependencies
+          @_setup_dependencies ||= []
+        end
+
+        def _artifact
+          @_artifact ||= []
+        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
+
+        # GitArtifact
+        class GitArtifact
+          attr_reader :_local, :_remote
+
+          def initialize
+            @_local = []
+            @_remote = []
+          end
+
+          def local(_, &blk)
+            @_local << Directive::GitArtifactLocal.new(&blk)
+          end
+
+          def remote(repo_url, &blk)
+            @_remote << Directive::GitArtifactRemote.new(repo_url, &blk)
+          end
+
+          def _local
+            @_local.map(&:_export).flatten
+          end
+
+          def _remote
+            @_remote.map(&:_export).flatten
+          end
+
+          protected
+
+          def empty?
+            (_local + _remote).empty?
+          end
+
+          def validate!
+            (_local + _remote).each { |exp| exp.send(:validate!) }
+          end
+        end
+
+        protected
+
+        def builder_validation(type)
+          @_builder = type if _builder == :none
+          raise Error::Config, code: :builder_type_conflict unless @_builder == type
+        end
+
+        def directive_eval(directive, &blk)
+          directive.instance_eval(&blk) if block_given?
+        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.send(clone_method)
+              when Symbol then variable
+              when Array then variable.dup
+              else
+                raise
+              end
+            end)
+          end
+          obj
+        end
+
+        def passed_directives
+          [:@_chef, :@_shell, :@_docker, :@_git_artifact, :@_mount, :@_artifact, :@_builder]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+module Dapp
+  module Config
+    class Dimg < Base
+      # Validation
+      module Validation
+        protected
+
+        def validate!
+          directives_validate!
+          validate_scratch!
+          validate_artifacts!
+          validate_artifacts_artifacts!
+        end
+
+        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.send(:validate!) if elm.methods.include?(:validate!)
+            end
+          end
+        end
+
+        def validate_scratch_directives!
+          directives = [:_shell, :_chef, :_git_artifact, :_install_dependencies, :_setup_dependencies,
+                        :_tmp_dir_mount, :_build_dir_mount]
+          directives.each do |directive|
+            raise Error::Config,
+                  code: :scratch_unsupported_directive,
+                  data: { directive: directive[1..-1] } unless public_send(directive).send(: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.send(: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
+    end
+  end
+end

data/lib/dapp/config/dimg_group.rb

@@ -0,0 +1,56 @@
+module Dapp
+  module Config
+    # DimgGroup
+    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(type_or_git_repo, &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 check_dimg_directive_order(directive)
+        project.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)
+        project.log_config_warning(desc: { code: 'wrong_using_directive',
+                                           data: { directive: directive },
+                                           context: 'warning' }) if _dimg.any? || _dimg_group.any?
+      end
+    end
+  end
+end

data/lib/dapp/config/dimg_group_base.rb

@@ -0,0 +1,36 @@
+module Dapp
+  module Config
+    # DimgGroupBase
+    class DimgGroupBase < Base
+      attr_reader :_dimg_group
+
+      def initialize(project:)
+        @_dimg = []
+        @_dimg_group = []
+
+        super(project: project)
+      end
+
+      def dimg(name = nil, &blk)
+        Config::Dimg.new(name, project: project).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(project: project, &blk).tap { |dimg_group| @_dimg_group << dimg_group }
+      end
+
+      def _dimg
+        (@_dimg + @_dimg_group.map(&:_dimg)).flatten
+      end
+
+      protected
+
+      def before_dimg_eval(_dimg)
+      end
+    end
+  end
+end

data/lib/dapp/config/dimg_group_main.rb

@@ -0,0 +1,21 @@
+module Dapp
+  module Config
+    # DimgGroupMain
+    class DimgGroupMain < DimgGroupBase
+      def dimg(name = nil)
+        with_dimg_validation { super }
+      end
+
+      def dimg_group
+        with_dimg_validation { super }
+      end
+
+      protected
+
+      def with_dimg_validation
+        yield
+        raise Error::Config, code: :dimg_name_required if _dimg.any? { |dimg| dimg._name.nil? } && _dimg.size > 1
+      end
+    end
+  end
+end