dapp 0.6.17 → 0.7.1

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

@@ -1,74 +1,49 @@
 module Dapp
   module Config
+    # Directive
     module Directive
       # Artifact
-      module Artifact
-        # Base
-        class Base
-          attr_accessor :_where_to_add, :_cwd, :_paths, :_exclude_paths, :_owner, :_group
+      class Artifact < ArtifactBase
+        attr_reader :_config
 
-          def initialize(where_to_add, **options)
-            @_cwd          = ''
-            @_where_to_add = where_to_add
-
-            options.each do |k, v|
-              respond_to?("_#{k}=") ? send(:"_#{k}=", v) : raise(Error::Config, code: code,
-                                                                                data: { type: object_name, attr: k })
-            end
-          end
+        def initialize(config:)
+          @_config = config
+          super()
+        end
 
-          def _paths
-            base_paths(@_paths)
+        def _export
+          super do |export|
+            export._before ||= @_before
+            export._after ||= @_after
+            export._config = _config
           end
+        end
 
-          def _exclude_paths
-            base_paths(@_exclude_paths)
-          end
+        # Export
+        class Export < ArtifactBase::Export
+          attr_accessor :_config
+          attr_accessor :_before, :_after
 
-          def _artifact_options
-            {
-              where_to_add:  _where_to_add,
-              cwd:           _cwd,
-              paths:         _paths,
-              exclude_paths: _exclude_paths,
-              owner:         _owner,
-              group:         _group
-            }
+          def not_associated?
+            (_before || _after).nil?
           end
 
           protected
 
-          def clone
-            Marshal.load(Marshal.dump(self))
-          end
-
-          def base_paths(paths)
-            Array(paths)
+          def before(stage)
+            associate_validation!(:before, stage)
+            @_before = stage
           end
 
-          def code
-            raise
-          end
-
-          def object_name
-            self.class.to_s.split('::').last
-          end
-        end
-
-        # Stage
-        class Stage < Base
-          attr_accessor :_config
-
-          protected
-
-          def clone
-            artifact_options = Marshal.load(Marshal.dump(_artifact_options))
-            where_to_add = artifact_options.delete(:where_to_add)
-            self.class.new(where_to_add, config: _config, **artifact_options)
+          def after(stage)
+            associate_validation!(:after, stage)
+            @_after = stage
           end
 
-          def code
-            :artifact_unexpected_attribute
+          def associate_validation!(type, stage)
+            another = [:before, :after].find { |t| t != type }
+            raise Error::Config, code: :stage_artifact_double_associate unless send("_#{another}").nil?
+            raise Error::Config, code: :stage_artifact_not_supported_associated_stage unless [:install, :setup].include? stage
           end
         end
       end

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

@@ -0,0 +1,92 @@
+module Dapp
+  module Config
+    module Directive
+      # ArtifactBase
+      class ArtifactBase < Base
+        attr_reader :_owner, :_group
+
+        def initialize
+          @_export = []
+          super
+        end
+
+        def _export
+          @_export.each do |export|
+            export._owner ||= @_owner
+            export._group ||= @_group
+
+            yield(export) if block_given?
+          end
+        end
+
+        # Export
+        class Export < Directive::Base
+          attr_accessor :_cwd, :_to, :_include_paths, :_exclude_paths, :_owner, :_group
+
+          def initialize(cwd = '/')
+            raise Error::Config, code: :export_cwd_absolute_path_required unless Pathname(cwd).absolute?
+            @_cwd = cwd
+            @_include_paths ||= []
+            @_exclude_paths ||= []
+
+            super()
+          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 = absolute_path
+          end
+
+          def include_paths(*relative_paths)
+            raise Error::Config, code: :export_include_paths_relative_path_required unless relative_paths.all? { |path| Pathname(path).relative? }
+            _include_paths.concat(relative_paths)
+          end
+
+          def exclude_paths(*relative_paths)
+            raise Error::Config, code: :export_exclude_paths_relative_path_required unless relative_paths.all? { |path| Pathname(path).relative? }
+            _exclude_paths.concat(relative_paths)
+          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, &blk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Dapp
+  module Config
+    module Directive
+      # Base
+      class Base < Config::Base
+        def initialize(&blk)
+          instance_eval(&blk) unless blk.nil?
+        end
+
+        protected
+
+        def clone
+          marshal_dup(self)
+        end
+
+        def clone_to_artifact
+          clone
+        end
+      end
+    end
+  end
+end

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

@@ -2,85 +2,35 @@ module Dapp
   module Config
     module Directive
       # Chef
-      class Chef
-        attr_reader :_modules
-        attr_reader :_recipes
+      class Chef < Base
+        attr_accessor :_dimod, :_recipe, :_attributes
 
         def initialize
-          @_modules = []
-          @_recipes = []
-        end
-
-        def module(*args)
-          @_modules.concat(args)
-        end
+          @_dimod = []
+          @_recipe = []
 
-        def reset_modules
-          @_modules.clear
+          super
         end
 
-        def skip_module(*args)
-          @_modules.reject! { |mod| args.include? mod }
+        def dimod(*args)
+          @_dimod.concat(args)
         end
 
         def recipe(*args)
-          @_recipes.concat(args)
-        end
-
-        def remove_recipe(*args)
-          @_recipes.reject! { |recipe| args.include? recipe }
-        end
-
-        def reset_recipes
-          @_recipes.clear
+          @_recipe.concat(args)
         end
 
         def attributes
-          @attributes ||= Attributes.new
+          @_attributes ||= Attributes.new
         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
-
           define_method("_#{stage}_attributes") do
-            attributes.in_depth_merge send("#{stage}_attributes")
-          end
-
-          define_method("reset_#{stage}_attributes") do
-            instance_variable_set("@#{stage}_attributes", nil)
-          end
-        end
-
-        def reset_attributes
-          @attributes = nil
-        end
-
-        def reset_all_attributes
-          reset_attributes
-          %i(before_install install before_setup setup build_artifact).each do |stage|
-            send("reset_#{stage}_attributes")
+            var = "@__#{stage}_attributes"
+            instance_variable_get(var) || instance_variable_set(var, Attributes.new)
           end
         end
 
-        def reset_all
-          reset_modules
-          reset_recipes
-          reset_all_attributes
-        end
-
-        protected
-
-        def clone
-          Marshal.load(Marshal.dump(self))
-        end
-
-        def empty?
-          @_modules.empty? && @_recipes.empty?
-        end
-
         # Attributes
         class Attributes < Hash
           def [](key)
@@ -89,6 +39,18 @@ module Dapp
             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

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

@@ -4,20 +4,9 @@ module Dapp
       # Docker
       module Docker
         # Artifact
-        class Artifact
-          attr_reader :_from
-          attr_reader :_from_cache_version
-
-          def from(image, cache_version: nil)
-            raise(Error::Config, code: :docker_from_incorrect, data: { name: image }) unless image =~ /^[[^ ].]+:[[^ ].]+$/
-            @_from = image
-            @_from_cache_version = cache_version
-          end
-
-          protected
-
-          def clone
-            Marshal.load(Marshal.dump(self))
+        class Artifact < Base
+          def _change_options
+            {}
           end
         end
       end

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

@@ -1,91 +1,16 @@
 module Dapp
   module Config
     module Directive
-      # Docker
       module Docker
         # Base
-        class Base
-          attr_reader :_from, :_volume, :_expose, :_env, :_label, :_cmd, :_onbuild, :_workdir, :_user, :_entrypoint
-          attr_reader :_from_cache_version
-
-          def initialize
-            @_volume = []
-            @_expose = []
-            @_env = {}
-            @_label = {}
-            @_cmd = []
-            @_onbuild = []
-          end
+        class Base < Directive::Base
+          attr_reader :_from, :_from_cache_version
 
           def from(image, cache_version: nil)
-            image = image.to_s
-            raise(Error::Config, code: :docker_from_incorrect, data: { name: image }) unless Image::Docker.image_name?(image)
-            raise(Error::Config, code: :docker_from_without_tag, data: { name: image }) unless image.include?(':')
+            raise(Error::Config, code: :docker_from_incorrect, data: { name: image }) unless image =~ /^[[^ ].]+:[[^ ].]+$/
             @_from = image
             @_from_cache_version = cache_version
           end
-
-          def volume(*args)
-            @_volume.concat(args)
-          end
-
-          def expose(*args)
-            @_expose.concat(args)
-          end
-
-          def env(**options)
-            @_env.merge!(options)
-          end
-
-          def label(**options)
-            @_label.merge!(options)
-          end
-
-          def cmd(*args)
-            @_cmd.concat(args)
-          end
-
-          def onbuild(*args)
-            @_onbuild.concat(args)
-          end
-
-          def workdir(val)
-            @_workdir = val
-          end
-
-          def user(val)
-            @_user = val
-          end
-
-          def entrypoint(*cmd_with_args)
-            @_entrypoint = cmd_with_args.flatten
-          end
-
-          def _change_options
-            {
-              volume: _volume,
-              expose: _expose,
-              env: _env,
-              label: _label,
-              cmd: _cmd,
-              onbuild: _onbuild,
-              workdir: _workdir,
-              user: _user,
-              entrypoint: _entrypoint
-            }
-          end
-
-          protected
-
-          def clone
-            Marshal.load(Marshal.dump(self))
-          end
-
-          def clone_to_artifact
-            Artifact.new.tap do |docker|
-              docker.instance_variable_set('@_from', @_from)
-            end
-          end
         end
       end
     end