squared 0.2.2 → 0.3.0

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

@@ -25,7 +25,7 @@ module Squared
           def bannerargs(*); end
 
           def tasks
-            %i[build depend graph doc test copy clean].freeze
+            %i[build depend graph doc lint test copy clean].freeze
           end
 
           def as_path(val)
@@ -46,7 +46,7 @@ module Squared
           end
 
           def to_s
-            super.match(/[^:]+\z/)[0]
+            super[/[^:]+\z/, 0]
           end
         end
 
@@ -68,12 +68,19 @@ module Squared
           @group = group&.to_s.freeze
           @depend = kwargs[:depend]
           @doc = kwargs[:doc]
+          @lint = kwargs[:lint]
           @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
+          @envname = @name.gsub(/[^\w]+/, '_').upcase.freeze
+          kwargs[:exception] = 'PIPE_FAIL'
+          @exception = if kwargs.key?(:exception)
+                         env_bool(kwargs[:exception], workspace.exception, strict: true)
+                       else
+                         workspace.exception
+                       end
+          @pipe = kwargs.key?(:pipe) ? env_pipe(kwargs[:pipe], workspace.pipe, strict: true) : workspace.pipe
           @verbose = kwargs.key?(:verbose) ? kwargs[:verbose] : workspace.verbose
           @theme = if !@verbose
                      {}
@@ -95,7 +102,6 @@ module Squared
             last: last,
             error: error
           }
-          @envname = @name.gsub(/[^\w]+/, '_').upcase.freeze
           @desc = (@name.include?(':') ? @name.split(':').join(ARG[:SPACE]) : @name).freeze
           @parent = nil
           @global = false
@@ -116,6 +122,7 @@ module Squared
             end
             @depend = @script[:depend] if @depend.nil?
             @doc = @script[:doc] if @doc.nil?
+            @lint = @script[:lint] if @lint.nil?
             @test = @script[:test] if @test.nil?
             @clean = @script[:clean] if @clean.nil?
             @exclude = @script[:exclude] if @exclude.empty? && @script.key?(:exclude)
@@ -128,7 +135,7 @@ module Squared
           if @output[0].nil?
             if (scr = data[:script])
               @global = true
-              script_set(scr, prod: kwargs[:prod])
+              script_set(scr, args: data.fetch(:args, kwargs[:args]), prod: kwargs[:prod])
             elsif (run = data[:run])
               @global = true
               run_set run
@@ -136,11 +143,11 @@ module Squared
             unless data[:env]
               if (scr = kwargs[:script])
                 @global = false
-                script_set scr
+                script_set(scr, args: kwargs[:args])
               elsif @script && !data[:global]
                 if (scr = @script[:script])
                   @global = false
-                  script_set scr
+                  script_set(scr, args: @script.fetch(:args, kwargs[:args]))
                 elsif (run = @script[:run])
                   @global = false
                   run_set run
@@ -151,6 +158,7 @@ module Squared
             @global = true
             run_set data[:run]
           end
+          @global = true
         end
 
         def initialize_events(ref, **)
@@ -194,14 +202,10 @@ module Squared
         end
 
         def initialize_env(dev: nil, prod: nil, **)
-          pre = "BUILD_#{@envname}"
-          @dev = env_match("#{pre}_DEV", dev)
-          @prod = env_match("#{pre}_PROD", prod)
+          @dev = env_match('BUILD', dev, suffix: 'DEV', strict: true)
+          @prod = env_match('BUILD', prod, suffix: 'PROD', strict: true)
           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?
+          if @output[2] != false && (val = env('BUILD', suffix: 'ENV'))
             begin
               data = JSON.parse(val)
               raise_error('invalid JSON object', val, hint: "#{prefix}_ENV") unless data.is_a?(Hash)
@@ -211,6 +215,10 @@ module Squared
               @output[2] = data
             end
           end
+          if cmd != false && !cmd.is_a?(Array)
+            @output[cmd ? 1 : 3] = shell_split(val, join: true) if (val = env('BUILD', suffix: 'OPTS'))
+            @output[4] = shell_split(val, join: true) if cmd.nil? && (val = env('SCRIPT', suffix: 'OPTS'))
+          end
           @version = val if (val = env('BUILD', suffix: 'VERSION'))
           return unless (val = env('BUILD', strict: true))
 
@@ -242,23 +250,16 @@ module Squared
                   when 'graph'
                     next unless graph?
 
-                    check = lambda do |args|
-                      next args if (args = args.to_a).empty?
-
-                      param_guard(action, flag, args: args.reject { |val| name == val.to_s })
-                    end
-
-                    format_desc action, flag, 'project*'
-                    if flag == :run
-                      task flag do |_, args|
-                        graph check.(args)
-                      end
-                    else
-                      task flag do |_, args|
-                        out, done = graph(check.(args), out: [])
+                    format_desc action, flag, '(-)project*'
+                    task flag do |_, args|
+                      args = param_guard(action, flag, args: args.to_a.reject { |val| name == val.to_s })
+                      if flag == :run
+                        graph args
+                      else
+                        out, done = graph(args, out: [])
                         out.map! do |val|
                           done.each_with_index do |proj, i|
-                            next unless Regexp.new(" #{Regexp.escape(proj.name)}(?:@\\d|\\z)") =~ val
+                            next unless val =~ / #{Regexp.escape(proj.name)}(?:@\d|\z)/
 
                             val += " (#{i.succ})"
                             break
@@ -301,8 +302,8 @@ module Squared
               false
             end
           end
-          if path.is_a?(String) && (data = %r{^(.+)[\\/]\*+$}.match(path))
-            return self unless checkdir.(path = basepath(data[1]))
+          if path.is_a?(String) && (seg = path[%r{^(.+)[\\/]\*+$}, 1])
+            return self unless checkdir.(path = basepath(seg))
 
             path = path.children.select { |val| checkdir.(val) }
           end
@@ -340,63 +341,87 @@ module Squared
 
           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)
+            warn log_message(Logger::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'), **)
+        def build(*args, sync: invoked_sync?('build'), from: :run, **)
           banner = verbose
           if args.empty?
-            return unless from == :build
+            return unless from == :run
 
-            cmd, opts, var, flags = @output
+            args = @output
             banner = verbose == 1 if task_invoked?('build', 'build:sync')
+          end
+          if args.all? { |val| val.is_a?(Array) }
+            cmd = []
+            var = {}
+            args.each do |val|
+              a, b, c, d, e = val
+              case b
+              when Hash
+                b = append_hash(b).join(' ')
+              when Enumerable
+                b = b.to_a.join(' ')
+              end
+              d = append_hash(d).join(' ') if d.is_a?(Hash)
+              if a
+                cmd << [a, d, b].compact.join(' ')
+              else
+                next unless respond_to?(:compose)
+
+                cmd << a if (a = compose(as_get(b), d, script: true, args: e, from: from))
+              end
+              var.merge!(c) if c.is_a?(Hash)
+            end
+            cmd = cmd.join(' && ')
           else
-            cmd = args.shift
-            opts = args.map { |val| shell_quote(val, force: false) }.join(' ')
+            cmd, opts, var, flags, scr = args
           end
           if cmd
+            cmd = as_get(cmd)
+            opts = compose(opts, script: false) if opts && respond_to?(:compose)
+            flags = append_hash(flags).join(' ') if flags.is_a?(Hash)
             case opts
-            when String
-              cmd = "#{cmd} #{opts}"
-            when Array
-              cmd = as_a(cmd).concat(opts).join(' && ')
+            when Hash
+              opts = append_hash(opts)
+              cmd = as_a(cmd).push(flags).concat(opts).compact.join(' ')
+            when Enumerable
+              cmd = as_a(cmd).concat(opts.to_a)
+              cmd.map! { |val| "#{val} #{flags}" } if flags
+              cmd = cmd.join(' && ')
             else
-              cmd = [cmd, compose(opts, script: false)].compact.join(' ') unless opts == false || !respond_to?(:compose)
+              cmd = [cmd, flags, opts].compact.join(' ') if opts || flags
             end
           else
             return unless respond_to?(:compose)
 
-            cmd = compose(opts, flags, from: from, script: true)
+            cmd = compose(as_get(opts), flags, script: true, args: scr, from: from)
           end
           run(cmd, var, from: from, banner: banner, sync: sync)
         end
 
         def depend(*, sync: invoked_sync?('depend'), **)
-          return unless @depend
-
-          run(@depend, from: :depend, sync: sync)
-        end
-
-        def copy(*, sync: invoked_sync?('copy'), **)
-          return unless @copy
-
-          run_s(@copy, from: :copy, sync: sync)
+          run_b(@depend, sync: sync, from: :depend)
         end
 
         def doc(*, sync: invoked_sync?('doc'), **)
-          return unless @doc
+          run_b(@doc, sync: sync, from: :doc)
+        end
 
-          build(*as_a(@doc), from: :doc, sync: sync)
+        def lint(*, sync: invoked_sync?('lint'), **)
+          run_b(@lint, sync: sync, from: :lint)
         end
 
         def test(*, sync: invoked_sync?('test'), **)
-          return unless @test
+          run_b(@test, sync: sync, from: :test)
+        end
 
-          build(*as_a(@test), from: :test, sync: sync)
+        def copy(*, sync: invoked_sync?('copy'), **)
+          run_b(@copy, sync: sync, from: :copy)
         end
 
         def clean(*, sync: invoked_sync?('clean'), **)
@@ -405,14 +430,22 @@ module Squared
           on :first, :clean
           case @clean
           when String
-            run(@clean, from: :clean, sync: sync)
+            run_s(@clean, from: :clean, sync: sync)
+          when Hash
+            begin
+              @clean.each { |cmd, opts| build(cmd.to_s, opts, sync: sync) }
+            rescue StandardError => e
+              log.error e
+              ret = on(:error, from, e)
+              raise if @exception && ret != true
+            end
           when Enumerable
-            (@clean.is_a?(Hash) ? @clean.values : as_a(@clean)).each do |val|
+            as_a(@clean).each do |val|
               val = val.to_s
               path = basepath(val)
               if path.directory? && val =~ %r{[\\/]\z}
                 log.warn "rm -rf #{path}"
-                path.rmtree(verbose: true)
+                path.rmtree(verbose: verbose)
               else
                 log.warn "rm #{path}"
                 (val.include?('*') ? Dir[path] : [path]).each do |file|
@@ -441,8 +474,9 @@ module Squared
               end
             end
           end
-          pass.concat(split_escape(val)) if (val = env('GRAPH_PASS', strict: true))
-          data = graph_collect(self, start)
+          pass += 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] })
           unless out
             data[name] << self
             on :first, :graph
@@ -476,6 +510,12 @@ module Squared
           (@events[name.to_sym] ||= {})[key.to_sym] = [block_given? ? [blk] + args : args, kwargs]
         end
 
+        def as(cmd, script, to = nil)
+          script = { "#{script}": to } if to
+          data = (@as ||= {})[cmd.to_sym] ||= {}
+          script.each { |key, val| data[key.to_s] = val }
+        end
+
         def variable_set(key, *val, **kwargs)
           if variables.include?(key)
             case key
@@ -544,6 +584,10 @@ module Squared
           !!@doc
         end
 
+        def lint?
+          !!@lint
+        end
+
         def test?
           !!@test
         end
@@ -623,9 +667,16 @@ module Squared
         end
 
         def run(cmd = @session, var = nil, exception: @exception, sync: true, banner: true, chdir: path, from: nil, **)
+          unless cmd
+            if warning?
+              from &&= from.to_s
+              warn log_message(Logger::WARN, from || 'unknown', subject: project, hint: 'no command given')
+            end
+            return
+          end
           cmd = session_done(cmd)
           log.info cmd
-          on :first, from if from
+          on :first, from
           begin
             if cmd.match?(/\A[^:]+:[^:]/) && workspace.task_defined?(cmd)
               log.warn "ENV was discarded: #{var}" if var
@@ -637,22 +688,32 @@ module Squared
             end
           rescue StandardError => e
             log.error e
-            ret = on(:error, from, e) if from
+            ret = on(:error, from, e)
             raise unless ret == true
           else
-            on :last, from if from
+            on :last, from
           end
         end
 
         def run_s(*cmd, env: nil, sync: true, banner: verbose != false, from: nil, **kwargs)
-          on :first, from if from
+          on :first, from
           begin
             cmd.flatten.each { |val| run(val, env, sync: sync, banner: banner, **kwargs) }
           rescue StandardError => e
-            ret = on(:error, from, e) if from
+            ret = on(:error, from, e)
             raise unless ret == true
           end
-          on :last, from if from
+          on :last, from
+        end
+
+        def run_b(obj, from: nil, sync: true)
+          return unless obj
+
+          if obj.is_a?(Array) && obj.any? { |val| !val.is_a?(String) }
+            build(*obj, from: from, sync: sync)
+          else
+            run_s(obj.is_a?(Enumerable) ? obj.to_a : obj, from: from, sync: sync)
+          end
         end
 
         def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], depth: 0, last: false,
@@ -739,9 +800,11 @@ module Squared
           done
         end
 
-        def graph_collect(target, start = [], data: {})
+        def graph_collect(target, start = [], data: {}, pass: [])
           deps = []
           (start.empty? ? target.instance_variable_get(:@graph) : start)&.each do |val|
+            next if pass.include?(val)
+
             if (obj = workspace.find(name: val))
               next unless obj.enabled?
 
@@ -749,8 +812,11 @@ module Squared
             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 pass.include?(proj.name)
+
+              graph_collect(proj, data: data, pass: pass) if proj.graph? && !data.key?(proj.name)
               next if (objs = data.fetch(proj.name, [])).include?(target)
 
               deps << proj
@@ -781,11 +847,25 @@ module Squared
           if (val = PATH[prefix] || PATH[prefix.to_sym])
             cmd[0] = shell_quote(val, force: false)
           end
-          split_escape(val).each { |opt| cmd << fill_option(opt) } if options && (val = env("#{prefix}_OPTIONS"))
           ret = JoinSet.new(cmd.flatten(1))
+          if options && (val = env("#{prefix}_OPTIONS"))
+            split_escape(val).each { |opt| ret.last(fill_option(opt), /^(--?[^ =]+)[ =].+$/) }
+          end
           main ? @session = ret : ret
         end
 
+        def session_delete(*list, target: @session)
+          ret = []
+          list.each do |val|
+            pat = /^#{Regexp.escape(shell_option(val))}(?: |=|$)/
+            if (key = target.find { |opt| opt =~ pat })
+              target.delete(key)
+              ret << key
+            end
+          end
+          ret
+        end
+
         def session_output(*cmd, **kwargs)
           session(*cmd, main: false, options: false, **kwargs)
         end
@@ -808,38 +888,86 @@ module Squared
           nil
         end
 
-        def option_partition(opts, list, target: @session, no: [], first: false, pass: ['='])
-          out = []
+        def option_sanitize(opts, list, target: @session, no: nil, first: false, pass: ['='])
+          ret = []
+          reg = []
           bare = []
-          reg, list = list.partition do |val|
-            next unless (n = val.index('='))
-
-            bare << val[0..n - 1] if val.end_with?('?')
-            true
+          e = []
+          b = []
+          p = []
+          q = []
+          i = []
+          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 += bare
-          no = no.map { |val| (n = val.index('=')) ? val[0..n - 1] : val }
+          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 'q'
+                q << flag
+              when 'p'
+                p << flag
+              when 'i'
+                i << 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 out << opt if found
+            next ret << opt if found
 
-            if list.include?(opt)
+            if bare.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
+              if opt =~ /^([^=]+)=(.+)$/
+                a = $1
+                if e.include?(a)
+                  target << shell_option(a, $2)
+                elsif q.include?(a)
+                  target << quote_option(a, $2)
+                elsif p.include?(a)
+                  target << quote_option(a, basepath($2))
+                elsif b.include?(a) || (i.include?(a) && /^\d+$/.match?($2))
+                  target << basic_option(a, $2)
+                else
+                  ret << opt
+                end
+                opt = a
+              else
+                ret << opt
+              end
               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]
+          [ret, reg.empty? ? /\A\s+\z/ : /^(#{reg.join('|')})=(.+)$/]
         end
 
-        def option_clear(params, target: @session, **kwargs)
+        def option_clear(opts, target: @session, **kwargs)
           kwargs[:subject] ||= target&.first
           kwargs[:hint] ||= 'not used'
-          warn log_message(:warn, params.join(', '), **kwargs) unless params.empty?
+          warn log_message(Logger::WARN, opts.join(', '), **kwargs) unless opts.empty?
         end
 
         def print_item(*val)
@@ -982,41 +1110,78 @@ module Squared
           opts.each { |val| target << shell_option(flag, val) }
         end
 
-        def append_value(*opts, target: @session, delim: false, escape: true, quote: false)
-          return if (opts = opts.flatten).empty?
-
-          target << '--' if delim
-          opts.each { |val| target << (escape ? shell_escape(val, quote: quote) : shell_quote(val)) }
-        end
-
-        def append_hash(opts, target: @session)
-          out = target.to_s
-          opts.each do |key, val|
-            key = key.to_s
-            key = shell_option(key) unless key[0] == '-'
-            next if out =~ Regexp.new(" #{key}(?: |=|$)")
+        def append_hash(data, target: @session)
+          target ||= []
+          if (type = env('BUILD', suffix: 'TYPE') || ENV['BUILD_TYPE'])
+            type = "__#{type}__"
+            if (extra = data[type] || data[type.to_sym]).is_a?(Hash)
+              data = data.merge(extra)
+            else
+              extra = nil
+            end
+          end
+          data.each do |key, val|
+            next if (key = key.to_s).start_with?('__')
 
+            if val.nil? || extra || session_arg?(key, target: target)
+              session_delete(key, target: target)
+              next if val.nil?
+            end
             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.to_s)
+              target << basic_option(key, val)
             when false
-              target << key.sub(/^--(?!no-)/, '--no-')
+              target << shell_option(key).sub(/^--(?!no-)/, '--no-')
             else
-              target << key
+              target << shell_option(key, val.is_a?(String) ? val : nil)
             end
           end
+          target
         end
 
-        def append_first(list, target: @session, flag: true, equals: false, quote: false, escape: true, **kwargs)
-          list.each do |opt|
+        def append_any(val, target: @session, delim: false)
+          if delim && !target.include?('--')
+            target << '--'
+          else
+            delim = false
+          end
+          case val
+          when String
+            target << val
+          when Hash
+            append_hash(val, target: target)
+          when Enumerable
+            if target.is_a?(Array)
+              target.concat(val.to_a)
+            else
+              target.merge(val.to_a)
+            end
+          else
+            target.delete('--') if delim
+          end
+        end
+
+        def append_value(*list, target: @session, delim: false, escape: false, quote: true)
+          return if (list = list.flatten).empty?
+
+          target << '--' if delim && !target.include?('--')
+          list.map do |val|
+            target << (val = escape ? shell_escape(val, quote: quote) : shell_quote(val))
+            val
+          end
+        end
+
+        def append_first(*list, target: @session, flag: true, equals: false, escape: true, quote: true, force: true,
+                         **kwargs)
+          return if (list = list.flatten).empty?
+
+          list.flatten.each do |opt|
             next unless (val = option(opt, **kwargs))
 
             return target << (if flag
-                                shell_option(opt, equals ? val : nil, quote: quote, escape: escape)
+                                shell_option(opt, equals ? val : nil, quote: quote, escape: escape, force: force)
                               else
                                 shell_quote(val)
                               end)
@@ -1024,18 +1189,33 @@ module Squared
           nil
         end
 
-        def append_option(list, target: @session, equals: false, quote: false, escape: true, **kwargs)
-          list.each do |flag|
+        def append_option(*list, target: @session, no: false, equals: false, escape: true, quote: true, force: true,
+                          **kwargs)
+          return if (list = list.flatten).empty?
+
+          ret = []
+          list.flatten.each do |flag|
             next unless (val = option(flag, **kwargs))
 
-            target << shell_option(flag, equals ? val : nil, quote: quote, escape: escape)
+            if val == '0' && no
+              flag = "no-#{flag}"
+              val = nil
+            end
+            ret << shell_option(flag, equals ? val : nil, escape: escape, quote: quote, force: force)
           end
+          ret.each { |val| target << val } unless ret.empty?
         end
 
         def append_nocolor(target: @session)
           target << '--no-color' if !ARG[:COLOR] || stdin? || option('no-color', ignore: false)
         end
 
+        def collect_hash(data, pass: [])
+          ret = []
+          data.each { |key, val| ret += val unless pass.include?(key) }
+          ret
+        end
+
         def param_guard(action, flag, args: nil, key: nil, pat: nil)
           if args && key
             val = args[key]
@@ -1073,9 +1253,9 @@ module Squared
         end
 
         def indexitem(val)
-          return unless (data = /\A\^(\d+)(:.+)?\z/.match(val))
+          return unless val =~ /\A\^(\d+)(:.+)?\z/
 
-          [data[1].to_i, data[2] ? data[2][1..-1] : nil]
+          [$1.to_i, $2 && $2[1..-1]]
         end
 
         def indexerror(val, list = nil)
@@ -1091,8 +1271,8 @@ module Squared
           val.compact.map { |s| color(s) }.flatten
         end
 
-        def on(event, action, *args, **kwargs)
-          return unless (obj = @events[event][action])
+        def on(event, from, *args, **kwargs)
+          return unless from && (obj = @events[event][from])
 
           if obj.is_a?(Array) && obj[1].is_a?(Hash)
             opts = kwargs.empty? ? obj[1] : obj[1].merge(kwargs)
@@ -1111,7 +1291,7 @@ module Squared
           end
         end
 
-        def pwd_set(done = nil, pass: false, from: nil, &blk)
+        def pwd_set(done = nil, pass: false, from: nil, dryrun: false, &blk)
           pwd = Pathname.pwd
           if block_given?
             begin
@@ -1124,8 +1304,10 @@ module Squared
               end
             rescue StandardError => e
               log.error e
-              ret = on(:error, from, e) if from
-              raise if exception && ret != true
+              unless dryrun
+                ret = on(:error, from, e)
+                raise if exception && ret != true
+              end
             else
               ret
             end
@@ -1145,6 +1327,8 @@ module Squared
         end
 
         def run_set(cmd, val = nil, opts: nil, **)
+          return @output = cmd.dup if cmd.is_a?(Array)
+
           unless @output[1] == false && !@output[0].nil?
             if opts == false
               @output[1] = false
@@ -1162,7 +1346,7 @@ module Squared
           @output[0] = cmd
         end
 
-        def script_set(cmd, prod: nil, **)
+        def script_set(cmd, prod: nil, args: nil, **)
           return if @output[1] == false && @output[0].nil?
 
           @output[0] = nil
@@ -1171,23 +1355,29 @@ module Squared
                        else
                          cmd
                        end
+          @output[4] = args unless @output[4] == false || args.nil?
+        end
+
+        def as_get(val)
+          @global && (ret = @as && @as[from] && @as[from][val]) ? ret : val
         end
 
         def task_build(keys)
           namespace name do
+            ws = workspace
             keys.each do |key|
-              next unless workspace.task_include?(self, key)
+              next unless ws.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)
+              action = ws.series.name_get(key)
+              unless @pass.include?(key.to_s) || ws.task_defined?(name, action) || ws.task_exclude?(action, self)
+                ws.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')
+              ws.task_desc(@desc, action, 'workspace')
               task task_join(action, 'workspace') => items.map { |item| task_join(item.name, action) }
             end
           end
@@ -1212,6 +1402,13 @@ module Squared
           end
         end
 
+        def session_arg?(*list, target: @session, value: false)
+          list.any? do |val|
+            pat = /^#{Regexp.escape(shell_option(val))}#{value ? '[ =].' : '(?:[ =]|$)'}/
+            target.any? { |opt| opt =~ pat }
+          end
+        end
+
         def from_sync?(*val)
           if task_invoked?(key = task_join(*val))
             !workspace.task_defined?(key, 'sync')