squared 0.6.2 → 0.6.4

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

@@ -3,6 +3,8 @@
 require 'json'
 require 'logger'
 
+require_relative 'support/class'
+
 module Squared
   module Workspace
     module Project
@@ -109,12 +111,13 @@ module Squared
 
         subtasks({
           'graph' => %i[run print].freeze,
-          'unpack' => %i[zip gz tar ext].freeze,
+          'unpack' => %i[zip gz tar ext],
           'asdf' => %i[set exec current update latest where reshim]
         })
 
-        attr_reader :name, :project, :workspace, :path, :theme, :group, :parent, :dependfile,
+        attr_reader :name, :workspace, :path, :theme, :group, :parent, :children, :dependfile,
                     :exception, :pipe, :verbose, :global
+        attr_accessor :project
 
         def initialize(workspace, path, name, *, group: nil, first: {}, last: {}, error: {}, common: ARG[:COMMON],
                        **kwargs)
@@ -380,11 +383,7 @@ module Squared
                       if flag == :run
                         graph args
                       else
-                        out, done = graph(args, out: [])
-                        out.map! do |val|
-                          n = done.index { |proj| val.match?(/ #{Regexp.escape(proj.name)}(?:@\d|\z)/) }
-                          n ? val.subhint(n.succ) : val
-                        end
+                        out = graph(args, out: [], order: {})
                         emphasize(out, title: path, right: true, border: borderstyle, sub: [
                           opt_style(theme[:header], /\A(#{Regexp.escape(path.to_s)})(.*)\z/),
                           opt_style(theme[:active], /\A(#{Regexp.escape(name)})(.*)\z/),
@@ -491,7 +490,7 @@ module Squared
               proj = self
               instance_eval(&blk) if block_given?
             end
-            @children << proj
+            children << proj
           end
           self
         end
@@ -561,10 +560,9 @@ module Squared
               flags = append_hash(flags, target: []).join(' ') if flags.is_a?(Hash)
               cmd = case opts
                     when Hash
-                      Array(cmd).push(flags)
-                                .concat(append_hash(opts, target: [], build: true))
-                                .compact
-                                .join(' ')
+                      [cmd, flags].concat(append_hash(opts, target: [], build: true))
+                                  .compact
+                                  .join(' ')
                     when Enumerable
                       cmd = Array(cmd).concat(opts.to_a)
                       cmd.map! { |val| "#{val} #{flags}" } if flags
@@ -618,7 +616,7 @@ module Squared
         end
 
         def doc(*, sync: invoked_sync?('doc'), **)
-          run_b(@doc, sync: sync, banner: from_base?('doc') ? verbose? : verbosetype > 0, from: :doc)
+          run_b(@doc, sync: sync, banner: from_base?('doc') ? verbose? : !silent?, from: :doc)
         end
 
         def lint(*, sync: invoked_sync?('lint'), **)
@@ -640,10 +638,10 @@ module Squared
           case @clean
           when Struct
             if (val = instance_eval(&@clean.block) || @clean.run)
-              temp = @clean
-              @clean = val
-              clean(*args, sync: sync, pass: true, **kwargs)
-              @clean = temp
+              @clean = @clean.tap do
+                @clean = val
+                clean(*args, sync: sync, pass: true, **kwargs)
+              end
             end
           when String
             run_s(@clean, sync: sync)
@@ -659,7 +657,7 @@ module Squared
                 entry = basepath(val = val.to_s)
                 if entry.directory? && val.match?(%r{[\\/]\z})
                   log&.warn "rm -rf #{entry}"
-                  rm_rf(entry, verbose: verbosetype > 0)
+                  rm_rf(entry, verbose: !silent?)
                 else
                   log&.warn "rm #{entry}"
                   (val.include?('*') ? Dir[entry] : [entry]).each do |file|
@@ -678,7 +676,7 @@ module Squared
           on :last, :clean unless pass
         end
 
-        def graph(start = [], tasks = nil, *, sync: invoked_sync?('graph'), pass: [], out: nil, **)
+        def graph(start = [], tasks = nil, *, sync: invoked_sync?('graph'), pass: [], out: nil, order: nil, **)
           env('GRAPH', strict: true) do |val|
             tasks ||= []
             split_escape(val) do |task|
@@ -696,12 +694,19 @@ module Squared
             data[name] << self
             on :first, :graph
           end
-          ret = graph_branch(self, data, tasks, out, sync: sync, pass: pass)
+          ret = graph_branch(self, data, tasks, out, sync: sync, pass: pass, order: order)
         rescue StandardError => e
           on_error(e, :graph, exception: true)
         else
           if out
-            [out, ret]
+            if order
+              out.map! do |val|
+                name = ret.find { |proj| val.match?(/ #{Regexp.escape(proj.name)}(?:@\d|\z)/) }&.name
+                (n = name && order[name]) ? val.subhint(n.succ) : val
+              end
+            else
+              [out, ret]
+            end
           else
             on :last, :graph
           end
@@ -770,7 +775,7 @@ module Squared
               break uri = url if data
             end
             unless data && (ext ||= URI.decode_www_form_component(URI.parse(uri).path[/\.([\w%]+)(?:\?|\z)/, 1]))
-              raise_error(data ? TypeError : RuntimeError, "no content#{data ? ' type' : ''}", hint: uri)
+              raise_error(data ? TypeError : RuntimeError, "no content#{' type' if data}", hint: uri)
             end
           end
           ext = ext.downcase
@@ -800,7 +805,7 @@ module Squared
             when 'zip', 'aar'
               session 'unzip', shell_quote(file), quote_option('d', target)
             when 'tar', /\A(?:t|tar\.)?[gx]z\z/
-              flags = +(verbose ? 'v' : '')
+              flags = +(silent? ? '' : 'v')
               if ext.end_with?('gz')
                 flags += 'z'
               elsif ext.end_with?('xz')
@@ -865,7 +870,7 @@ module Squared
             cmd << name
           else
             cmd << name
-            banner = flag == :update || flag == :reshim
+            banner = false if flag == :latest || flag == :where
           end
           success?(run(banner: banner, from: :"asdf:#{flag}"), flag == :set || flag == :reshim)
         end
@@ -918,16 +923,16 @@ module Squared
 
           cmd = cmd.target if cmd.is_a?(OptionPartition)
           if interactive && sync && (!@session || !option('y'))
-            title, y, hint = case interactive
-                             when Array
-                               interactive
-                             when String
-                               [interactive, 'N']
-                             else
-                               ['Run', 'Y']
-                             end
-            title = "#{title} #{sub_style(hint, styles: theme[:active])}" if hint
-            exit 1 unless confirm_basic("#{title}?", cmd, y)
+            msg, y, h = case interactive
+                        when Array
+                          interactive
+                        when String
+                          [interactive, 'N']
+                        else
+                          %w[Run Y]
+                        end
+            msg = "#{msg} #{sub_style(h, theme[:active])}" if h
+            exit 1 unless confirm_basic("#{msg}?", cmd, y)
           end
           cmd = session_done cmd
           log&.info cmd
@@ -1085,6 +1090,10 @@ module Squared
           @prod != false && workspace.prod?(pat: @prod, **scriptargs)
         end
 
+        def empty?
+          children.empty?
+        end
+
         def exclude?(*refs)
           !@exclude.empty? && has_value?(@exclude, refs.flatten)
         end
@@ -1159,7 +1168,7 @@ module Squared
           log_console(*args, pipe: kwargs[:pipe] || pipe)
         end
 
-        def run_s(*cmd, sync: true, banner: verbosetype > 0, from: nil, **kwargs)
+        def run_s(*cmd, sync: true, banner: !silent?, from: nil, **kwargs)
           cmd.flatten!
           case cmd.last
           when Hash, TrueClass, FalseClass
@@ -1204,11 +1213,11 @@ module Squared
           end
         end
 
-        def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], depth: 0,
+        def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], order: nil, depth: 0,
                          single: false, last: false, context: nil)
-          tag = ->(proj) { "#{proj.name}#{SEM_VER.match?(proj.version) ? "@#{proj.version}" : ''}" }
+          tag = ->(proj) { "#{proj.name}#{"@#{proj.version}" if SEM_VER.match?(proj.version)}" }
           script = ->(proj) { workspace.script_get(:graph, group: proj.group, ref: proj.allref)&.fetch(:graph, nil) }
-          dedupe = lambda do |name|
+          uniq = lambda do |name|
             next [] unless (ret = data[name])
 
             ret.dup.each do |proj|
@@ -1219,7 +1228,7 @@ module Squared
             ret
           end
           if depth == 0
-            items = dedupe.call(target.name) - done
+            items = uniq.call(target.name) - done
             single = items.size == 1
           else
             items = data[target.name] - done
@@ -1243,7 +1252,7 @@ module Squared
           items.each_with_index do |proj, i|
             next if done.include?(proj)
 
-            t = dedupe.call(name = proj.name)
+            t = uniq.call(name = proj.name)
             j = if out
                   if i == items.size.pred || (post = items[i.succ..-1] - done).empty?
                     true
@@ -1252,10 +1261,41 @@ module Squared
                   end
                 end
             unless target.name == name || (none = (t - done).empty?)
-              graph_branch(proj, data, tasks, out, sync: sync, pass: pass, done: done, depth: depth.succ,
+              graph_branch(proj, data, tasks, out, sync: sync, pass: pass, done: done, order: order, depth: depth.succ,
                                                    single: single, last: j == true, context: target)
             end
-            if !out
+            if out
+              if none
+                a, b, c, d = ARG[:GRAPH]
+                out << if depth == 0
+                         "#{i == items.size.pred ? d : c}#{b * 4} #{tag.call(proj)}"
+                       else
+                         s = +''
+                         k = 0
+                         final = data.keys.last
+                         while k < depth
+                           indent = k > 0 ? ((last && !j) || (j && k == depth.pred) || single) : j && last && depth == 1
+                           s += "#{indent || (last && data[final].last == context) ? ' ' : a}   "
+                           k += 1
+                         end
+                         s += "#{j ? d : c}#{b * 3} #{tag.call(proj)}"
+                       end
+              end
+              if order
+                n = order.size
+                order[name] ||= if proj.parent
+                                  if order[s = proj.parent.name]
+                                    order[s] += 1
+                                    n.pred
+                                  else
+                                    order[s] = n.succ
+                                    n
+                                  end
+                                else
+                                  n
+                                end
+              end
+            else
               (tasks || (subtasks = script.call(proj)) || (dev? ? %w[build copy] : %w[depend build])).each do |meth|
                 next if pass.include?(meth)
 
@@ -1271,21 +1311,6 @@ module Squared
                   proj.__send__(meth.to_sym, sync: sync)
                 end
               end
-            elsif none
-              a, b, c, d = ARG[:GRAPH]
-              out << if depth == 0
-                       "#{i == items.size.pred ? d : c}#{b * 4} #{tag.call(proj)}"
-                     else
-                       s = ''.dup
-                       k = 0
-                       final = data.keys.last
-                       while k < depth
-                         indent = k > 0 ? ((last && !j) || (j && k == depth.pred) || single) : j && last && depth == 1
-                         s += "#{indent || (last && data[final].last == context) ? ' ' : a}   "
-                         k += 1
-                       end
-                       s + "#{j ? d : c}#{b * 3} #{tag.call(proj)}"
-                     end
             end
             done << proj
           end
@@ -1301,16 +1326,22 @@ module Squared
               obj.enabled? ? [obj] : []
             else
               workspace.find(group: val, ref: val.to_sym)
+            end.sort do |a, b|
+              if a.parent == b
+                -1
+              else
+                b.parent == a ? 1 : 0
+              end
             end.each do |proj|
               next if pass.include?(name = proj.name)
 
               if proj.graph? && !data.key?(name) && !root.include?(name)
                 graph_collect(proj, data: data, pass: pass, root: root + [name, target.name])
               end
-              unless (objs = data.fetch(name, [])).include?(target)
-                deps << proj
-                deps.concat(objs)
-              end
+              next if (objs = data.fetch(name, [])).include?(target)
+
+              deps << proj
+              deps.concat(objs)
             end
           end
           deps.uniq!
@@ -1346,11 +1377,13 @@ module Squared
                   ENV[name] || ENV.fetch(key, '')
                 end
           if !equals.nil?
-            ret = ret == equals.to_s
+            ret = Array(equals).any? { |val| ret == val.to_s }
           elsif ret.empty? || (ignore && Array(ignore).any? { |val| ret == val.to_s })
             ret = default
           end
-          block_given? && !ret.nil? ? yield(ret) : ret
+          return yield ret if block_given? && !ret.nil?
+
+          ret
         end
 
         def session(*cmd, prefix: cmd.first, main: true, path: true, options: true)
@@ -1364,11 +1397,13 @@ module Squared
               if val.start_with?('-')
                 ret.merge(shell_parse(val))
               else
-                split_escape(val) { |opt| ret.last(fill_option(opt), /\A(--?[^\[\]=\s-][^\[\]=\s]*)[=\s].+\z/m) }
+                split_escape(val) { |opt| ret.last(fill_option(opt), /\A(--?[^=\s-][^=\s]*)[=\s].+\z/m) }
               end
             end
           end
-          main ? @session = ret : ret
+          return ret unless main
+
+          @session = ret
         end
 
         def session_output(*cmd, **kwargs)
@@ -1497,7 +1532,7 @@ module Squared
               val
             end
           end
-          (lines << sub_style(ARG[:BORDER][1] * n, styles: border)).join("\n")
+          (lines << sub_style(ARG[:BORDER][1] * n, border)).join("\n")
         end
 
         def print_footer(*lines, sub: nil, reverse: false, right: false, border: borderstyle, **)
@@ -1505,30 +1540,32 @@ module Squared
           sub = as_a sub
           lines.map! do |val|
             s = right ? val.rjust(n) : val.ljust(n)
-            sub.each { |h| s = sub_style(s, **h) }
+            sub.each { |h| sub_style!(s, **h) }
             s
           end
-          [sub_style(ARG[:BORDER][1] * n, styles: border)].concat(lines)
-                                                          .tap { |ret| ret.reverse! if reverse }
-                                                          .join("\n")
+          [sub_style(ARG[:BORDER][1] * n, border)].concat(lines)
+                                                  .tap { |ret| ret.reverse! if reverse }
+                                                  .join("\n")
         end
 
         def print_status(*args, from: nil, **kwargs)
-          return if stdin?
+          return if stdin? || silent?
 
           case from
           when :outdated
             out = print_footer("major #{args[0]} / minor #{args[1]} / patch #{args[2]}", right: true).split("\n")
-            out[1] = sub_style(out[1], **opt_style(theme[:major], /^( +major )(\d+)(.+)$/, 2))
-            out[1] = sub_style(out[1], **opt_style(theme[:active], /^(.+)(minor )(\d+)(.+)$/, 3))
-            out[1] = sub_style(out[1], **opt_style(theme[:current], /^(.+)(patch )(\d+)(.+)$/, 3)) if theme[:current]
-            puts out
+            sub_style!(out[1], **opt_style(theme[:major], /^( +major )(\d+)(.+)$/, 2))
+            sub_style!(out[1], **opt_style(theme[:active], /^(.+)(minor )(\d+)(.+)$/, 3))
+            sub_style!(out[1], **opt_style(theme[:current], /^(.+)(patch )(\d+)(.+)$/, 3)) if theme[:current]
           when :completed
-            return unless verbose && kwargs[:start]
+            return unless kwargs[:start]
 
-            puts log_message(Logger::INFO, *args, sub_style('completed', styles: theme[:active]),
-                             subject: kwargs[:subject], hint: time_format(time_epoch - kwargs[:start]))
+            out = log_message(Logger::INFO, *args, sub_style('completed', theme[:active]),
+                              subject: kwargs[:subject], hint: time_format(time_epoch - kwargs[:start]))
+          else
+            return
           end
+          puts out
         end
 
         def format_desc(action, flag, opts = nil, **kwargs)
@@ -1621,7 +1658,7 @@ module Squared
         end
 
         def empty_status(msg, title, obj, always: false)
-          "#{msg}#{!always && (!obj || obj == 0 || obj.to_s.empty?) ? '' : message(hint: message(title, obj.to_s))}"
+          "#{msg}#{message(hint: message(title, obj.to_s)) unless !always && (!obj || obj == 0 || obj.to_s.empty?)}"
         end
 
         def append_repeat(flag, opts, target: @session)
@@ -1828,22 +1865,34 @@ module Squared
         end
 
         def confirm_basic(msg, target, default = 'Y', style: :inline, **kwargs)
-          confirm("#{msg} [#{sub_style(target.to_s, styles: theme[style])}]", default, **kwargs)
+          confirm("#{msg} [#{sub_style(target.to_s, style.is_a?(Symbol) ? theme[style] : style)}]", default, **kwargs)
         end
 
-        def confirm_outdated(pkg, ver, rev, cur = nil, lock: false, col1: 0, **kwargs)
-          a = sub_style(case rev
-                        when 1
-                          'MAJOR'
-                        when 2
-                          'MINOR'
-                        else
-                          'PATCH'
-                        end, styles: (rev == 1 && theme[:major]) || theme[:header])
-          b = sub_style(pkg.ljust(col1), styles: theme[:inline])
-          c = lock ? sub_style((cur || 'locked').rjust(7), styles: color(:red)) : cur&.rjust(7)
-          d = rev == 1 || lock ? 'N' : 'Y'
-          confirm("#{a}: #{b}#{c} #{sub_style(ver.rjust(col1 > 0 ? 10 : 0), styles: theme[:inline])}  ", d, **kwargs)
+        def confirm_outdated(pkg, ver, type, cur = nil, lock: false, col0: 0, col1: 0, col2: nil, col3: 0, col4: 0,
+                             **kwargs)
+          h = sub_style(semrev(type).upcase, (type == 1 && theme[:major]) || theme[:header])
+          case col0
+          when 0
+            col0 = "#{h}: "
+          when Numeric
+            puts h
+            col0 = ' ' * col0
+          else
+            puts h
+          end
+          b = sub_style pkg.ljust(col1), theme[:inline]
+          cur ||= 'locked' if lock
+          c = if cur
+                cur = cur.ljust(col2 || cur.size.succ)
+                lock ? sub_style(cur, color(:red)) : cur
+              end
+          d = type == 1 || lock ? 'N' : 'Y'
+          e = "#{col0}#{b}#{c}#{sub_style(col1 > 0 ? ver.ljust(col3) : ver.rjust(ver.size.succ), theme[:inline])}"
+          confirm("#{e}#{col4 > 0 ? ' ' * [col4 - e.stripstyle.size - 1, 2].max : '  '}", d, **kwargs)
+        end
+
+        def confirm_semver(msg, type, style: (type == 1 && theme[:major]) || :inline, timeout: 0, **kwargs)
+          confirm_basic(msg, semrev(type), type == 1 ? 'N' : 'Y', style: style, timeout: timeout, **kwargs)
         end
 
         def choice_index(msg, list, values: nil, accept: nil, series: false, trim: nil, column: nil, multiple: false,
@@ -1862,12 +1911,12 @@ module Squared
             ret = ret.first unless multiple
           end
           if accept
-            hint = Array(ret).map { |val| sub_style(val.to_s, styles: theme[:inline]) }.join(', ')
+            hint = Array(ret).map { |val| sub_style(val.to_s, theme[:inline]) }.join(', ')
             accept = Array(accept).map { |val| Array(val) }
             ret = Array(ret) if accept.any? { |val| val[1] == true }
             loop do
               item = accept.first
-              c = confirm("#{item[0]}#{hint ? " [#{hint}]" : ''}", item[2] ? 'Y' : 'N')
+              c = confirm("#{item[0]}#{" [#{hint}]" if hint}", item[2] ? 'Y' : 'N')
               if item[1] == true
                 ret << c
               elsif !c
@@ -2012,6 +2061,27 @@ module Squared
           join ? ret.join : ret
         end
 
+        def semtype(cur, lat)
+          if semmajor?(cur, lat)
+            1
+          else
+            cur[2] == lat[2] ? 3 : 2
+          end
+        end
+
+        def semrev(type)
+          case type
+          when 1
+            'major'
+          when 2
+            'minor'
+          when 3
+            'patch'
+          else
+            'unknown'
+          end
+        end
+
         def semgte?(val, other)
           semcmp(val, other) != 1
         end
@@ -2028,6 +2098,30 @@ module Squared
           workspace.windows? ? '=' : '^'
         end
 
+        def shortname(*args, suffix: '?', delim: ',', pass: false)
+          return unless TASK_METADATA || pass
+
+          args.map! do |ch|
+            "#{ch}/#{case ch
+                     when 'i'
+                       'nteractive'
+                     when 's'
+                       'elect'
+                     when 'u'
+                       'pdate'
+                     when 'h'
+                       'ide'
+                     when 'f'
+                       'orce'
+                     when 'd'
+                       'ry-run'
+                     else
+                       next
+                     end}#{suffix}"
+          end.compact
+             .join(delim)
+        end
+
         def printsucc
           @@print_order += 1
         end
@@ -2197,7 +2291,7 @@ module Squared
         end
 
         def theme_set(common)
-          @theme = if !verbose
+          @theme = if silent?
                      {}
                    elsif common
                      workspace.theme
@@ -2232,7 +2326,7 @@ module Squared
                   __send__ key
                 end
               end
-              next if (items = @children.select { |item| item.task_include?(key) }).empty?
+              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) }
@@ -2270,7 +2364,7 @@ module Squared
 
         def runnable?(val)
           case val
-          when String, Enumerable, Proc, Method
+          when String, Enumerable, Proc, Method, Struct
             true
           else
             false
@@ -2313,7 +2407,13 @@ module Squared
           else
             $?.success?
           end.tap do |ret|
-            print_success if ret && stdout? && banner? && cond.none? { |val| val == false }
+            next unless cond.none? { |val| val == false }
+
+            if block_given?
+              yield ret
+            elsif ret && stdout? && banner?
+              print_success
+            end
           end
         end
 
@@ -2337,6 +2437,10 @@ module Squared
           verbosetype > 1
         end
 
+        def silent?
+          verbosetype == 0
+        end
+
         def warning?
           workspace.warning
         end
@@ -2345,12 +2449,7 @@ module Squared
           return false unless target.is_a?(Enumerable)
 
           args = args.first if args.size == 1 && args.first.is_a?(Enumerable)
-          case target
-          when Hash
-            args.is_a?(Enumerable) ? args.any? { |obj| target.value?(obj) } : target.value?(args)
-          else
-            args.is_a?(Enumerable) ? args.any? { |obj| target.include?(obj) } : target.include?(args)
-          end
+          args.any? { |obj| target.include?(obj) }
         end
 
         def has_value!(target, *args, first: false)