dapp 0.8.0 → 0.9.0

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

@@ -0,0 +1,126 @@
+module Dapp
+  module Dimg
+    module Config
+      class Dimg < Base
+        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],
+                          [:_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 # Validation
+        # rubocop:enable Metrics/ModuleLength
+      end # Dimg
+    end # Config
+  end # Dimg
+end # Dapp

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

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

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

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

@@ -0,0 +1,22 @@
+module Dapp
+  module Dimg
+    module Config
+      class DimgGroupMain < DimgGroupBase
+        def dimg(name = nil, &blk)
+          with_dimg_validation { super(name, &blk) }
+        end
+
+        def dimg_group(&blk)
+          with_dimg_validation { super(&blk) }
+        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
+end

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

@@ -0,0 +1,70 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class Artifact < ArtifactBase
+          attr_reader :_config
+
+          def initialize(config:, **kwargs, &blk)
+            @_config = config
+
+            super(**kwargs, &blk)
+          end
+
+          def _export
+            super do |export|
+              export._before ||= @_before
+              export._after ||= @_after
+              export._config = _config
+            end
+          end
+
+          class Export < ArtifactBase::Export
+            attr_accessor :_config
+            attr_accessor :_before, :_after
+
+            def not_associated?
+              (_before || _after).nil?
+            end
+
+            protected
+
+            def before(stage)
+              stage = stage.to_sym
+              associate_validation!(:before, stage, @_before)
+              @_before = stage
+            end
+
+            def after(stage)
+              stage = stage.to_sym
+              associate_validation!(:after, stage, @_after)
+              @_after = stage
+            end
+
+            def associate_validation!(type, stage, _old_stage)
+              conflict_type = [:before, :after].find { |t| t != type }
+              conflict_stage = send("_#{conflict_type}")
+
+              raise Error::Config, code: :stage_artifact_not_supported_associated_stage,
+                                   data: { stage: "#{type} #{stage.inspect}" } unless [:install, :setup].include? stage
+
+              raise Error::Config, code: :stage_artifact_double_associate,
+                                   data: { stage: "#{type} #{stage.inspect}",
+                                           conflict_stage: "#{conflict_type} #{conflict_stage.inspect}" } if conflict_stage
+
+              defined_stage = send("_#{type}")
+              dapp.log_config_warning(
+                desc: {
+                  code: :stage_artifact_rewritten,
+                  context: :warning,
+                  data: { stage: "#{type} #{stage.inspect}",
+                          conflict_stage: "#{type} #{defined_stage.inspect}" }
+                }
+              ) if defined_stage
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class ArtifactBase < Base
+          attr_reader :_owner, :_group
+
+          def initialize(**kwargs, &blk)
+            @_export = []
+
+            super(**kwargs, &blk)
+          end
+
+          def _export
+            @_export.each do |export|
+              export._owner ||= @_owner
+              export._group ||= @_group
+
+              yield(export) if block_given?
+            end
+          end
+
+          class Export < Directive::Base
+            attr_accessor :_cwd, :_to, :_include_paths, :_exclude_paths, :_owner, :_group
+
+            def initialize(cwd = '/', **kwargs, &blk)
+              raise Error::Config, code: :export_cwd_absolute_path_required unless Pathname(cwd).absolute?
+              @_cwd = path_format(cwd)
+              @_include_paths ||= []
+              @_exclude_paths ||= []
+
+              super(**kwargs, &blk)
+            end
+
+            def _artifact_options
+              {
+                to:            _to,
+                cwd:           _cwd,
+                include_paths: _include_paths,
+                exclude_paths: _exclude_paths,
+                owner:         _owner,
+                group:         _group
+              }
+            end
+
+            protected
+
+            def to(absolute_path)
+              raise Error::Config, code: :export_to_absolute_path_required unless Pathname(absolute_path).absolute?
+              @_to = path_format(absolute_path)
+            end
+
+            def include_paths(*relative_paths)
+              unless relative_paths.all? { |path| Pathname(path).relative? }
+                raise Error::Config, code: :export_include_paths_relative_path_required
+              end
+              _include_paths.concat(relative_paths.map(&method(:path_format)))
+            end
+
+            def exclude_paths(*relative_paths)
+              unless relative_paths.all? { |path| Pathname(path).relative? }
+                raise Error::Config, code: :export_exclude_paths_relative_path_required
+              end
+              _exclude_paths.concat(relative_paths.map(&method(:path_format)))
+            end
+
+            def owner(owner)
+              @_owner = owner
+            end
+
+            def group(group)
+              @_group = group
+            end
+
+            def validate!
+              raise Error::Config, code: :export_to_required if _to.nil?
+            end
+          end
+
+          protected
+
+          def owner(owner)
+            @_owner = owner
+          end
+
+          def group(group)
+            @_group = group
+          end
+
+          def export(absolute_dir_path = '/', &blk)
+            @_export << self.class.const_get('Export').new(absolute_dir_path, dapp: dapp, &blk)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,68 @@
+module Dapp
+  module Dimg
+    module Config
+      module Directive
+        class Chef < Base
+          attr_accessor :_dimod, :_cookbook, :_recipe, :_attributes
+
+          def initialize(**kwargs, &blk)
+            @_dimod = []
+            @_recipe = []
+            @_cookbook = {}
+
+            super(**kwargs, &blk)
+          end
+
+          def dimod(name, *args)
+            @_dimod << name
+            cookbook(name, *args)
+          end
+
+          def recipe(name)
+            @_recipe << name
+          end
+
+          def attributes
+            @_attributes ||= Attributes.new
+          end
+
+          def cookbook(name, version_constraint=nil, **kwargs)
+            @_cookbook[name] = {}.tap do |desc|
+              desc.update(kwargs)
+              desc[:name] = name
+              desc[:version_constraint] = version_constraint if version_constraint
+              desc[:path] = File.expand_path(desc[:path], dapp.path) if desc.key? :path
+            end
+          end
+
+          %i(before_install install before_setup setup build_artifact).each do |stage|
+            define_method("_#{stage}_attributes") do
+              var = "@__#{stage}_attributes"
+              instance_variable_get(var) || instance_variable_set(var, Attributes.new)
+            end
+          end
+
+          class Attributes < Hash
+            def [](key)
+              super || begin
+                self[key] = self.class.new
+              end
+            end
+          end # Attributes
+
+          %i(before_install install before_setup setup build_artifact).each do |stage|
+            define_method("__#{stage}_attributes") do
+              attributes.in_depth_merge send("_#{stage}_attributes")
+            end
+          end
+
+          protected
+
+          def empty?
+            (@_dimod + @_recipe).empty? && attributes.empty?
+          end
+        end
+      end
+    end
+  end
+end