squared 0.1.3 → 0.2.1

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

@@ -14,7 +14,7 @@ module Squared
         include Utils
         include Rake::DSL
 
-        VAR_SET = %i[parent global envname dependfile theme run script env].freeze
+        VAR_SET = %i[parent global envname dependfile theme run script env pass].freeze
         SEM_VER = /\b(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?\b/.freeze
         private_constant :VAR_SET, :SEM_VER
 
@@ -50,18 +50,17 @@ module Squared
           end
         end
 
-        @@tasks = {
-          "#{ref}": {
-            graph: %i[run print].freeze
-          }.freeze
-        }
+        (@@tasks = {})[ref] = {
+          'graph' => %i[run print].freeze
+        }.freeze
+        @@task_desc = Rake::TaskManager.record_task_metadata
         @@print_order = 0
 
-        attr_reader :name, :project, :workspace, :path, :exception, :pipe, :theme, :group, :parent,
-                    :dependfile, :verbose
+        attr_reader :name, :project, :workspace, :path, :theme, :exception, :pipe, :verbose,
+                    :group, :parent, :dependfile
 
         def initialize(workspace, path, name, *, group: nil, graph: nil, pass: nil, exclude: nil,
-                       common: ARG[:COMMON], **kwargs)
+                       first: {}, last: {}, error: {}, common: ARG[:COMMON], **kwargs)
           @path = path
           @workspace = workspace
           @name = name.to_s.freeze
@@ -72,6 +71,7 @@ module Squared
           @test = kwargs[:test]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
+          @version = kwargs[:version]
           @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
@@ -88,8 +88,13 @@ module Squared
           @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
+          @pass = (pass ? as_a(pass) : []).freeze
           @exclude = (exclude ? as_a(exclude, :to_sym) : []).freeze
+          @events = {
+            first: first,
+            last: last,
+            error: error
+          }
           @envname = @name.gsub(/[^\w]+/, '_').upcase.freeze
           @desc = (@name.include?(':') ? @name.split(':').join(ARG[:SPACE]) : @name).freeze
           @parent = nil
@@ -115,6 +120,7 @@ module Squared
             @clean = @script[:clean] if @clean.nil?
             @exclude = @script[:exclude] if @exclude.empty? && @script.key?(:exclude)
           end
+          initialize_events(ref, **kwargs)
           initialize_logger(**kwargs)
           return if @output[0] == false
 
@@ -147,6 +153,12 @@ module Squared
           end
         end
 
+        def initialize_events(ref, **)
+          return unless (events = @workspace.events_get(group: @group, ref: ref))
+
+          events.each { |task, data| data.each { |ev, blk| (@events[ev] ||= {})[task] ||= blk } }
+        end
+
         def initialize_logger(log: nil, **)
           return if @log
 
@@ -193,11 +205,13 @@ module Squared
             begin
               data = JSON.parse(val)
               raise_error('invalid JSON object', val, hint: "#{prefix}_ENV") unless data.is_a?(Hash)
-              @output[2] = data
             rescue StandardError => e
               log.warn e
+            else
+              @output[2] = data
             end
           end
+          @version = val if (val = env('BUILD', suffix: 'VERSION'))
           return unless (val = env('BUILD', strict: true))
 
           @global = false
@@ -214,49 +228,37 @@ module Squared
           Base.ref
         end
 
-        def populate(*)
-          namespace name do
-            workspace.series.each_key do |key|
-              next unless workspace.task_include?(self, key)
-
-              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| workspace.task_include?(item, key) }).empty?
-
-              desc message(@desc, s, 'workspace')
-              task task_join(s, 'workspace') => items.map { |item| task_join(item.name, s) }
-            end
-            next unless ref?(Base.ref)
+        def populate(keys, **)
+          task_build keys
+          return unless ref?(Base.ref)
 
+          namespace name do
             @@tasks[Base.ref].each do |action, flags|
+              next if @pass.include?(action)
+
               namespace action do
                 flags.each do |flag|
                   case action
-                  when :graph
+                  when 'graph'
                     next unless graph?
 
                     check = lambda do |args|
                       next args if (args = args.to_a).empty?
 
-                      guard_params(action, flag, args: args.reject { |val| name == val.to_s })
+                      param_guard(action, flag, args: args.reject { |val| name == val.to_s })
                     end
 
-                    desc format_desc(action, flag, 'project*')
+                    format_desc action, flag, 'project*'
                     if flag == :run
-                      task flag, [:project] do |_, args|
+                      task flag do |_, args|
                         graph check.(args)
                       end
                     else
-                      task flag, [:project] do |_, args|
+                      task flag do |_, args|
                         out, done = graph(check.(args), out: [])
                         out.map! do |val|
                           done.each_with_index do |proj, i|
-                            next unless val.end_with?(" #{proj.name}")
+                            next unless Regexp.new(" #{Regexp.escape(proj.name)}(?:@\\d|\\z)") =~ val
 
                             val += " (#{i.succ})"
                             break
@@ -277,6 +279,10 @@ module Squared
           end
         end
 
+        def generate(keys, **)
+          task_build keys
+        end
+
         def with(**kwargs, &blk)
           @withargs = kwargs.empty? ? nil : kwargs
           if block_given?
@@ -329,7 +335,19 @@ module Squared
           self
         end
 
-        def build(*args, sync: invoked_sync?('build'), **)
+        def inject(obj, *args, **kwargs, &blk)
+          return self unless enabled?
+
+          out = obj.link(self, *args, **kwargs, &blk) if obj.respond_to?(:link)
+          if !out
+            warn log_message(:warn, 'link not compatible', subject: obj.to_s, hint: name)
+          elsif out.respond_to?(:build)
+            out.build
+          end
+          self
+        end
+
+        def build(*args, from: :build, sync: invoked_sync?('build'), **)
           if args.empty?
             cmd, opts, var, flags = @output
             banner = verbose == 1
@@ -350,35 +368,46 @@ module Squared
           else
             return unless respond_to?(:compose)
 
-            cmd = compose(opts, flags, script: true)
+            cmd = compose(opts, flags, from: from, script: true)
           end
-          run(cmd, var, banner: banner, sync: sync)
+          run(cmd, var, from: from, banner: banner, sync: sync)
         end
 
         def depend(*, sync: invoked_sync?('depend'), **)
-          run(@depend, sync: sync) if @depend
+          return unless @depend
+
+          run(@depend, from: :depend, sync: sync)
         end
 
         def copy(*, sync: invoked_sync?('copy'), **)
-          run_s(@copy, sync: sync) if @copy
+          return unless @copy
+
+          run_s(@copy, from: :copy, sync: sync)
         end
 
         def doc(*, sync: invoked_sync?('doc'), **)
-          build(@doc, sync: sync) if @doc
+          return unless @doc
+
+          build(@doc, from: :doc, sync: sync)
         end
 
         def test(*, sync: invoked_sync?('test'), **)
-          build(@test, sync: sync) if @test
+          return unless @test
+
+          build(@test, from: :test, sync: sync)
         end
 
-        def clean(*)
+        def clean(*, sync: invoked_sync?('clean'), **)
+          return unless @clean
+
+          on :first, :clean
           case @clean
           when String
-            run_s(@clean, sync: invoked_sync?('clean'))
+            run_s(@clean, from: :clean, sync: sync)
           when Enumerable
             as_a(@clean).each do |val|
-              if (val = val.to_s) =~ %r{[\\/]$}
-                dir = Pathname.new(val)
+              if val =~ %r{[\\/]$}
+                dir = Pathname.new(val.to_s)
                 dir = basepath(dir) unless dir.absolute?
                 next unless dir.directory?
 
@@ -396,6 +425,7 @@ module Squared
               end
             end
           end
+          on :last, :clean
         end
 
         def graph(start = [], tasks = nil, sync: invoked_sync?('graph'), pass: [], out: nil)
@@ -411,9 +441,37 @@ module Squared
           end
           pass.concat(split_escape(val)) if (val = env('GRAPH_PASS', strict: true))
           data = graph_collect(self, start)
-          data[name] << self unless out
-          done = run_graph(data, name, tasks, out, sync: sync, pass: pass)
-          [out, done] if out
+          unless out
+            data[name] << self
+            on :first, :graph
+          end
+          begin
+            done = graph_branch(self, data, tasks, out, sync: sync, pass: pass)
+          rescue StandardError => e
+            ret = on(:error, :graph, e)
+            raise unless ret == true
+          end
+          if out
+            [out, done]
+          else
+            on :last, :graph
+          end
+        end
+
+        def first(key, *args, **kwargs, &blk)
+          event(:first, key, *args, **kwargs, &blk)
+        end
+
+        def last(key, *args, **kwargs, &blk)
+          event(:last, key, *args, **kwargs, &blk)
+        end
+
+        def error(key, *args, **kwargs, &blk)
+          event(:error, key, *args, **kwargs, &blk)
+        end
+
+        def event(name, key, *args, **kwargs, &blk)
+          (@events[name.to_sym] ||= {})[key.to_sym] = [block_given? ? [blk] + args : args, kwargs]
         end
 
         def variable_set(key, *val, **kwargs)
@@ -444,7 +502,7 @@ module Squared
           end
         end
 
-        def enabled?(ref = nil)
+        def enabled?(ref = nil, **)
           return false if ref && !ref?(ref)
 
           path.directory? && !path.empty?
@@ -500,7 +558,13 @@ module Squared
           @prod != false && workspace.prod?(pat: @prod, **scriptargs)
         end
 
-        def version(*); end
+        def task_include?(key, ref = nil)
+          workspace.task_include?(self, key, ref) && !@pass.include?(key.to_s)
+        end
+
+        def version(*)
+          @version
+        end
 
         def dependtype(*)
           @dependindex ? @dependindex.succ : 0
@@ -528,6 +592,10 @@ module Squared
           ret
         end
 
+        def localname
+          workspace.task_localname(name)
+        end
+
         def inspect
           "#<#{self.class}: #{name} => #{self}>"
         end
@@ -546,11 +614,12 @@ module Squared
           puts_oe(*args, pipe: pipe)
         end
 
-        def run(cmd = @session, var = nil, exception: @exception, sync: true, banner: true, chdir: path, **)
+        def run(cmd = @session, var = nil, exception: @exception, sync: true, banner: true, chdir: path, from: nil, **)
           cmd = session_done(cmd)
           log.info cmd
+          on :first, from if from
           begin
-            if cmd =~ /\A[^:]+:[^:]/ && workspace.task_defined?(cmd)
+            if cmd.match?(/\A[^:]+:[^:]/) && workspace.task_defined?(cmd)
               log.warn "ENV was discarded: #{var}" if var
               task_invoke(cmd, exception: exception, warning: warning?)
             else
@@ -560,16 +629,27 @@ module Squared
             end
           rescue StandardError => e
             log.error e
-            raise
+            ret = on(:error, from, e) if from
+            raise unless ret == true
+          else
+            on :last, from if from
           end
         end
 
-        def run_s(*cmd, env: nil, banner: verbose != false, **kwargs)
-          cmd.each { |val| run(val, env, banner: banner, **kwargs) }
+        def run_s(*cmd, env: nil, sync: true, banner: verbose != false, from: nil, **kwargs)
+          on :first, from if from
+          begin
+            cmd.each { |val| run(val, env, sync: sync, banner: banner, **kwargs) }
+          rescue StandardError => e
+            ret = on(:error, from, e) if from
+            raise unless ret == true
+          end
+          on :last, from if from
         end
 
-        def run_graph(data, start, tasks = nil, out = nil, sync: true, pass: [], done: [], depth: 0, last: false,
-                      single: false)
+        def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], depth: 0, last: false,
+                         single: false)
+          tag = ->(proj) { "#{proj.name}#{SEM_VER =~ proj.version ? "@#{proj.version}" : ''}" }
           check = ->(deps) { deps.reject { |val| done.include?(val) } }
           dedupe = lambda do |name|
             next [] unless (ret = data[name])
@@ -581,6 +661,7 @@ module Squared
             end
             ret
           end
+          start = target.name
           if depth == 0
             items = check.(dedupe.(start))
             single = items.size == 1
@@ -589,24 +670,24 @@ module Squared
           end
           if out
             a, b, c, d, e = ARG[:GRAPH]
+            f = tag.(target)
             out << case depth
                    when 0
-                     start
+                     f
                    when 1
                      if items.empty?
-                       "#{d}#{b * 4} #{start}"
+                       "#{d}#{b * 4} #{f}"
                      else
-                       "#{last ? d : c}#{b * 3}#{e} #{start}"
+                       "#{last ? d : c}#{b * 3}#{e} #{f}"
                      end
                    else
-                     "#{single ? ' ' : a}#{'   ' * (depth - 1)}#{last ? d : c}#{b * 3}#{items.empty? ? b : e} #{start}"
+                     "#{single ? ' ' : a}#{'   ' * (depth - 1)}#{last ? d : c}#{b * 3}#{items.empty? ? b : e} #{f}"
                    end
           end
           items.each_with_index do |proj, i|
             next if done.include?(proj)
 
-            s = proj.name
-            t = dedupe.(s)
+            t = dedupe.(proj.name)
             j = if out
                   if i == items.size - 1 || check.(post = items[i + 1..-1]).empty?
                     true
@@ -614,35 +695,35 @@ module Squared
                     post.reject { |pr| t.include?(pr) }.empty?
                   end
                 end
-            unless start == s || (none = check.(t).empty?)
-              run_graph(data, s, tasks, out, sync: sync, pass: pass, done: done, depth: depth.succ, single: single,
-                                             last: j == true)
+            unless start == proj.name || (none = check.(t).empty?)
+              graph_branch(proj, data, tasks, out, sync: sync, pass: pass, done: done, depth: depth.succ,
+                                                   single: single, last: j == true)
             end
             if !out
-              unless tasks || !(script = workspace.script_get(:graph, group: proj.group, ref: proj.allref))
+              if !tasks && (script = workspace.script_get(:graph, group: proj.group, ref: proj.allref))
                 group = script[:graph]
               end
               (tasks || group || (dev? ? ['build', 'copy'] : ['depend', 'build'])).each do |meth|
                 next if pass.include?(meth)
 
-                if workspace.task_defined?(cmd = task_join(s, meth))
+                if workspace.task_defined?(cmd = task_join(proj.name, meth))
                   run(cmd, sync: false, banner: false)
-                elsif proj.has?(meth)
+                elsif proj.has?(meth, tasks || group ? nil : workspace.baseref)
                   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}"
+                       "#{i == items.size - 1 ? d : c}#{b * 4} #{tag.(proj)}"
                      else
-                       f = ''.dup
+                       s = ''.dup
                        k = 0
                        while k < depth
-                         f += "#{(last && !j) || (j && k > 0 && k == depth - 1) || single ? ' ' : a}   "
+                         s += "#{(last && !j) || (j && k > 0 && k == depth - 1) || single ? ' ' : a}   "
                          k += 1
                        end
-                       f + "#{j ? d : c}#{b * 3} #{s}"
+                       s + "#{j ? d : c}#{b * 3} #{tag.(proj)}"
                      end
             end
             done << proj
@@ -653,11 +734,20 @@ module Squared
         def graph_collect(target, start = [], data: {})
           deps = []
           (start.empty? ? target.instance_variable_get(:@graph) : start)&.each do |val|
-            next unless (proj = workspace.find(name: val)) && proj.enabled?
+            if (obj = workspace.find(name: val))
+              next unless obj.enabled?
 
-            deps << proj
-            graph_collect(proj, data: data) if proj.graph? && !data.key?(proj.name)
-            deps += data.fetch(val, [])
+              items = [obj]
+            else
+              items = workspace.find(group: val, ref: val.to_sym)
+            end
+            items.each do |proj|
+              graph_collect(proj, data: data) if proj.graph? && !data.key?(proj.name)
+              next if (objs = data.fetch(proj.name, [])).include?(target)
+
+              deps << proj
+              deps += objs
+            end
           end
           data[target.name] = deps.uniq.reject { |proj| proj == target }
           data
@@ -678,15 +768,22 @@ module Squared
           ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
         end
 
-        def session(*cmd, prefix: cmd.first)
-          if (val = env("#{prefix.upcase}_OPTIONS"))
-            split_escape(val).each { |opt| cmd << fill_option(opt) }
+        def session(*cmd, prefix: cmd.first, main: true, options: true)
+          prefix = prefix.to_s.upcase
+          if (val = PATH[prefix] || PATH[prefix.to_sym])
+            cmd[0] = shell_quote(val, force: false)
           end
-          @session = JoinSet.new(cmd)
+          split_escape(val).each { |opt| cmd << fill_option(opt) } if options && (val = env("#{prefix}_OPTIONS"))
+          ret = JoinSet.new(cmd.flatten(1))
+          main ? @session = ret : ret
+        end
+
+        def session_output(*cmd, **kwargs)
+          session(*cmd, main: false, options: false, **kwargs)
         end
 
         def session_done(cmd)
-          return cmd.to_s unless cmd.respond_to?(:done)
+          return cmd unless cmd.respond_to?(:done)
 
           raise_error('no args were added', hint: cmd.first || name) unless cmd.size > 1
           @session = nil if cmd == @session
@@ -703,6 +800,40 @@ module Squared
           nil
         end
 
+        def option_partition(opts, list, target: @session, no: [], first: false, pass: ['='])
+          out = []
+          bare = []
+          reg, list = list.partition do |val|
+            next unless (n = val.index('='))
+
+            bare << val[0..n - 1] if val.end_with?('?')
+            true
+          end
+          list += bare
+          no = no.map { |val| (n = val.index('=')) ? val[0..n - 1] : val }
+          found = false
+          opts.each do |opt|
+            next out << opt if found
+
+            if list.include?(opt)
+              target << (opt.size == 1 ? "-#{opt}" : "--#{opt}")
+            elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
+              target << "--no-#{name}"
+            else
+              out << opt
+              found = true if first && pass.none? { |val| opt.include?(val) }
+            end
+          end
+          pat = Regexp.new("^(#{reg.map { |val| val[0..val.index('=') - 1] }.join('|')})=(.+)$")
+          [out, pat]
+        end
+
+        def option_clear(params, target: @session, **kwargs)
+          kwargs[:subject] ||= target&.first
+          kwargs[:hint] ||= 'not used'
+          warn log_message(:warn, params.join(', '), **kwargs) unless params.empty?
+        end
+
         def print_item(*val)
           puts if @@print_order > 0 && verbose && !stdin?
           @@print_order += 1
@@ -715,7 +846,7 @@ module Squared
             if styles.any? { |s| s.to_s.end_with?('!') }
               pad = 1
             elsif !client && styles.size <= 1
-              styles = %i[bold] + styles
+              styles = [:bold] + styles
             end
           end
           n = Project.max_width(lines)
@@ -748,32 +879,33 @@ module Squared
           ret.join("\n")
         end
 
-        def format_desc(action, flag, opts = nil, req: nil, arg: 'opts*')
-          return unless Rake::TaskManager.record_task_metadata
+        def format_desc(action, flag, opts = nil, **kwargs)
+          return unless @@task_desc
 
-          opts = "#{arg}=#{opts.join(',')}" if opts.is_a?(Array)
-          out = [@desc]
-          if flag
-            out << action
-          else
-            flag = action
-          end
-          req &&= opts ? "#{req}," : "[#{req}]"
-          out << (opts ? "#{flag}[#{req}#{opts}]" : "#{flag}#{req}")
-          message(*out)
+          ret = [@desc, action]
+          ret << flag if flag
+          workspace.format_desc(ret, opts, **kwargs)
         end
 
         def format_banner(cmd, banner: true)
           return unless banner && ARG[:BANNER]
 
           if (data = workspace.banner_get(*@ref, group: group))
+            return if data.empty?
+
             client = true
           else
-            data = { command: true, order: %i[path], styles: theme[:banner], border: theme[:border] }
+            data = { command: true, order: [:path], styles: theme[:banner], border: theme[:border] }
           end
           if verbose
             out = []
-            out << cmd.sub(/\A\S+/, &:upcase) if data[:command]
+            if data[:command]
+              if /\A(?:"((?:[^"]|(?<=\\)")+)"|'((?:[^']|(?<=\\)')+)'|(\S+)) /.match(cmd)
+                path = $3 || $2 || $1
+                cmd = cmd.sub(path, File.basename(path).upcase)
+              end
+              out << cmd
+            end
             data[:order].each do |val|
               if val.is_a?(Array)
                 s = ' '
@@ -803,14 +935,15 @@ module Squared
         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
+          unless items.empty?
+            pad = items.size.to_s.size
             items.each_with_index do |val, i|
-              next unless reg.empty? || reg.any? { |pat| pat.match?(val[0]) }
+              next unless reg.empty? || reg.any? { |pat| val[0] =~ pat }
 
               out << "#{(i + 1).to_s.rjust(pad)}. #{each ? each.(val) : val[0]}"
             end
           end
+          sub = [headerstyle]
           if out.empty?
             out = ["No #{type} were found:", '']
             unless grep.empty?
@@ -820,54 +953,81 @@ module Squared
             end
             if from
               out << from
-              pat = /\A(#{Regexp.escape(out.last)})(.*)\z/m
+              pat = /\A(#{Regexp.escape(from)})(.*)\z/
             end
           else
-            pat = /\A(\s*\d+\.)(.+)\z/m
+            pat = /\A(\s*\d+\.)(.+)\z/
+            unless grep.empty?
+              footer = "#{out.size} found"
+              sub << { pat: /\A(\d+)( .+)\z/, styles: theme[:inline] }
+            end
           end
-          sub = [headerstyle]
           sub << { pat: pat, styles: theme[:active] } if pat
-          emphasize(out, title: task_join(name, cmd), border: borderstyle, sub: sub)
+          emphasize(out, title: task_join(name, cmd), border: borderstyle, sub: sub, footer: footer, right: true)
         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
 
-        def append_repeat(flag, opts)
-          opts.each { |val| @session << shell_option(flag, val, quote: true) }
+        def append_repeat(flag, opts, target: @session)
+          opts.each { |val| target << shell_option(flag, val, quote: true) }
         end
 
-        def append_value(opts, delim: false, escape: true)
-          @session << '--' if delim && !opts.empty?
-          opts.each { |val| @session << (escape ? shell_escape(val) : shell_quote(val)) }
+        def append_value(opts, target: @session, delim: false, escape: true)
+          return if opts.empty?
+
+          target << '--' if delim
+          opts.each { |val| target << (escape ? shell_escape(val) : shell_quote(val)) }
         end
 
-        def append_first(list, flag: true, equals: false, quote: false, **kwargs)
+        def append_hash(opts, target: @session)
+          out = target.to_s
+          opts.each do |key, val|
+            key = key.to_s
+            key = "--#{key}" unless key[0] == '-'
+            next if out =~ Regexp.new(" #{key}(?: |=|$)")
+
+            case val
+            when String
+              append_repeat(key, [val], target: target)
+            when Array
+              append_repeat(key, val, target: target)
+            when Numeric
+              target << (key + (key.start_with?('--') ? '=' : '') + val)
+            when false
+              target << key.sub(/^--(?!no-)/, '--no-')
+            else
+              target << key
+            end
+          end
+        end
+
+        def append_first(list, target: @session, flag: true, equals: false, quote: false, escape: true, **kwargs)
           list.each do |opt|
             next unless (val = option(opt, **kwargs))
 
-            return @session << (if flag
-                                  shell_option(opt, equals ? val : nil, quote: quote)
-                                else
-                                  shell_quote(val)
-                                end)
+            return target << (if flag
+                                shell_option(opt, equals ? val : nil, quote: quote, escape: escape)
+                              else
+                                shell_quote(val)
+                              end)
           end
         end
 
-        def append_option(list, equals: false, quote: false, **kwargs)
+        def append_option(list, target: @session, equals: false, quote: false, escape: true, **kwargs)
           list.each do |flag|
             next unless (val = option(flag, **kwargs))
 
-            @session << shell_option(flag, equals ? val : nil, quote: quote)
+            target << shell_option(flag, equals ? val : nil, quote: quote, escape: escape)
           end
         end
 
-        def append_nocolor(flag = nil)
-          @session << '--no-color' if flag || !ARG[:COLOR] || stdin?
+        def append_nocolor(target: @session)
+          target << '--no-color' if !ARG[:COLOR] || stdin? || option('no-color', ignore: false)
         end
 
-        def guard_params(action, flag, args: nil, key: nil, pat: nil)
+        def param_guard(action, flag, args: nil, key: nil, pat: nil)
           if args && key
             val = args[key]
             return val unless val.nil? || (pat && !val.match?(pat))
@@ -918,17 +1078,48 @@ module Squared
           ret && !ret.empty? ? ret : [val]
         end
 
-        def pwd_set(done = nil, pass: false, &blk)
+        def colormap(val)
+          val.compact.map { |s| color(s) }.flatten
+        end
+
+        def on(event, action, *args, **kwargs)
+          return unless (obj = @events[event][action])
+
+          if obj.is_a?(Array) && obj[1].is_a?(Hash)
+            opts = kwargs.empty? ? obj[1] : obj[1].merge(kwargs)
+            target = obj[0]
+          else
+            opts = kwargs
+            target = obj
+          end
+          as_a(target, flat: true).each do |cmd|
+            case cmd
+            when Proc, Method
+              cmd.call(*args, **opts)
+            when String
+              run_s(cmd, **opts)
+            end
+          end
+        end
+
+        def pwd_set(done = nil, pass: false, from: nil, &blk)
           pwd = Pathname.pwd
           if block_given?
-            if path == pwd || pass == true || (pass.is_a?(String) && semscan(pass).join >= RUBY_VERSION)
-              ret = instance_eval(&blk)
+            begin
+              if path == pwd || pass == true || (pass.is_a?(String) && semscan(pass).join >= RUBY_VERSION)
+                ret = instance_eval(&blk)
+              else
+                Dir.chdir(path)
+                ret = instance_eval(&blk)
+                Dir.chdir(pwd)
+              end
+            rescue StandardError => e
+              log.error e
+              ret = on(:error, from, e) if from
+              raise if exception && ret != true
             else
-              Dir.chdir(path)
-              ret = instance_eval(&blk)
-              Dir.chdir(pwd)
+              ret
             end
-            ret
           elsif @pwd == pwd
             @pwd = nil
             pwd unless done
@@ -973,6 +1164,26 @@ module Squared
                        end
         end
 
+        def task_build(keys)
+          namespace name do
+            keys.each do |key|
+              next unless workspace.task_include?(self, key)
+
+              action = workspace.series.name_get(key)
+              unless @pass.include?(key.to_s) || workspace.task_defined?(name, action)
+                workspace.task_desc(@desc, action)
+                task action do
+                  __send__(key)
+                end
+              end
+              next if (items = @children.select { |item| item.task_include?(key) }).empty?
+
+              workspace.task_desc(@desc, action, 'workspace')
+              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?('..')
         end
@@ -1001,7 +1212,7 @@ module Squared
         end
 
         def invoked_sync?(action, val = nil)
-          return true if !val.nil? || from_sync?(ac = workspace.task_name(action))
+          return true if val || 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?
 
@@ -1009,7 +1220,7 @@ module Squared
             true
           else
             val = workspace.series.name_get(action)
-            val == action ? false : invoked_sync?(val)
+            val != action && invoked_sync?(val)
           end
         end