dapp 0.8.0 → 0.9.0

data/lib/dapp/config/dimg.rb

@@ -1,23 +0,0 @@
-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

@@ -1,194 +0,0 @@
-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 dev_mode
-          @_dev_mode = true
-        end
-
-        def install_depends_on(*args)
-          _install_dependencies.concat(args)
-        end
-
-        def setup_depends_on(*args)
-          _setup_dependencies.concat(args)
-        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)
-          _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(url = nil, &blk)
-          type = url.nil? ? :local : :remote
-          _git_artifact.send(type, url.to_s, &blk)
-        end
-
-        def mount(to, &blk)
-          _mount << Directive::Mount.new(to, project: project, &blk)
-        end
-
-        def _dev_mode
-          !!@_dev_mode
-        end
-
-        def _builder
-          @_builder || :none
-        end
-
-        def _chef
-          @_chef ||= Directive::Chef.new(project: project)
-        end
-
-        def _shell
-          @_shell ||= Directive::Shell::Dimg.new(project: project)
-        end
-
-        def _docker
-          @_docker ||= Directive::Docker::Dimg.new(project: project)
-        end
-
-        def _mount
-          @_mount ||= []
-        end
-
-        def _git_artifact
-          @_git_artifact ||= GitArtifact.new(project: project)
-        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 < Directive::Base
-          attr_reader :_local, :_remote
-
-          def initialize(**kwargs, &blk)
-            @_local = []
-            @_remote = []
-
-            super(**kwargs, &blk)
-          end
-
-          def local(_, &blk)
-            @_local << Directive::GitArtifactLocal.new(project: project, &blk)
-          end
-
-          def remote(repo_url, &blk)
-            @_remote << Directive::GitArtifactRemote.new(repo_url, project: project, &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(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?
-          directive
-        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
-              when TrueClass, FalseClass then variable
-              else
-                raise
-              end
-            end)
-          end
-          obj
-        end
-
-        def passed_directives
-          [:@_chef, :@_shell, :@_docker,
-           :@_git_artifact, :@_mount,
-           :@_artifact, :@_builder, :@_dev_mode,
-           :@_install_dependencies, :@_setup_dependencies]
-        end
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-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, :shell], [:_chef, :chef], [:_git_artifact, :git],
-                        [:_install_dependencies, :install_depends_on], [:_setup_dependencies, :setup_depends_on],
-                        [:_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).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

@@ -1,60 +0,0 @@
-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(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)
-        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

@@ -1,53 +0,0 @@
-module Dapp
-  module Config
-    # DimgGroupBase
-    class DimgGroupBase < Base
-      attr_reader :_dimg_group
-
-      def initialize(project:)
-        @_dimg = []
-        @_dimg_group = []
-
-        super(project: project)
-      end
-
-      def dev_mode
-        @_dev_mode = true
-      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).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