docker-template 0.8.0 → 0.10.0

data/lib/docker/template/notify.rb

@@ -1,17 +1,15 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Docker
   module Template
     module Notify
       module_function
 
-      # ----------------------------------------------------------------------
+      # --
       # Notify the user of a push that is happening.
-      # ----------------------------------------------------------------------
+      # --
 
       def push(builder)
         $stderr.puts Simple::Ansi.green(
@@ -19,9 +17,9 @@ module Docker
         )
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Notify the user that we are tag aliasing.
-      # ----------------------------------------------------------------------
+      # --
 
       def alias(builder)
         repo = builder.repo
@@ -30,14 +28,59 @@ module Docker
         $stderr.puts msg
       end
 
-      # ----------------------------------------------------------------------
+      # --
+
+      def build(repo, rootfs: false)
+        build_start(repo, {
+          :rootfs => rootfs
+        })
+
+        if block_given?
+          yield
+          build_end(repo, {
+            :rootfs => rootfs
+          })
+        end
+      end
+
+      # --
       # Notify the user that we are building their repository.
-      # ----------------------------------------------------------------------
+      # --
 
-      def build(repo, **kwd)
-        img = repo.to_s(**kwd)
-        msg = Simple::Ansi.green("Building: #{img}")
-        $stderr.puts msg
+      def build_start(repo, rootfs: false)
+        if ENV["TRAVIS"] && !ENV.key?("RSPEC_RUNNING")
+          STDOUT.puts(format("travis_fold:end:%s",
+            repo.to_s(:rootfs => rootfs).tr("^A-Za-z0-9", "-").gsub(
+              /\-$/, ""
+            )
+          ))
+        end
+
+        $stderr.puts Simple::Ansi.green(format(
+          "Building: %s", repo.to_s({
+            :rootfs => rootfs
+          })
+        ))
+      end
+
+      # --
+      # Notify the user that building their repository has ended.
+      # --
+
+      def build_end(repo, rootfs: false)
+        if ENV["TRAVIS"] && !ENV.key?("RSPEC_RUNNING")
+          STDOUT.puts(format("travis_fold:end:%s",
+            repo.to_s(:rootfs => rootfs).tr("^A-Za-z0-9", "-").gsub(
+              /\-$/, ""
+            )
+          ))
+        end
+
+        $stderr.puts Simple::Ansi.green(format(
+          "Done Building: %s", repo.to_s({
+            :rootfs => rootfs
+          })
+        ))
       end
     end
   end

data/lib/docker/template/parser.rb

@@ -1,8 +1,6 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Docker
   module Template
@@ -16,62 +14,60 @@ module Docker
         @argv = argv
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Return `raw_repos` if you send us a list of repos you wish to build,
       # otherwise we get the children of the repo folder and ship that off so
       # you can build *every* repo, I don't know if you want that.
-      # ----------------------------------------------------------------------
-
+      # --
       def all
         return @raw_repos unless @raw_repos.empty?
-        Template.root.join(Metadata.new({}).repos_dir).children.map do |path|
+        return [Template.root.basename.to_s] if Template.project?
+        Template.root.join(Meta.new({}).repos_dir).children.map do |path|
           path.basename.to_s
         end
 
       rescue Errno::ENOENT
-        then raise Error::RepoNotFound
+        then raise(
+          Error::RepoNotFound
+        )
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # rubocop:disable Metrics/AbcSize
-      # ----------------------------------------------------------------------
-
+      # --
       def parse
-        repos = {
-          :scratch => [],
-          :simple  => [],
-          :aliases => []
-        }
+        scratch = []
+        simple  = []
+        aliases = []
 
         all.each do |v|
-          hash = self.class.to_repo_hash(
-            v
-          )
+          hash = self.class.to_repo_hash(v)
+          raise Error::BadRepoName, v if hash.empty?
+          Repo.new(hash, @argv).to_repos.each do |r|
+            scratch << r if r.builder.scratch? && !r.alias?
+            simple  << r unless r.alias? || r.builder.scratch?
+            aliases << r if r.alias?
+          end
+        end
 
-          if hash.empty?
-            raise(Docker::Template::Error::BadRepoName,
-              v
+        out = aliases.each_with_object(scratch | simple) do |alias_, repos|
+          index = repos.rindex { |v| v.name == alias_.name }
+          if index
+            repos.insert(index + 1,
+              alias_
             )
 
           else
-            Repo.new(hash, @argv).to_repos.each do |r|
-              r.alias?? repos[:aliases] << r : \
-                if r.builder.scratch?
-                  repos[:scratch] << r else repos[:simple] << r
-                end
-            end
+            repos.push(
+              alias_
+            )
           end
         end
-
-        repos.values.reduce(
-          :|
-        )
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # rubocop:enable Metrics/AbcSize
-      # ----------------------------------------------------------------------
-
+      # --
       def self.to_repo_hash(val)
         data = val.to_s.split(SPLIT_REGEXP)
 
@@ -83,7 +79,20 @@ module Docker
         {}
       end
 
-      # ----------------------------------------------------------------------
+      # --
+
+      def self.from_tag_to_repo_hash(val)
+        data = val.to_s.split(SPLIT_REGEXP)
+
+        return "tag" => data[0] if data.one?
+        return "name" => data[0], "tag"  => data[1] if val =~ COLON_REGEXP && data.size == 2
+        return "user" => data[0], "name" => data[1] if val =~ SLASH_REGEXP && data.size == 2
+        return "user" => data[0], "name" => data[1], "tag" => data[2] if data.size == 3
+
+        {}
+      end
+
+      # --
 
       def self.full_name?(val)
         parsed = to_repo_hash(val)

data/lib/docker/template/repo.rb

@@ -1,18 +1,18 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
 # Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Docker
   module Template
     class Repo
       extend Forwardable::Extended
 
-      # ----------------------------------------------------------------------
+      # --
 
       def initialize(*hashes)
-        @base_meta = hashes.compact.reduce(:deep_merge).freeze
+        @base_meta = hashes.compact
+        @base_meta = @base_meta.reduce(:deep_merge)
+        @base_meta.freeze
 
         unless root.exist?
           raise(
@@ -21,57 +21,56 @@ module Docker
         end
       end
 
-      # ----------------------------------------------------------------------
-      # Determines whether or not we should (or you should) push the repo.
-      # ----------------------------------------------------------------------
+      # --
 
       def pushable?
-        (metadata["push"] || metadata["push_only"]) &&
-          !metadata["cache_only"] && !metadata[
+        (meta["push"] || meta["push_only"]) &&
+          !meta["cache_only"] && !meta[
             "clean_only"
           ]
       end
 
-      # ----------------------------------------------------------------------
-      # Determines whether or not we should (or you should) cache the repo.
-      # ----------------------------------------------------------------------
+      # --
 
       def cacheable?
-        (metadata["cache"] || metadata["cache_only"]) &&
-          !metadata[
+        (meta["cache"] || meta["cache_only"]) &&
+          !meta[
             "push_only"
           ]
       end
 
-      # ----------------------------------------------------------------------
-      # Determines whether or not we should (or you should) build the repo.
-      # ----------------------------------------------------------------------
+      # --
+
+      def clean_cache?
+        (meta["clean"] || meta["clean_only"])
+      end
+
+      # --
 
       def buildable?
-        !metadata["push_only"] && !metadata["cache_only"] &&
-          !metadata[
+        meta.build? && !meta["push_only"] && !meta["cache_only"] &&
+          !meta[
             "clean_only"
           ]
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Pulls out the repo this repo is aliasing it, this happens when you
       # when you set the tag in the "alias" section of your `opts.yml`.
-      # ----------------------------------------------------------------------
-
+      # --
       def aliased
         full = Parser.full_name?(
-          metadata.aliased_tag
+          meta.aliased_tag
         )
 
         if alias? && full
           self.class.new(to_h.merge(Parser.to_repo_hash(
-            metadata.aliased_tag
+            meta.aliased_tag
           )))
 
         elsif alias?
           self.class.new(to_h.merge({
-            "tag" => metadata.aliased_tag
+            "tag" => meta.aliased_tag
           }))
         end
 
@@ -81,51 +80,47 @@ module Docker
         end
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Initializes and returns the builder so that you can build the repo.
-      # ----------------------------------------------------------------------
-
+      # --
       def builder
         return @builder ||= begin
-          Template.const_get(type.capitalize).new(
+          Template::Builder.const_get(type.capitalize).new(
             self
           )
         end
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # Convert the repo into it's final image name, however if you tell, us
       # this is a rootfs build we will convert it into the rootfs name.
-      # ----------------------------------------------------------------------
-
+      # --
       def to_s(rootfs: false)
-        prefix = metadata["local_prefix"]
+        prefix = meta["local_prefix"]
         return "#{user}/#{name}:#{tag}" unless rootfs
         "#{prefix}/rootfs:#{name}"
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # The directory you wish to cache to (like `cache/`) or other.
-      # ----------------------------------------------------------------------
-
+      # --
       def cache_dir
         return root.join(
-          metadata["cache_dir"], tag
+          meta["cache_dir"], tag
         )
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # The directory you store your image data in (by default `copy/`.)
-      # ----------------------------------------------------------------------
-
+      # --
       def copy_dir(*path)
-        dir = metadata["copy_dir"]
-        root.join(dir,
-          *path
+        dir = meta["copy_dir"]
+        root.join(
+          dir, *path
         )
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
       def to_tag_h
         {
@@ -135,91 +130,100 @@ module Docker
         }
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
       def to_rootfs_h
         {
           "tag"   => name,
-          "repo"  => "#{metadata["local_prefix"]}/rootfs",
+          "repo"  => "#{meta["local_prefix"]}/rootfs",
           "force" => true
         }
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
       def tmpdir(*args, root: nil)
         args.unshift(user, name, tag)
-        Pathutil.tmpdir(args,
-          nil, root
+        Pathutil.tmpdir(
+          args, nil, root
         )
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
       def tmpfile(*args, root: nil)
         args.unshift(user, name, tag)
-        Pathutil.tmpfile(args,
-          nil, root
+        Pathutil.tmpfile(
+          args, nil, root
         )
       end
 
-      # ----------------------------------------------------------------------
+      # --
       # If a tag was given then it returns [self] and if a tag was not sent
       # it then goes on to detect the type and split itself accordingly
       # returning multiple, AKA all repos that should be built.
-      # ----------------------------------------------------------------------
-
+      # --
       def to_repos
-        set = Set.new
-        if @base_meta.key?("tag")
-          set << self
+        if Template.project?
+          then Set.new([
+            self
+          ])
+
         else
-          tags.each do |tag|
-            hash = to_h.merge("tag" => tag)
-            set << self.class.new(
-              hash, @cli_opts
-            )
+          set = Set.new
+          if @base_meta.key?("tag")
+            set << self
+          else
+            tags.each do |tag|
+              hash = Parser.from_tag_to_repo_hash(tag)
+              hash = to_h.merge(hash)
+              set << self.class.new(
+                hash, @cli_opts
+              )
+            end
           end
+
+          set
         end
-        set
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
-      def metadata
-        return @metadata ||= begin
-          Metadata.new(
+      def meta
+        return @meta ||= begin
+          Meta.new(
             @base_meta
           )
         end
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
       def to_env(tar_gz: nil, copy_dir: nil)
-        hash = metadata["env"] || { "all" => {}}
-        Metadata.new(hash, :root => metadata).merge({
+        hash = meta["env"] || { "all" => {}}
+        Meta.new(hash, :root => meta).merge({
           "REPO" => name,
           "TAR_GZ" => tar_gz,
-          "GROUP" => metadata.group,
+          "GROUP" => meta.group,
+          "DEBUG" => meta.debug?? "true" : "",
           "COPY_DIR" => copy_dir,
           "BUILD_TYPE" => type,
           "TAG" => tag
         })
       end
 
-      # ----------------------------------------------------------------------
+      # --
 
       rb_delegate :build, :to => :builder
-      rb_delegate :alias?, :to => :metadata
-      rb_delegate :complex_alias?, :to => :metadata
-      rb_delegate :type, :to => :metadata, :type => :hash
-      rb_delegate :user, :to => :metadata, :type => :hash
-      rb_delegate :name, :to => :metadata, :type => :hash
-      rb_delegate :tag,  :to => :metadata, :type => :hash
+      rb_delegate :alias?, :to => :meta
+      rb_delegate :complex_alias?, :to => :meta
+      rb_delegate :type, :to => :meta, :type => :hash
+      rb_delegate :user, :to => :meta, :type => :hash
+      rb_delegate :name, :to => :meta, :type => :hash
+      rb_delegate :tag,  :to => :meta, :type => :hash
       rb_delegate :to_h, :to => :@base_meta
-      rb_delegate :root, :to => :metadata
-      rb_delegate :tags, :to => :metadata
+      rb_delegate :root, :to => :meta
+      rb_delegate :tags, :to => :meta
       rb_delegate :clean, {
         :to => Cache, :alias_of => :cleanup, :args => %w(
           self