squared 0.0.10 → 0.0.12

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

@@ -8,21 +8,22 @@ module Squared
   module Workspace
     module Project
       class Base
-        include Common
-        include Format
+        include Common::Format
         include System
         include Shell
-        include Task
         include Utils
         include ::Rake::DSL
 
         SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?/.freeze
 
-        VAR_SET = %i[parent global envname theme run script env depend doc test copy clean].freeze
+        VAR_SET = %i[parent global envname dependfile theme run script env depend graph doc test copy clean].freeze
         private_constant :VAR_SET
 
         class << self
           def populate(*); end
+          def batchargs(*); end
+          def aliasargs(*); end
+          def bannerargs(*); end
 
           def tasks
             [].freeze
@@ -42,32 +43,39 @@ module Squared
           end
 
           def to_s
-            super.to_s.match(/[^:]+$/)[0]
+            super.match(/[^:]+$/)[0]
+          end
+
+          def config?(*)
+            false
           end
         end
 
+        @@tasks = {
+          "#{ref}": {
+            graph: %i[run print].freeze
+          }.freeze
+        }
         @@print_order = 0
-        @@tasks = {}
 
-        attr_reader :name, :project, :workspace, :group, :path, :theme, :parent
-        attr_accessor :exception, :pipe, :verbose
+        attr_reader :name, :project, :workspace, :path, :exception, :pipe, :theme, :group, :parent,
+                    :dependfile, :verbose
 
-        def initialize(name, path, workspace, *,
-                       group: nil, verbose: nil, pass: nil, exclude: nil,
-                       common: Common::KEY[:COMMON], pipe: Common::KEY[:PIPE], **kwargs)
-          @name = name.to_s
+        def initialize(workspace, path, name, *, group: nil, graph: nil, pass: nil, exclude: nil,
+                       common: ARG[:COMMON], **kwargs)
           @path = path
-          @project = @path.basename.to_s
           @workspace = workspace
-          @group = group&.to_s
+          @name = name.to_s.freeze
+          @project = @path.basename.to_s.freeze
+          @group = group&.to_s.freeze
           @depend = kwargs[:depend]
           @doc = kwargs[:doc]
           @test = kwargs[:test]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
-          @exception = workspace.exception
-          @pipe = env_pipe(pipe, workspace.pipe)
-          @verbose = verbose.nil? ? workspace.verbose : verbose
+          @exception = kwargs.key?(:exception) ? env_bool(kwargs[:exception]) : workspace.exception
+          @pipe = kwargs.key?(:pipe) ? env_pipe(kwargs[:pipe]) : workspace.pipe
+          @verbose = kwargs.key?(:verbose) ? kwargs[:verbose] : workspace.verbose
           @theme = if !@verbose
                      {}
                    elsif common
@@ -78,12 +86,16 @@ module Squared
           @output = []
           @ref = []
           @children = []
+          @graph = if graph
+                     as_a(graph, workspace.prefix ? ->(val) { workspace.task_name(val).to_sym } : :to_sym).freeze
+                   end
           @pass = (pass ? as_a(pass, :to_sym) : []).freeze
           @exclude = (exclude ? as_a(exclude, :to_sym) : []).freeze
-          @envname = @name.gsub(/[^\w]+/, '_').upcase
-          @desc = @name.split(':').join(' => ')
+          @envname = @name.gsub(/[^\w]+/, '_').upcase.freeze
+          @desc = (@name.include?(':') ? @name.split(':').join(ARG[:SPACE]) : @name).freeze
+          @parent = nil
           @global = false
-          run_set kwargs[:run], kwargs[:env]
+          run_set(kwargs[:run], kwargs[:env], opts: kwargs.fetch(:opts, true))
           initialize_ref(Base.ref)
         end
 
@@ -93,7 +105,7 @@ module Squared
 
         def initialize_build(ref, **kwargs)
           initialize_ref(ref)
-          if (@script = @workspace.script(group: @group, ref: ref))
+          if (@script = @workspace.script_get(group: @group, ref: ref))
             if @script[:log] && !kwargs.key?(:log)
               kwargs[:log] = @script[:log]
               @log = nil
@@ -107,7 +119,7 @@ module Squared
           initialize_logger(**kwargs)
           return if @output[0] == false
 
-          data = @workspace.script(*@ref, @group)
+          data = @workspace.script_find(*@ref, @group)
           if @output[0].nil?
             if (scr = data[:script])
               @global = true
@@ -140,8 +152,8 @@ module Squared
           return if @log
 
           log = log.is_a?(::Hash) ? log.dup : { file: log }
-          if (file = env('LOG_FILE')).nil? && (auto = env('LOG_AUTO'))
-            file = case auto
+          unless (file = env('LOG_FILE'))
+            file = case env('LOG_AUTO')
                    when 'y', 'year'
                      "#{@name}-#{Date.today.year}.log"
                    when 'm', 'month'
@@ -152,7 +164,7 @@ module Squared
           end
           if file ||= log[:file]
             file = Date.today.strftime(file)
-            file = (dir = env('LOG_DIR')) ? Pathname.new(dir).join(file) : Pathname.new(file)
+            file = (dir = env('LOG_DIR')) ? @workspace.home.join(dir, file) : @workspace.home.join(file)
             begin
               file = file.realdirpath
             rescue StandardError => e
@@ -163,7 +175,7 @@ module Squared
             end
           end
           log[:progname] ||= @name
-          if (val = env('LOG_LEVEL', ignore: nil))
+          if (val = env('LOG_LEVEL', ignore: false))
             log[:level] = val
           end
           log.delete(:file)
@@ -171,10 +183,14 @@ module Squared
         end
 
         def initialize_env(dev: nil, prod: nil, **)
-          prefix = "BUILD_#{@envname}"
-          @dev = env_match("#{prefix}_DEV", dev)
-          @prod = env_match("#{prefix}_PROD", prod)
-          if (val = env('BUILD', suffix: 'ENV'))
+          pre = "BUILD_#{@envname}"
+          @dev = env_match("#{pre}_DEV", dev)
+          @prod = env_match("#{pre}_PROD", prod)
+          cmd = @output[0]
+          unless cmd == false || cmd.is_a?(::Array) || (val = env('BUILD', suffix: 'OPTS')).nil?
+            @output[cmd ? 1 : 3] = shell_split(val, join: true)
+          end
+          unless @output[2] == false || (val = env('BUILD', suffix: 'ENV')).nil?
             begin
               data = JSON.parse(val)
               raise_error('invalid JSON object', val, hint: "#{prefix}_ENV") unless data.is_a?(::Hash)
@@ -186,10 +202,12 @@ module Squared
           return unless (val = env('BUILD', strict: true))
 
           @global = false
-          if script?
+          if val == '0'
+            @output = [false]
+          elsif script?
             script_set val
           else
-            run_set(val, opts: false)
+            run_set val
           end
         end
 
@@ -198,36 +216,90 @@ module Squared
         end
 
         def populate(*)
-          check = lambda do |proj, key|
-            workspace.series.include?(key) ? proj.has?(key, Base.ref) : workspace.task_extend?(proj, key)
-          end
-
           namespace name do
             workspace.series.each_key do |key|
-              next unless check.(self, key)
+              next unless workspace.task_include?(self, key)
 
-              unless workspace.task_defined?("#{name}:#{key}")
-                desc message(@desc, key)
-                task key do
+              s = workspace.series.name_get(key)
+              unless workspace.task_defined?(name, s)
+                desc message(@desc, s)
+                task s do
                   __send__(key)
                 end
               end
-              next if (items = @children.select { |item| check.(item, key) }).empty?
+              next if (items = @children.select { |item| workspace.task_include?(item, key) }).empty?
 
-              desc message(@desc, key, 'workspace')
-              task "#{key}:workspace" => items.map { |item| "#{item.name}:#{key}" }
+              desc message(@desc, s, 'workspace')
+              task task_join(s, 'workspace') => items.map { |item| task_join(item.name, s) }
+            end
+            next unless ref?(Base.ref)
+
+            @@tasks[Base.ref].each do |action, flags|
+              namespace action do
+                flags.each do |flag|
+                  case action
+                  when :graph
+                    next unless graph?
+
+                    if flag == :run
+                      desc format_desc(action, flag, 'pass*')
+                      task flag, [:pass] do |_, args|
+                        graph(pass: args.to_a)
+                      end
+                    else
+                      desc format_desc(action, flag)
+                      task flag do
+                        out = graph(out: [])
+                        emphasize(out, title: path, right: true, border: borderstyle,
+                                       footer: "dependencies: #{out.size - 1}",
+                                       sub: [
+                                         { pat: /^(#{Regexp.escape(path.to_s)})(.*)$/, styles: theme[:header] },
+                                         { pat: /^(#{Regexp.escape(name)})(.*)$/, styles: theme[:active] },
+                                         { pat: /^(\s*)([a-z]+: )(\d+)$/, styles: theme[:inline], index: 3 }
+                                       ])
+                      end
+                    end
+                  end
+                end
+              end
             end
           end
         end
 
-        def add(path, name = nil, **kwargs, &blk)
-          return self unless source_path?(path = base_path(path))
+        def with(**kwargs, &blk)
+          @withargs = kwargs.empty? ? nil : kwargs
+          if block_given?
+            instance_eval(&blk)
+            @withargs = nil
+          end
+          self
+        end
 
+        def add(path, name = nil, **kwargs, &blk)
+          if path.is_a?(::String) && (data = %r{^(.+)[\\/]\*+$}.match(path))
+            path = basepath(data[1]).children.select(&:directory?)
+          end
+          if path.is_a?(::Array)
+            name = @name if name == true
+            path.each { |val| add(val, name && task_join(name, File.basename(val)), **kwargs, &blk) }
+            return self
+          elsif !projectpath?(path = basepath(path))
+            return self
+          elsif name.is_a?(::Symbol)
+            name = name.to_s
+          elsif !name.is_a?(::String)
+            name = nil
+          end
+          if @withargs
+            data = @withargs.dup
+            data.merge!(kwargs)
+            kwargs = data
+          end
           kwargs[:group] = group unless kwargs.key?(:group)
           kwargs[:ref] = ref unless kwargs.key?(:ref)
           parent = self
           proj = nil
-          workspace.add(path, name || path.basename.to_s, **kwargs) do
+          workspace.add(path, name || path.basename, **kwargs) do
             variable_set :parent, parent
             proj = self
           end
@@ -236,54 +308,49 @@ module Squared
           self
         end
 
-        def build(*args, sync: true)
+        def build(*args, sync: invoked_sync?('build'), **)
           if args.empty?
-            cmd, opts, var = @output
-            opts &&= shell_split(opts, join: true)
+            cmd, opts, var, flags = @output
+            banner = verbose == 1
           else
             cmd = args.shift
             opts = args.map { |val| shell_quote(val, force: false) }.join(' ')
+            banner = verbose
           end
           if cmd
-            if opts
+            case opts
+            when ::String
               cmd = "#{cmd} #{opts}"
-            elsif cmd.is_a?(::Array)
+            when ::Array
               cmd = cmd.join(' && ')
+            else
+              cmd = [cmd, compose(opts, script: false)].compact.join(' ') unless opts == false || !respond_to?(:compose)
             end
-            banner = verbose != false
           else
             return unless respond_to?(:compose)
 
-            cmd = compose(opts)
-            banner = verbose == 1
+            cmd = compose(opts, flags, script: true)
           end
           run(cmd, var, banner: banner, sync: sync)
         end
 
-        def refresh(*)
-          build(sync: invoked_sync?('refresh') || invoked_sync?('build'))
-          return if run_task "#{name}:copy"
-
-          copy if copy?
+        def depend(*, sync: invoked_sync?('depend'), **)
+          run(@depend, sync: sync) if @depend
         end
 
-        def depend(*)
-          run(@depend, sync: invoked_sync?('depend')) if @depend
+        def copy(*, sync: invoked_sync?('copy'), **)
+          run_s(@copy, sync: sync) if @copy
         end
 
-        def copy(*)
-          run_s(@copy, sync: invoked_sync?('copy')) if @copy
+        def doc(*, sync: invoked_sync?('doc'), **)
+          build(@doc, sync: sync) if @doc
         end
 
-        def doc
-          build(@doc, sync: invoked_sync?('doc')) if @doc
+        def test(*, sync: invoked_sync?('test'), **)
+          build(@test, sync: sync) if @test
         end
 
-        def test
-          build(@test, sync: invoked_sync?('test')) if @test
-        end
-
-        def clean
+        def clean(*)
           case @clean
           when ::String
             run_s(@clean, sync: invoked_sync?('clean'))
@@ -291,13 +358,13 @@ module Squared
             as_a(@clean).each do |val|
               if (val = val.to_s) =~ %r{[\\/]$}
                 dir = Pathname.new(val)
-                dir = base_path(dir) unless dir.absolute?
+                dir = basepath(dir) unless dir.absolute?
                 next unless dir.directory?
 
                 log.warn "rm -rf #{dir}"
                 dir.rmtree(verbose: true)
               else
-                files = val.include?('*') ? Dir[base_path(val)] : [base_path(val)]
+                files = val.include?('*') ? Dir[basepath(val)] : [basepath(val)]
                 files.each do |file|
                   begin
                     File.delete(file) if File.file?(file)
@@ -310,16 +377,29 @@ module Squared
           end
         end
 
+        def graph(*, sync: invoked_sync?('graph'), pass: [], out: nil)
+          data = graph_collect(self)
+          data[name] << self unless out
+          run_graph(data, name, out, sync: sync, pass: pass)
+          out
+        end
+
         def log
-          if @log.is_a?(::Array)
-            @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
-          else
-            @log
-          end
+          return @log unless @log.is_a?(::Array)
+
+          @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
         end
 
-        def base_path(*args)
-          path.join(*args)
+        def basepath(*args, ascend: nil)
+          ret = path.join(*args)
+          return ret unless ascend && !ret.exist?
+
+          path.parent.ascend.each do |dir|
+            target = dir.join(*args)
+            return target if target.exist?
+            break if (ascend.is_a?(String) && dir.join(ascend).exist?) || workspace.root == dir || parent&.path == dir
+          end
+          ret
         end
 
         def color(val)
@@ -328,26 +408,43 @@ module Squared
         end
 
         def variable_set(key, *val, **kwargs)
-          if variable_all.include?(key)
+          if variables.include?(key)
             case key
             when :run
-              run_set(*val, opts: false, **kwargs)
+              run_set(*val, **kwargs)
             when :script
               script_set(*val, **kwargs)
             when :env
-              run_set(output[0], *val, opts: false, **kwargs)
+              run_set(output[0], *val, **kwargs)
+            when :parent
+              @parent = val if (val = val.first).is_a?(Project::Base)
+            when :graph
+              @graph = case val.first
+                       when nil, false
+                         nil
+                       else
+                         val.flatten.map!(&:to_s).freeze
+                       end
+            when :dependfile
+              @dependfile = basepath(*val)
             else
               instance_variable_set :"@#{key}", val.first
             end
           else
-            log.warn "variable_set: @#{key} (not defined)"
+            log.warn "variable_set: @#{key} (private)"
           end
         end
 
-        def variable_all
-          VAR_SET
+        def allref
+          @ref.reverse_each
         end
 
+        def dependtype(*)
+          @dependindex ? @dependindex.succ : 0
+        end
+
+        def version(*); end
+
         def inspect
           "#<#{self.class}: #{name} => #{self}>"
         end
@@ -384,12 +481,16 @@ module Squared
           @output[0].nil? && !!@output[1] && respond_to?(:compose)
         end
 
-        def refresh?
-          build? && copy?
+        def depend?
+          !!@depend
         end
 
-        def depend?
-          @depend != false && (!@depend.nil? || has?('outdated'))
+        def graph?
+          @graph.is_a?(::Array) && !@graph.empty?
+        end
+
+        def copy?
+          runnable?(@copy) || workspace.task_defined?(name, 'copy')
         end
 
         def doc?
@@ -400,12 +501,8 @@ module Squared
           !!@test
         end
 
-        def copy?
-          runnable?(@copy) || workspace.task_defined?("#{name}:copy")
-        end
-
         def clean?
-          runnable?(@clean) || workspace.task_defined?("#{name}:clean")
+          runnable?(@clean) || workspace.task_defined?(name, 'clean')
         end
 
         def dev?
@@ -418,18 +515,22 @@ module Squared
 
         private
 
-        def run(cmd = @session, var = nil, exception: @exception, banner: true, sync: true, req: nil, **)
-          if req && !base_path(req).exist?
-            log.warn "#{req} (not found)"
-            return
-          end
-          cmd = close_session(cmd)
+        def variables
+          VAR_SET
+        end
+
+        def puts(*args)
+          puts_oe(*args, pipe: pipe)
+        end
+
+        def run(cmd = @session, var = nil, exception: @exception, sync: true, banner: true, **)
+          cmd = session_done(cmd)
           log.info cmd
           begin
             if cmd =~ /^\S+:(\S+:?)+$/ && workspace.task_defined?(cmd)
               print_item if sync
               log.warn "ENV was discarded: #{var}" if var
-              invoke(cmd, exception: exception, warning: warning?)
+              task_invoke(cmd, exception: exception, warning: warning?)
             else
               print_item format_banner(cmd, banner: banner) if sync
               args = var.is_a?(::Hash) ? [var, cmd] : [cmd]
@@ -441,52 +542,114 @@ module Squared
           end
         end
 
-        def run_s(cmd, **kwargs)
-          as_a(cmd).each { |val| run(val, banner: !!verbose, **kwargs) if val.is_a?(::String) }
+        def run_s(*cmd, env: nil, banner: verbose != false, **kwargs)
+          cmd.each { |val| run(val, env, banner: banner, **kwargs) }
         end
 
-        def run_task(key)
-          return false unless workspace.task_defined?(key)
+        def run_graph(data, start, out = nil, sync: true, pass: [], done: [], depth: 0, last: false)
+          check = ->(deps) { deps.reject { |val| done.include?(val) } }
+          items = check.(data[start])
+          if out
+            a, b, c, d, e = ARG[:GRAPH]
+            out << case depth
+                   when 0
+                     start
+                   when 1
+                     if items.empty?
+                       "#{d}#{b * 4} #{start}"
+                     else
+                       "#{last ? d : c}#{b * 3}#{e} #{start}"
+                     end
+                   else
+                     "#{a}#{'   ' * (depth - 1)}#{d}#{b * 2}#{items.empty? ? b : e} #{start}"
+                   end
+          end
+          items.each_with_index do |proj, i|
+            next if done.include?(proj)
 
-          invoke(key, exception: exception, warning: warning?)
-          true
-        end
+            j = out ? i == items.size - 1 || check.(items[i + 1..-1]).empty? : false
+            s = proj.name
+            unless start == s || (none = check.(data.fetch(s, [])).empty?)
+              run_graph(data, s, out, sync: sync, pass: pass, done: done, depth: depth.succ, last: j)
+            end
+            if !out
+              if (script = workspace.script_get(group: proj.group, ref: proj.ref))
+                tasks = script[:graph]
+              end
+              (tasks || (dev? ? %w[build copy] : %w[depend build])).each do |meth|
+                next if pass.include?(meth)
 
-        def env(key, default = nil, equals: nil, ignore: ['0'].freeze, suffix: nil, strict: false)
-          a = "#{key}_#{@envname}"
-          b = ''
-          if suffix
-            a = "#{a}_#{suffix}"
-          elsif !strict
-            b = ENV.fetch(key, '')
+                if workspace.task_defined?(cmd = task_join(s, meth))
+                  run(cmd, sync: false, banner: false)
+                elsif proj.has?(meth)
+                  proj.__send__(meth.to_sym, sync: sync)
+                end
+              end
+            elsif none
+              a, b, c, d = ARG[:GRAPH]
+              out << if depth == 0
+                       "#{i == items.size - 1 ? d : c}#{b * 4} #{s}"
+                     else
+                       "#{last && depth == 1 ? ' ' : a}#{'   ' * depth}#{j ? d : c}#{b * 3} #{s}"
+                     end
+            end
+            done << proj
           end
-          ret = ENV.fetch(a, b)
-          return ret == equals.to_s unless equals.nil?
+        end
+
+        def graph_collect(target, data: {})
+          deps = []
+          target.instance_variable_get(:@graph)&.each do |val|
+            next unless (proj = workspace.find(name: val))
 
-          ret.empty? || as_a(ignore).any? { |val| ret == val.to_s } ? default : ret
+            deps << proj
+            graph_collect(proj, data: data) if proj.graph? && !data.key?(proj.name)
+            deps += data.fetch(val, [])
+          end
+          data[target.name] = deps.uniq.reject { |proj| proj == target }
+          data
         end
 
-        def puts(*args)
-          pipe == 2 ? $stderr.puts(*args) : $stdout.puts(*args)
+        def env(key, default = nil, suffix: nil, equals: nil, ignore: nil, strict: false)
+          a = "#{key}_#{@envname}"
+          ret = if suffix
+                  ENV.fetch("#{a}_#{suffix}", '')
+                else
+                  ignore = ['0'].freeze if ignore.nil? && !strict
+                  ENV[a] || (strict ? '' : ENV.fetch(key, ''))
+                end
+          return ret == equals.to_s unless equals.nil?
+
+          ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
         end
 
-        def session(*cmd, prefix: nil)
-          if (val = ENV["#{(prefix || cmd.first).upcase}_OPTIONS"])
+        def session(*cmd, prefix: cmd.first)
+          if (val = env("#{prefix.upcase}_OPTIONS"))
             split_escape(val).each { |opt| cmd << fill_option(opt) }
           end
           @session = JoinSet.new(cmd)
         end
 
-        def close_session(cmd)
-          return cmd unless cmd.respond_to?(:done)
+        def session_done(cmd)
+          return cmd.to_s unless cmd.respond_to?(:done)
 
           raise_error('no args were added', hint: cmd.first || name) unless cmd.size > 1
           @session = nil if cmd == @session
           cmd.done
         end
 
+        def option(*args, prefix: @session&.first, **kwargs)
+          if prefix
+            args.each do |val|
+              ret = env("#{prefix}_#{val.gsub(/\W/, '_')}".upcase, **kwargs)
+              return ret if ret
+            end
+          end
+          nil
+        end
+
         def print_item(*val)
-          puts unless @@print_order == 0 || stdin?
+          puts if @@print_order > 0 && verbose && !stdin?
           @@print_order += 1
           puts val unless val.empty? || (val.size == 1 && val.first.nil?)
         end
@@ -497,7 +660,7 @@ module Squared
             if styles.any? { |s| s.to_s.end_with?('!') }
               pad = 1
             elsif !client && styles.size <= 1
-              styles = [:bold] + styles
+              styles = %i[bold] + styles
             end
           end
           n = Project.max_width(lines)
@@ -516,33 +679,37 @@ module Squared
           out.join("\n")
         end
 
-        def print_footer(*lines, sub: nil, border: theme[:border], reverse: false)
+        def print_footer(*lines, sub: nil, reverse: false, right: false, **kwargs)
+          border = kwargs.key?(:border) ? kwargs[:border] : borderstyle
           n = Project.max_width(lines)
           sub = as_a(sub)
           lines.map! do |val|
-            s = val.ljust(n)
+            s = right ? val.rjust(n) : val.ljust(n)
             sub.each { |h| s = sub_style(s, **h) }
             s
           end
-          ret = [sub_style('-' * n, styles: border), *lines]
+          ret = [sub_style('-' * n, styles: border || theme[:border]), *lines]
           ret.reverse! if reverse
           ret.join("\n")
         end
 
-        def format_desc(action, flag, opts = nil, req: '', arg: 'opts*')
+        def format_desc(action, flag, opts = nil, req: nil, arg: 'opts*')
           opts = "#{arg}=#{opts.join(',')}" if opts.is_a?(::Array)
-          unless flag
+          out = [@desc]
+          if flag
+            out << action
+          else
             flag = action
-            action = ''
           end
-          req = opts ? "#{req}," : "[#{req}]" unless req.to_s.empty?
-          message(@desc, action, opts ? "#{flag}[#{req}#{opts}]" : flag.to_s + req)
+          req &&= opts ? "#{req}," : "[#{req}]"
+          out << (opts ? "#{flag}[#{req}#{opts}]" : "#{flag}#{req}")
+          message(*out)
         end
 
-        def format_banner(cmd, banner: true, multiple: false)
-          return unless banner
+        def format_banner(cmd, banner: true)
+          return unless banner && ARG[:BANNER]
 
-          if (data = workspace.banner(group: group, ref: ref))
+          if (data = workspace.banner_get(*@ref, group: group))
             client = true
           else
             data = { command: true, order: %i[path], styles: theme[:banner], border: theme[:border] }
@@ -550,13 +717,62 @@ module Squared
           if verbose
             out = []
             out << cmd.sub(/^\S+/, &:upcase) if data[:command]
-            data[:order].each { |val| out << val.to_s if (val = __send__(val)) }
+            data[:order].each do |val|
+              if val.is_a?(::Array)
+                s = ' '
+                found = false
+                val = val.map do |meth|
+                  if meth.is_a?(::String)
+                    s = ''
+                    meth
+                  elsif respond_to?(meth)
+                    found = true
+                    __send__(meth)
+                  end
+                end
+                val = val.compact.join(s)
+                next unless found && !val.empty?
+              elsif (val = __send__(val)).nil?
+                next
+              end
+              out << val.to_s
+            end
             print_banner(*out, styles: data[:styles], border: data[:border], client: client)
           elsif multiple && workspace.series.multiple?
             "## #{__send__(data[:order].first || :path)} ##"
           end
         end
 
+        def format_list(items, cmd, type, grep: [], from: nil, each: nil)
+          reg = grep.map { |val| Regexp.new(val) }
+          out = []
+          if (pad = items.size) > 0
+            pad = pad.to_s.size
+            items.each_with_index do |val, i|
+              next unless reg.empty? || reg.any? { |pat| pat.match?(val[0]) }
+
+              out << "#{(i + 1).to_s.rjust(pad)}. #{each ? each.(val) : val[0]}"
+            end
+          end
+          if out.empty?
+            out = ["No #{type} were found:", '']
+            unless grep.empty?
+              i = 0
+              out += grep.map { |s| "#{i += 1}. #{s}" }
+              out << ''
+            end
+            if from
+              out << from
+              pat = /^(#{Regexp.escape(out.last)})(.*)$/
+            end
+          else
+            pat = /^(\s*\d+\.)(.+)$/
+          end
+          sub = [headerstyle]
+          sub << { pat: pat, styles: theme[:active] } if pat
+          emphasize(out, title: task_join(name, cmd), border: borderstyle, sub: sub)
+        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))}"
         end
@@ -569,22 +785,22 @@ module Squared
           opts.each { |val| @session << val }
         end
 
-        def append_nocolor
-          @session << (!ENV.fetch('NO_COLOR', '').empty? || stdin? ? '--no-color' : '')
+        def append_nocolor(flag = nil)
+          @session << '--no-color' if flag || !ARG[:COLOR] || stdin?
         end
 
         def guard_params(action, flag, args: nil, key: nil, pat: nil)
           if args && key
-            return unless (val = args[key]).nil? || (pat && !val.match?(pat))
+            val = args[key]
+            return val unless val.nil? || (pat && !val.match?(pat))
 
             @session = nil
             raise_error(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
-          elsif args.is_a?(::Array)
-            return unless args.empty?
-
+          elsif args.is_a?(::Array) && args.empty?
             @session = nil
-            raise_error(action, "#{flag}[]", hint: 'empty')
+            raise_error(action, "#{flag}+", hint: 'empty')
           end
+          args
         end
 
         def pwd_set(done = nil, &blk)
@@ -612,39 +828,27 @@ module Squared
           end
         end
 
-        def semver(val)
-          unless val[3]
-            val[3] = '.'
-            val[4] = '0'
+        def run_set(cmd, val = nil, opts: nil, **)
+          unless @output[1] == false && !@output[0].nil?
+            if opts == false
+              @output[1] = false
+            elsif opts && opts != true
+              @output[1] = opts
+            end
           end
-          unless val[1]
-            val[1] = '.'
-            val[2] = '0'
+          unless @output[2] == false
+            if val.is_a?(::Hash)
+              @output[2] = val
+            elsif val == false
+              @output[2] = false
+            end
           end
-          val
-        end
-
-        def semmajor(cur, want)
-          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
-        end
-
-        def scriptargs
-          { target: script? ? @output[1] : @output[0], ref: ref, group: group, global: @global }
-        end
-
-        def run_set(cmd, val = nil, *, opts: true, **)
           @output[0] = cmd
-          @output[1] = if cmd && opts
-                         env('BUILD', opts.is_a?(::String) ? opts : nil, suffix: 'OPTS')
-                       end
-          if val.is_a?(::Hash)
-            @output[2] = val
-          elsif val == false
-            @output[2] = nil
-          end
         end
 
-        def script_set(cmd, *, prod: nil, **)
+        def script_set(cmd, prod: nil, **)
+          return if @output[1] == false && @output[0].nil?
+
           @output[0] = nil
           @output[1] = if @global && cmd.is_a?(::Array)
                          cmd[prod == true ? 1 : 0]
@@ -653,16 +857,12 @@ module Squared
                        end
         end
 
-        def source_path?(val)
-          Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.match?(%r{^\.\.[/\\]})
+        def projectpath?(val)
+          Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.start_with?('..')
         end
 
-        def warning?
-          workspace.warning
-        end
-
-        def stdin?
-          pipe == 0
+        def semmajor?(cur, want)
+          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
         end
 
         def runnable?(val)
@@ -676,23 +876,83 @@ module Squared
           end
         end
 
-        def from_sync?(val)
-          if invoked?(val)
-            !workspace.task_defined?("#{val}:sync")
-          elsif workspace.series.sync?("#{val}:sync")
+        def from_sync?(*val)
+          if task_invoked?(key = task_join(*val))
+            !workspace.task_defined?(key, 'sync')
+          elsif workspace.series.sync?(task_join(key, 'sync'))
             true
           end
         end
 
         def invoked_sync?(action, val = nil)
           return true if !val.nil? || from_sync?(ac = workspace.task_name(action))
+          return val if group && !(val = from_sync?(ac, group)).nil?
+          return val if (base = workspace.find_base(self)) && !(val = from_sync?(ac, base.ref)).nil?
 
-          return val if group && !(val = from_sync?("#{ac}:#{group}")).nil?
-          return val if (base = workspace.find_base(self)) && !(val = from_sync?("#{ac}:#{base.ref}")).nil?
+          if task_invoked?(task_join(name, ac)) && (!task_invoked?(ac) || !workspace.task_defined?(ac, 'sync'))
+            true
+          else
+            val = workspace.series.name_get(action)
+            val == action ? false : invoked_sync?(val)
+          end
+        end
+
+        def stdin?
+          pipe == 0
+        end
+
+        def warning?
+          workspace.warning
+        end
+
+        def projectmap(files, parent: false)
+          files = files.select { |val| projectpath?(val) } unless parent
+          files.map { |val| val == '.' ? '.' : shell_quote(basepath(val.strip)) }
+        end
+
+        def semver(val)
+          return val if val[3]
+
+          val[3] = '.'
+          val[4] = '0'
+          unless val[1]
+            val[1] = '.'
+            val[2] = '0'
+          end
+          val
+        end
+
+        def semscan(val)
+          val.scan(SEM_VER).first
+        end
 
-          invoked?("#{name}:#{ac}") && (!invoked?(ac) || !workspace.task_defined?("#{ac}:sync"))
+        def borderstyle
+          if (data = workspace.banner_get(*@ref, group: group))
+            data[:border]
+          end
+        end
+
+        def headerstyle
+          { pat: /^(\S+)(\s+)$/, styles: theme[:header] }
+        end
+
+        def scriptargs
+          { target: script? ? @output[1] : @output[0], ref: ref, group: group, global: @global }
+        end
+
+        def indexdata(val)
+          if (data = /\A\^(\d+)(:.+)?\z/.match(val))
+            [data[1].to_i, data[2] ? data[2][1..-1] : nil]
+          end
+        end
+
+        def indexerror(val, list = nil)
+          raise_error("requested index #{val}", hint: list && "of #{list.size}")
         end
       end
+
+      Application.impl_project = Base
+      Application.attr_banner = Common::SymSet.new(%i[name project path ref group parent])
     end
   end
 end