squared 0.4.5 → 0.4.7

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

@@ -2,7 +2,9 @@
 
 require 'json'
 require 'date'
+require 'time'
 require 'logger'
+require 'digest'
 
 module Squared
   module Workspace
@@ -13,6 +15,7 @@ module Squared
         include Shell
         include Prompt
         include Utils
+        include Support
         include Rake::DSL
 
         VAR_SET = %i[parent global envname dependfile dependindex theme run script env pass].freeze
@@ -70,7 +73,7 @@ module Squared
                     :group, :parent, :dependfile
 
         def initialize(workspace, path, name, *, group: nil, graph: nil, pass: nil, exclude: nil, release: nil,
-                       archive: nil, first: {}, last: {}, error: {}, common: ARG[:COMMON], **kwargs)
+                       archive: nil, verbose: nil, first: {}, last: {}, error: {}, common: ARG[:COMMON], **kwargs)
           @path = path
           @workspace = workspace
           @name = name.to_s.freeze
@@ -97,7 +100,7 @@ module Squared
                      when nil
                        workspace.verbose
                      when String
-                       env_pipe(verbose, workspace.verbose, strict: true, index: true)
+                       env_bool(verbose, workspace.verbose, strict: true, index: true)
                      else
                        verbose
                      end
@@ -192,19 +195,24 @@ module Squared
           return if @log
 
           log = log.is_a?(Hash) ? log.dup : { file: log }
-          unless (file = env('LOG_FILE'))
-            file = case env('LOG_AUTO')
-                   when 'y', 'year'
-                     "#{@name}-#{Date.today.year}.log"
-                   when 'm', 'month'
-                     "#{@name}-#{Date.today.strftime('%Y-%m')}.log"
-                   when 'd', 'day', '1'
-                     "#{@name}-#{Date.today}.log"
-                   end
-          end
-          if file ||= log[:file]
-            file = Date.today.strftime(file)
-            file = (dir = env('LOG_DIR')) ? @workspace.home.join(dir, file) : @workspace.home.join(file)
+          if (file = env('LOG_FILE'))
+            file = Time.now.strftime(file)
+          elsif (val = env('LOG_AUTO'))
+            file = "#{@name}-%s.log" % [case val
+                                        when 'y', 'year'
+                                          Date.today.year
+                                        when 'm', 'month'
+                                          Date.today.strftime('%Y-%m')
+                                        when 'd', 'day', '1'
+                                          Date.today
+                                        else
+                                          val.include?('%') ? Time.now.strftime(val) : Time.now.strftime('%FT%T%:z')
+                                        end]
+          elsif (val = log[:file])
+            file = val.is_a?(String) ? Time.now.strftime(val) : "#{@name}-#{Date.today}.log"
+          end
+          if file
+            file = (val = env('LOG_DIR')) ? @workspace.home.join(val, file) : @workspace.home.join(file)
             begin
               file = file.realdirpath
             rescue StandardError => e
@@ -395,7 +403,7 @@ module Squared
 
             run_b(@run, sync: sync, from: from) if series?(@run)
             args = @output
-            banner = verbose == 1 if task_invoked?('build', 'build:sync', 'default')
+            banner = verbosetype > 1 if task_invoked?('build', 'build:sync', 'default')
           end
           if args.all? { |val| val.is_a?(Array) }
             cmd = []
@@ -450,7 +458,7 @@ module Squared
         end
 
         def archive(*, sync: invoked_sync?('archive'), **)
-          return unless @archive.is_a?(Array)
+          return unless @archive.is_a?(Hash)
 
           unpack(path, **@archive, sync: sync, from: :archive)
         end
@@ -488,12 +496,11 @@ module Squared
             end
           else
             if @clean.is_a?(Enumerable) && !series?(@clean)
-              as_a(@clean).each do |val|
-                val = val.to_s
-                path = basepath(val)
+              @clean.each do |val|
+                path = basepath(val = val.to_s)
                 if path.directory? && val.match?(%r{[\\/]$})
                   log&.warn "rm -rf #{path}"
-                  path.rmtree(verbose: verbose)
+                  rm_rf(path, verbose: verbose)
                 else
                   log&.warn "rm #{path}"
                   (val.include?('*') ? Dir[path] : [path]).each do |file|
@@ -519,15 +526,15 @@ module Squared
             tasks ||= []
             split_escape(val).each do |task|
               if ref?(task.to_sym) && (script = workspace.script_get(:graph, ref: task.to_sym))
-                tasks += script[:graph]
+                tasks.concat(script[:graph])
               else
                 tasks << task
               end
             end
           end
-          pass += split_escape(val) if (val = env('GRAPH', suffix: 'PASS'))
+          pass.concat(split_escape(val)) if (val = env('GRAPH', suffix: 'PASS'))
           start, neg = start.partition { |name| !name.start_with?('-') }
-          data = graph_collect(self, start, pass: neg.map { |name| name[1..-1] })
+          data = graph_collect(self, start, pass: neg.map! { |name| name[1..-1] })
           unless out
             data[name] << self
             on :first, :graph
@@ -582,11 +589,10 @@ module Squared
           if (val = env('HEADERS')) && (val = parse_json(val, hint: "HEADERS_#{@envname}"))
             headers = val
           end
-          require 'open-uri'
           data = nil
           (uri = as_a(uri)).each_with_index do |url, index|
             last = index == uri.size - 1
-            URI.open(url, headers) do |f|
+            fetch_uri(url, headers) do |f|
               data = f.read
               if algo && algo.hexdigest(data) != digest
                 data = nil
@@ -610,7 +616,7 @@ module Squared
               raise_error('no content', hint: url)
             end
           end
-          ext ||= URI.parse(uri).path[/^.+?\.((?:tar\.)?\w+)$/i, 1]
+          ext ||= URI.parse(uri).path[/\.(\w+)(\?|$)/i, 1]
           if (n = env("#{ext == 'zip' || ext == '7z' ? ext.upcase : 'TAR'}_DEPTH", ignore: false))
             depth = n.to_i
           end
@@ -624,7 +630,7 @@ module Squared
               target.rmtree
               target.mkpath
             end
-            case ext
+            case ext.downcase
             when 'zip', 'aar'
               session 'unzip', shell_quote(file.path), quote_option('d', target)
             when 'tar', 'tgz', 'tar.gz', 'tar.xz', 'gz', 'xz'
@@ -648,8 +654,8 @@ module Squared
               break unless entry.directory?
 
               dest = target.join(File.basename(file.path))
-              FileUtils.mv(entry, dest)
-              dest.children.each { |child| FileUtils.mv(child, target) }
+              mv(entry, dest)
+              dest.children.each { |child| mv(child, target) }
               dest.rmdir
               target = entry
               depth -= 1
@@ -1043,7 +1049,7 @@ module Squared
               next if (objs = data.fetch(proj.name, [])).include?(target)
 
               deps << proj
-              deps += objs
+              deps.concat(objs)
             end
           end
           data[target.name] = deps.uniq.reject { |proj| proj == target }
@@ -1066,8 +1072,8 @@ module Squared
         end
 
         def session(*cmd, prefix: cmd.first, main: true, path: true, options: true)
-          prefix = prefix.to_s.upcase
-          if path && (val = PATH[prefix] || PATH[prefix.to_sym])
+          prefix = stripext(prefix.to_s).upcase
+          if path && (val = ENV["PATH_#{prefix}"] || PATH[prefix] || PATH[prefix.to_sym])
             cmd[0] = shell_quote(val, force: false)
           end
           ret = JoinSet.new(cmd.flatten(1))
@@ -1077,9 +1083,9 @@ module Squared
           main ? @session = ret : ret
         end
 
-        def session_delete(*list, target: @session)
+        def session_delete(*args, target: @session)
           ret = []
-          list.each do |val|
+          args.each do |val|
             pat = /^#{Regexp.escape(shell_option(val))}(?: |=|$)/
             if (key = target.find { |opt| opt.match?(pat) })
               target.delete(key)
@@ -1101,120 +1107,25 @@ module Squared
           cmd.done
         end
 
-        def option(*args, prefix: @session&.first, **kwargs)
+        def option(*args, target: @session, prefix: target&.first, **kwargs)
           if prefix
             args.each do |val|
-              ret = env("#{prefix}_#{val.gsub(/\W/, '_')}".upcase, **kwargs)
+              ret = env("#{stripext(prefix)}_#{val.gsub(/\W/, '_')}".upcase, **kwargs)
               return ret if ret
             end
           end
           nil
         end
 
-        def option_sanitize(opts, list, target: @session, no: nil, single: nil, args: false, first: false, pass: ['='])
-          ret = []
-          reg = []
-          bare = []
-          e = []
-          b = []
-          m = []
-          p = []
-          q = []
-          qq = []
-          i = []
-          f = []
-          si = []
-          list = list.map do |val|
-            x, y = val.split('|')
-            if y
-              if (n = val.index('='))
-                x += val[n..-1]
-              end
-              [x, y]
-            else
-              x
-            end
-          end
-          list.flatten.each do |val|
-            if (n = val.index('='))
-              flag = val[0, n]
-              case val[n + 1]
-              when 'e'
-                e << flag
-              when 'b'
-                b << flag
-              when 'm'
-                m << flag
-              when 'q'
-                qq << flag if val[n + 2] == 'q'
-                q << flag
-              when 'p'
-                p << flag
-              when 'i'
-                i << flag
-              when 'f'
-                f << flag
-              when 'n'
-                si << flag
-              else
-                reg << Regexp.escape(flag)
-              end
-              bare << flag if val.end_with?('?')
-            else
-              bare << val
-            end
-          end
-          no = (no || []).map { |val| (n = val.index('=')) ? val[0, n] : val }
-          bare += no
-          found = false
-          opts.each do |opt|
-            next ret << opt if found
-
-            if single&.match?(opt)
-              target << "-#{opt}"
-            elsif bare.include?(opt)
-              target << (opt.size == 1 ? "-#{opt}" : "--#{opt}")
-            elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
-              target << "--no-#{name}"
-            else
-              if opt =~ /\A([^=]+)=(.+)\z/
-                key = $1
-                val = $2
-                match = ->(flag, pat) { flag.include?(key) && pat.match?(val) }
-                if e.include?(key)
-                  target << shell_option(key, val)
-                elsif q.include?(key)
-                  target << quote_option(key, val, double: qq.include?(key))
-                elsif p.include?(key)
-                  target << quote_option(key, basepath(val))
-                elsif m.include?(key)
-                  target << basic_option(key, val, merge: true)
-                elsif b.include?(key) || match.(i, /^\d+$/) || match.(f, /^\d*(?:\.\d+)?$/) || match.(si, /^-?\d+$/)
-                  target << basic_option(key, val)
-                else
-                  ret << opt
-                end
-                opt = key
-              else
-                ret << opt
-                found = true if args
-              end
-              found = true if first && pass.none? { |s| opt.include?(s) }
-            end
-          end
-          [ret, reg.empty? ? /\A\s+\z/ : /^(#{reg.join('|')})=(.+)$/]
+        def option_sanitize(opts, list, target: @session, **kwargs)
+          op = OptionPartition.new(opts, list, target, project: self, **kwargs)
+          [op.extras, op.values]
         end
 
-        def option_clear(opts, target: @session, pass: true, append: false, **kwargs)
-          return if opts.empty?
-
-          kwargs[:subject] ||= target&.first
-          kwargs[:hint] ||= 'unrecognized'
-          warn log_message(Logger::WARN, opts.join(', '), pass: true, **kwargs)
-          append_value(opts, delim: true) if append
-          return if pass || confirm("Run? [#{sub_style(target, styles: theme[:inline])}] [y/N] ", 'N', timeout: 30)
+        def option_clear(opts, target: @session, **kwargs)
+          return unless target
 
-          raise_error 'user cancelled'
+          OptionPartition.clear(target, opts, styles: theme[:inline], **kwargs)
         end
 
         def print_item(*val)
@@ -1235,7 +1146,7 @@ module Squared
           n = Project.max_width(lines)
           ch = ' ' * pad
           index = -1
-          out = lines.map do |val|
+          lines.map! do |val|
             index += 1
             val = ch + val.ljust(n - (pad * 2)) + ch
             if styles && (pad == 1 || index == 0)
@@ -1244,8 +1155,7 @@ module Squared
               val
             end
           end
-          out << sub_style(ARG[:BORDER][1] * n, styles: border)
-          out.join("\n")
+          (lines << sub_style(ARG[:BORDER][1] * n, styles: border)).join("\n")
         end
 
         def print_footer(*lines, sub: nil, reverse: false, right: false, **kwargs)
@@ -1330,7 +1240,7 @@ module Squared
             out = ["No #{type} were found:", '']
             unless grep.empty?
               i = 0
-              out += grep.map { |s| "#{i += 1}. #{s}" }
+              out.concat(grep.map { |s| "#{i += 1}. #{s}" })
               out << ''
             end
             if from
@@ -1357,7 +1267,6 @@ module Squared
         end
 
         def append_hash(data, target: @session, build: false)
-          target ||= []
           if build && (type = env('BUILD', suffix: 'TYPE') || ENV['BUILD_TYPE'])
             type = "__#{type}__"
             if (extra = data[type] || data[type.to_sym]).is_a?(Hash)
@@ -1410,22 +1319,17 @@ module Squared
           end
         end
 
-        def append_value(*list, target: @session, delim: false, escape: false, quote: true)
-          return if (list = list.flatten).empty?
+        def append_value(*list, target: @session, **kwargs)
+          return unless target
 
-          target << '--' if delim && !target.include?('--')
-          list.map do |val|
-            item = escape ? shell_escape(val, quote: quote) : shell_quote(val)
-            target << item
-            item
-          end
+          OptionPartition.append(target, *list, **kwargs)
         end
 
         def append_first(*list, target: @session, flag: true, equals: false, escape: true, quote: true, force: true,
                          **kwargs)
-          return if (list = list.flatten).empty?
+          return if list.empty?
 
-          list.each do |opt|
+          list.flatten.each do |opt|
             next unless (val = option(opt, **kwargs))
 
             return target << (if flag
@@ -1439,11 +1343,11 @@ module Squared
 
         def append_option(*list, target: @session, no: false, equals: false, escape: true, quote: true, force: true,
                           **kwargs)
-          return if (list = list.flatten).empty?
+          return if list.empty?
 
           ret = []
-          list.each do |flag|
-            next unless (val = option(flag, **kwargs))
+          list.flatten.each do |flag|
+            next unless (val = option(flag, target: target, **kwargs))
 
             if val == '0' && no
               flag = "no-#{flag}"
@@ -1455,50 +1359,52 @@ module Squared
         end
 
         def append_nocolor(target: @session)
-          target << '--no-color' if !ARG[:COLOR] || stdin? || option('no-color', ignore: false)
+          target << '--no-color' if !ARG[:COLOR] || stdin? || option('color', target: target, equals: '0')
         end
 
         def merge_opts(base, data)
-          return data unless base
-          return base unless data
-
-          ret = case data
-                when String
-                  case base
-                  when String
-                    "#{base} #{data}"
-                  when Hash
-                    "#{append_hash(base).join(' ')} #{data}"
-                  when Enumerable
-                    "#{base.to_a.join(' ')} #{data}"
-                  end
-                when Hash
-                  case base
-                  when String
-                    "#{base} #{append_hash(data).join(' ')}"
-                  when Hash
-                    base.merge(data)
-                  when Enumerable
-                    base.to_a + append_hash(data)
-                  end
-                when Enumerable
-                  case base
-                  when String
-                    "#{base} #{data.to_a.join(' ')}"
-                  when Hash
-                    "#{append_hash(base).join(' ')} #{data.to_a.join(' ')}"
-                  when Enumerable
-                    base.to_a + data.to_a
-                  end
-                else
-                  base
-                end
-          ret || data
+          case data
+          when String
+            case base
+            when String
+              "#{base} #{data}"
+            when Hash
+              "#{append_hash(base).join(' ')} #{data}"
+            when Enumerable
+              "#{base.to_a.join(' ')} #{data}"
+            else
+              data
+            end
+          when Hash
+            case base
+            when String
+              "#{base} #{append_hash(data).join(' ')}"
+            when Hash
+              base.merge(data)
+            when Enumerable
+              Set.new(base.to_a + append_hash(data)).to_a
+            else
+              data
+            end
+          when Enumerable
+            case base
+            when String
+              "#{base} #{data.to_a.join(' ')}"
+            when Hash
+              "#{append_hash(base).join(' ')} #{data.to_a.join(' ')}"
+            when Enumerable
+              Set.new(base.to_a + data.to_a).to_a
+            else
+              data
+            end
+          else
+            base
+          end
         end
 
         def collect_hash(data, pass: [])
           ret = []
-          data.each { |key, val| ret += val unless pass.include?(key) }
+          data.each { |key, val| ret.concat(val) unless pass.include?(key) }
           ret
         end
 
@@ -1512,6 +1418,15 @@ module Squared
           ret
         end
 
+        def fetch_uri(*args, **kwargs, &blk)
+          require 'open-uri'
+          if RUBY_VERSION < '2.5'
+            open(*args, **kwargs, &blk)
+          else
+            URI.open(*args, **kwargs, &blk)
+          end
+        end
+
         def param_guard(action, flag, args: nil, key: nil, pat: nil, values: nil)
           if args && key
             val = args.fetch(key, nil)
@@ -1538,12 +1453,11 @@ module Squared
           end
         end
 
-        def relativepath(*files, all: false)
-          return [] if files.empty?
+        def relativepath(*list, all: false)
+          return [] if list.empty?
 
-          pat = /^#{Regexp.escape(File.join(path, ''))}/
-          files.flatten.map { |val| Pathname.new(val) }.select { |val| projectpath?(val) }.map do |val|
-            val = val.absolute? ? val.to_s.sub(pat, '') : val.to_s
+          list.flatten.map! { |val| Pathname.new(val) }.select { |val| projectpath?(val) }.map! do |val|
+            val = val.absolute? ? val.relative_path_from(path).to_s : val.to_s
             val = val[2..-1] if val.start_with?('./')
             val = "#{val}*" if all && val.end_with?('/')
             val
@@ -1552,11 +1466,11 @@ module Squared
 
         def projectmap(files, parent: false, pass: true)
           unless parent
-            project = files.select { |val| projectpath?(val) }
-            raise_error 'pathspec not within worktree' unless pass || files.size == project.size
-            files = project
+            proj = files.select { |val| projectpath?(val) }
+            raise_error 'pathspec not within worktree' unless pass || files.size == proj.size
+            files = proj
           end
-          files.map { |val| val == '.' ? '.' : shell_quote(basepath(val.strip)) }
+          files.map { |val| val == '.' ? '.' : shell_quote(basepath(val)) }
         end
 
         def semver(val)
@@ -1592,11 +1506,22 @@ module Squared
         end
 
         def colormap(val)
-          val.compact.map { |s| color(s) }.flatten
+          val.compact.map! { |s| color(s) }.flatten
         end
 
         def epochtime
-          DateTime.now.strftime('%Q').to_i
+          Time.now.strftime('%s%L').to_i
+        end
+
+        def verbosetype
+          case verbose
+          when true
+            1
+          when Numeric
+            verbose.succ
+          else
+            0
+          end
         end
 
         def on(event, from, *args, **kwargs)
@@ -1740,13 +1665,14 @@ module Squared
               next if (items = @children.select { |item| item.task_include?(key) }).empty?
 
               ws.task_desc(@desc, action, 'workspace')
-              task task_join(action, 'workspace') => items.map { |item| task_join(item.name, action) }
+              task task_join(action, 'workspace') => items.map! { |item| task_join(item.name, action) }
             end
           end
         end
 
         def projectpath?(val)
-          Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.start_with?('..')
+          val = Pathname.new(val).cleanpath
+          val.absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.start_with?(File.join('..', ''))
         end
 
         def semmajor?(cur, want)
@@ -1766,11 +1692,8 @@ module Squared
           val.is_a?(Array) && val.all? { |p| p.is_a?(Proc) || p.is_a?(Method) }
         end
 
-        def session_arg?(*list, target: @session, value: false)
-          list.any? do |val|
-            pat = /^#{Regexp.escape(shell_option(val))}#{value ? '[ =].' : '(?:[ =]|$)'}/
-            target.any? { |opt| opt.match?(pat) }
-          end
+        def session_arg?(*args, target: @session, **kwargs)
+          !!target && OptionPartition.arg?(target, *args, **kwargs)
         end
 
         def from_sync?(*val)