squared 0.4.6 → 0.4.7

data/lib/squared/workspace/project/docker.rb

@@ -278,45 +278,44 @@ module Squared
 
         def buildx(flag, opts = [], tag: nil, context: nil)
           cmd, opts = docker_session('buildx', opts: opts)
-          opts = option_sanitize(opts, OPT_DOCKER[:buildx][:common]).first
-          cmd << flag
-          list = OPT_DOCKER[:buildx][flag == :bake ? :bake : :build] + OPT_DOCKER[:buildx][:shared]
-          out = option_sanitize(opts, list).first
+          op = OptionPartition.new(opts, OPT_DOCKER[:buildx][:common], cmd, project: self)
+          op << flag
+          op.parse(OPT_DOCKER[:buildx][flag == :bake ? :bake : :build] + OPT_DOCKER[:buildx][:shared])
           case flag
           when :build, :context
             append_tag(tag || option('tag', ignore: false) || @tag)
             append_context context
           when :bake
-            unless out.empty?
-              args = out.dup
-              out.clear
+            unless op.empty?
+              args = op.dup
+              op.extras.clear
               if Dir.exist?(args.last)
                 if projectpath?(val = args.pop)
                   context = val
                 else
-                  out << val
+                  op.extras << val
                 end
               end
-              append_value(args, escape: true)
+              op.append(args, escape: true)
               contextdir(context) if context
             end
           end
-          option_clear(out, pass: false)
+          op.clear(pass: false)
           run(from: :"buildx:#{flag}")
         end
 
         def composex(flag, opts = [], service: nil)
           cmd, opts = docker_session('compose', opts: opts)
-          opts = option_sanitize(opts, OPT_DOCKER[:compose][:common]).first
-          append_file filetype unless session_arg?('f', 'file')
-          cmd << flag
-          out = option_sanitize(opts, OPT_DOCKER[:compose][flag]).first
+          op = OptionPartition.new(opts, OPT_DOCKER[:compose][:common], cmd, project: self)
+          append_file filetype unless op.arg?('f', 'file')
+          op << flag
+          op.parse(OPT_DOCKER[:compose][flag])
           from = :"compose:#{flag}"
           case flag
           when :build, :up
-            append_value(out, escape: true)
+            op.append(escape: true)
           when :exec, :run
-            append_command(flag, service, out, from: from)
+            append_command(flag, service, op.extras, from: from)
           end
           run(from: from)
         end
@@ -324,12 +323,12 @@ module Squared
         def container(flag, opts = [], id: nil)
           cmd, opts = docker_session('container', flag, opts: opts)
           list = OPT_DOCKER[:container].fetch(flag, [])
-          list += OPT_DOCKER[:container][:update] if flag == :run
-          out = option_sanitize(opts, list, args: flag == :run || flag == :exec).first
+          list.concat(OPT_DOCKER[:container][:update]) if flag == :run
+          op = OptionPartition.new(opts, list, cmd, project: self, args: flag == :run || flag == :exec)
           from = :"container:#{flag}"
           case flag
           when :run, :exec
-            if flag == :run && !session_arg?('mount')
+            if flag == :run && !op.arg?('mount')
               run = VAL_DOCKER[:run]
               both = run[:bind] + run[:tmpfs]
               diff = run[:bind].reject { |val| run[:tmpfs].include?(val) }
@@ -361,14 +360,14 @@ module Squared
                 cmd << "--mount type=#{tmpfs ? 'tmpfs' : 'bind'},#{args.join(',')}"
               end
             end
-            append_command(flag, id.to_s.empty? ? tagmain : id, out, from: from)
+            append_command(flag, id.to_s.empty? ? tagmain : id, op.extras, from: from)
           when :update
-            raise_error('missing container', hint: from) if out.empty?
-            append_value(out, escape: true)
+            raise_error('missing container', hint: from) if op.empty?
+            op.append(escape: true)
           when :commit
-            latest = out.shift || tagmain
+            latest = op.shift || tagmain
             cmd << id << latest
-            raise_error("unknown args: #{out.join(', ')}", hint: from) unless out.empty?
+            raise_error("unknown args: #{op.join(', ')}", hint: from) unless op.empty?
             return unless confirm_command(cmd.to_s, title: from, target: id, as: latest)
 
             registry = option('registry') || @registry
@@ -386,7 +385,7 @@ module Squared
             opts << '--quiet' unless verbose
             return image(:push, opts, id: latest, registry: registry)
           else
-            if out.empty?
+            if op.empty?
               status = []
               no = true
               case flag
@@ -411,13 +410,13 @@ module Squared
               when :rm
                 status = %w[created exited dead]
               end
-              ps = docker_output('ps -a', *status.map! { |s| "--filter='status=#{s}'" })
+              ps = docker_output('ps -a', *status.map { |s| "--filter='status=#{s}'" })
               list_image(flag, ps, no: no, hint: "status: #{status.join(', ')}", from: from) do |img|
                 run(cmd.temp(img), from: from)
               end
               return
             else
-              append_value(out, escape: true)
+              op.append(escape: true)
             end
           end
           run(from: from)
@@ -425,11 +424,11 @@ module Squared
 
         def image(flag, opts = [], sync: true, id: nil, registry: nil)
           cmd, opts = docker_session('image', flag, opts: opts)
-          out = option_sanitize(opts, OPT_DOCKER[:image][flag]).first
+          op = OptionPartition.new(opts, OPT_DOCKER[:image][flag], cmd, project: self)
           from = :"image:#{flag}"
           case flag
           when :list
-            if opts.size == out.size
+            if opts.size == op.size
               index = 0
               name = nil
               opts.reverse_each { |opt| break opts.delete(opt) if (name = opt[/^name=["']?(.+?)["']?$/, 1]) }
@@ -443,28 +442,30 @@ module Squared
               end
               return
             else
-              option_clear out
+              op.clear
             end
           when :rm
             if id
-              cmd << id
-            elsif !out.empty?
-              out.each { |val| run(cmd.temp(val), sync: sync, from: from) }
-              return
+              op << id
             else
-              list_image(flag, docker_output('image ls -a'), from: from) do |val|
-                image(:rm, opts, sync: sync, id: val)
+              if op.empty?
+                list_image(flag, docker_output('image', 'ls', '-a'), from: from) do |val|
+                  puts val
+                  image(:rm, opts, sync: sync, id: val)
+                end
+              else
+                op.each { |val| run(cmd.temp(val), sync: sync, from: from) }
               end
               return
             end
           when :push
             id ||= option('tag', ignore: false) || tagmain
-            registry ||= out.shift || option('registry') || @registry
-            raise_error(id ? "unknown args: #{out.join(', ')}" : 'no id/tag given', hint: from) unless id && out.empty?
+            registry ||= op.shift || option('registry') || @registry
+            raise_error(id ? "unknown args: #{op.join(', ')}" : 'no id/tag given', hint: from) unless id && op.empty?
             raise_error('username/registry not provided', hint: from) unless registry
             registry.chomp!('/')
             uri = shell_quote("#{registry}/#{id}")
-            cmd << uri
+            op << uri
             img = docker_output 'image', 'tag', id, uri
             return unless confirm_command(img.to_s, cmd.to_s, target: id, as: registry, title: from)
 
@@ -475,7 +476,8 @@ module Squared
 
         def network(flag, opts = [], target: nil)
           cmd, opts = docker_session('network', flag, opts: opts)
-          option_sanitize(opts, OPT_DOCKER[:network][flag]).first
+          op = OptionPartition.new(opts, OPT_DOCKER[:network][flag], cmd, project: self)
+          op.clear
           from = :"network:#{flag}"
           list_image(flag, docker_output('ps -a'), from: from) do |img|
             puts 'Success' if run(cmd.temp(target, img), from: from) == true && stdout? && banner?
@@ -510,10 +512,9 @@ module Squared
         def docker_session(*cmd, opts: nil)
           return session('docker', *cmd) unless opts
 
-          out = []
-          opts = option_sanitize(opts, OPT_DOCKER[:common], target: out).first
-          ret = session('docker', *out, *cmd)
-          [ret, opts]
+          op = OptionPartition.new(opts, OPT_DOCKER[:common], project: self)
+          ret = session('docker', *op.to_a, *cmd)
+          [ret, op.extras]
         end
 
         def docker_output(*cmd, **kwargs)
@@ -523,7 +524,7 @@ module Squared
         def append_command(flag, val, list, target: @session, from: nil)
           case flag
           when :run
-            unless session_arg?('name')
+            unless session_arg?('name', target: target)
               require 'random/formatter'
               target << basic_option('name', dnsname("#{name}_#{Random.new.alphanumeric(6)}"))
             end
@@ -537,18 +538,23 @@ module Squared
         def append_file(type, target: @session)
           return unless type == 2 || type == 4 || @file.is_a?(Array)
 
-          target.merge(as_a(@file).map { |val| quote_option('file', basepath(val)) })
+          files = as_a(@file).map { |val| quote_option('file', basepath(val)) }
+          if target.is_a?(Set)
+            target.merge(files)
+          else
+            target.concat(files)
+          end
         end
 
         def append_context(ctx = nil, target: @session)
-          if @file.is_a?(String) && !session_arg?('f', 'file') && !bake?(dockerfile) && !compose?(dockerfile)
+          if @file.is_a?(String) && !session_arg?('f', 'file', target: target) && !bake? && !compose?
             target << quote_option('file', dockerfile)
           end
           target << contextdir(ctx || context)
         end
 
         def append_tag(val, target: @session)
-          ver = option('version', ignore: false)
+          ver = option('version', target: target, ignore: false)
           list = case val
                  when String
                    val.split(',')
@@ -587,7 +593,7 @@ module Squared
               a = sub_style(ee, styles: theme[:inline])
               b = "Execute #{sub_style(flag, styles: theme[:active])} on #{a}#{ee == id ? '' : " (#{id})"}"
               c, d = no ? ['y/N', 'N'] : ['Y/n', 'Y']
-              e = time_format(time_offset(data['CreatedAt']), pass: ['ms'])
+              e = time_format(time_since(data['CreatedAt']), pass: ['ms'])
               f = sub_style(ARG[:BORDER][0], styles: theme[:inline])
               g = ' ' * (cc + 1)
               h = "#{sub_style(bb.rjust(cc), styles: theme[:current])} #{f} "
@@ -678,11 +684,11 @@ module Squared
           tag.is_a?(Array) ? tag.first : tag
         end
 
-        def compose?(file)
+        def compose?(file = dockerfile)
           COMPOSEFILE.include?(File.basename(file))
         end
 
-        def bake?(file)
+        def bake?(file = dockerfile)
           BAKEFILE.include?(File.basename(file))
         end
       end