squared 0.5.22 → 0.6.0

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'date'
 require 'logger'
 
 module Squared
@@ -15,15 +14,17 @@ module Squared
         include Prompt
         include Utils
         include Support
+        include Workspace::Support::Variables
         include Rake::DSL
 
-        VAR_SET = %i[parent global script index envname desc dependfile dependindex theme archive env dev prod graph
-                     pass only exclude asdf].freeze
+        OPTIONS = Workspace::Support.hashobj
+        VAR_SET = %i[parent global script index envname desc dependfile dependname dependindex theme archive env graph
+                     dev prod pass only exclude asdf].freeze
         BLK_SET = %i[run depend doc lint test copy clean].freeze
         SEM_VER = /\b(\d+)(?:(\.)(\d+))?(?:(\.)(\d+))?[-.]?(\S+)?\b/.freeze
         URI_SCHEME = %r{\A([a-z][a-z\d+-.]*)://[^@:\[\]\\^<>|\s]}i.freeze
         TASK_METADATA = Rake::TaskManager.record_task_metadata
-        private_constant :VAR_SET, :BLK_SET, :SEM_VER, :URI_SCHEME, :TASK_METADATA
+        private_constant :OPTIONS, :VAR_SET, :BLK_SET, :SEM_VER, :URI_SCHEME, :TASK_METADATA
 
         class << self
           def populate(*); end
@@ -35,13 +36,33 @@ module Squared
             (%i[build archive graph prereqs] + BLK_SET).freeze
           end
 
-          def as_path(val)
-            case val
-            when Pathname
-              val
-            when String
-              Pathname.new(val)
+          def options(*args, **kwargs)
+            name = nil
+            with = []
+            proj = []
+            opts = []
+            args.each do |val|
+              case val
+              when String
+                if name
+                  opts << val
+                else
+                  name = val
+                end
+              when Symbol
+                if name
+                  proj << val
+                else
+                  with << val
+                end
+              end
             end
+            return if !name || (opts.empty? && kwargs.empty? && with.empty?)
+
+            base = OPTIONS[ref]
+            data = [opts.freeze, kwargs.freeze, with.freeze].freeze
+            proj << :_ if proj.empty?
+            proj.each { |val| (base[val] ||= {})[name.to_s] = data }
           end
 
           def ref
@@ -61,28 +82,39 @@ module Squared
           def to_s
             super[/[^:]+\z/, 0]
           end
+
+          private
+
+          def as_path(val)
+            case val
+            when Pathname
+              val
+            when String
+              Pathname.new(val)
+            end
+          end
         end
 
         @@tasks = {}
         @@graph = { _: [] }
         @@asdf = Pathname.new("#{Dir.home}/.asdf").yield_self do |path|
-          if path.join('asdf.sh').exist?
-            [path, 15]
-          elsif ENV['ASDF_DATA_DIR']
-            [Pathname.new(ENV['ASDF_DATA_DIR']), 16]
-          end
+          version = if path.join('asdf.sh').exist?
+                      15
+                    elsif ENV['ASDF_DATA_DIR'] && (path = Pathname.new(ENV['ASDF_DATA_DIR'])).exist?
+                      16
+                    end
+          Struct.new(:path, :version).new(path, version) if version
         end
         @@print_order = 0
 
         subtasks({
           'graph' => %i[run print].freeze,
-          'unpack' => %i[zip tar gem ext].freeze,
-          'asdf' => %i[set exec current]
+          'unpack' => %i[zip gz tar ext].freeze,
+          'asdf' => %i[set exec current update latest where reshim]
         })
 
-        attr_reader :name, :workspace, :path, :theme, :group, :parent, :dependfile,
-                    :exception, :pipe, :verbose
-        attr_accessor :global, :project
+        attr_reader :name, :project, :workspace, :path, :theme, :group, :parent, :dependfile,
+                    :exception, :pipe, :verbose, :global
 
         def initialize(workspace, path, name, *, group: nil, first: {}, last: {}, error: {}, common: ARG[:COMMON],
                        **kwargs)
@@ -108,20 +140,20 @@ module Squared
                          else
                            val.nil? ? workspace.verbose : val
                          end
+          self.global = false
           @output = []
           @ref = []
           @children = []
           @events = hashobj.update({ first: first, last: last, error: error })
           @as = hashobj
           @desc = (@name.include?(':') ? @name.split(':').join(ARG[:SPACE]) : @name).freeze
-          @parent = nil
-          @global = false
           @log = nil
           @dev = nil
           @prod = nil
           @withargs = nil
           @session = nil
           @index = -1
+          parent_set kwargs[:parent]
           run_set(kwargs[:run], kwargs[:env], opts: kwargs.fetch(:opts, true))
           graph_set kwargs[:graph]
           pass_set kwargs[:pass]
@@ -157,32 +189,24 @@ module Squared
 
           data = @workspace.script_find(*@ref, @group)
           if @output[0].nil?
-            if (scr = data[:script])
+            if data[:script]
               unless kwargs[:script] == false
-                @global = true
-                script_set(scr, args: data.fetch(:args, kwargs[:args]), prod: kwargs[:prod])
+                script_set(data[:script], args: data.fetch(:args, kwargs[:args]), prod: kwargs[:prod], global: true)
               end
-            elsif (run = data[:run])
-              @global = true
-              run_set run
+            elsif data[:run]
+              run_set(data[:run], global: true)
             end
-            unless data[:env]
-              if (scr = kwargs[:script])
-                @global = false
-                script_set(scr, args: kwargs[:args])
-              elsif @script && !data[:global]
-                if (scr = @script[:script])
-                  @global = false
-                  script_set(scr, args: @script.fetch(:args, kwargs[:args]))
-                elsif (run = @script[:run])
-                  @global = false
-                  run_set run
-                end
+            if kwargs[:script]
+              script_set(kwargs[:script], args: kwargs[:args]) unless data[:env][:script]
+            elsif @script
+              if @script[:script]
+                script_set(@script[:script], args: @script.fetch(:args, kwargs[:args])) unless data[:global][:script]
+              elsif @script[:run] && !data[:global][:run]
+                run_set @script[:run]
               end
             end
-          elsif data[:env] && data[:run]
-            @global = true
-            run_set data[:run]
+          elsif data[:run] && data[:env][:run]
+            run_set(data[:run], global: true)
           end
         end
 
@@ -196,10 +220,11 @@ module Squared
           return if @log
 
           log = log.is_a?(Hash) ? log.dup : { file: log }
-          if (file = env('LOG_FILE'))
-            file = Time.now.strftime(file)
-          elsif (val = env('LOG_AUTO'))
-            file = "#{@name}-%s.log" % [case val
+          file = if (val = env('LOG_FILE'))
+                   Time.now.strftime(val)
+                 elsif (val = env('LOG_AUTO'))
+                   require 'date'
+                   "#{@name}-%s.log" % [case val
                                         when 'y', 'year'
                                           Date.today.year
                                         when 'm', 'month'
@@ -209,19 +234,21 @@ module Squared
                                         else
                                           val.include?('%') ? Time.now.strftime(val) : Time.now.strftime('%FT%T%:z')
                                         end]
-          elsif (val = log[:file])
-            file = val.is_a?(String) ? Time.now.strftime(val) : "#{@name}-#{Date.today}.log"
-          end
-          begin
-            file &&= @workspace.home.join(env('LOG_DIR', ''), file).realdirpath
-          rescue StandardError => e
-            file = nil
-            print_error e
-          end
+                 elsif (val = log[:file])
+                   if val.is_a?(String)
+                     Time.now.strftime(val)
+                   else
+                     require 'date'
+                     "#{@name}-#{Date.today}.log"
+                   end
+                 end
+                 .yield_self do |dir|
+                   @workspace.home.join(env('LOG_DIR', ''), dir).realdirpath if dir
+                 rescue StandardError => e
+                   print_error e
+                 end
           log[:progname] ||= @name
-          if (val = env('LOG_LEVEL', ignore: false))
-            log[:level] = val.match?(/\d/) ? log_sym(val.to_i) : val
-          end
+          log[:level] = val.match?(/\d/) ? log_sym(val.to_i) : val if (val = env('LOG_LEVEL', ignore: false))
           log.delete(:file)
           @log = [file, log]
         end
@@ -229,7 +256,7 @@ module Squared
         def initialize_env(dev: nil, prod: nil, **)
           @dev = env_match('BUILD', dev, suffix: 'DEV', strict: true)
           @prod = env_match('BUILD', prod, suffix: 'PROD', strict: true)
-          if (val = env('BUILD', suffix: 'ENV')) && @output[2] != false
+          if @output[2] != false && (val = env('BUILD', suffix: 'ENV'))
             @output[2] = parse_json(val, hint: "BUILD_#{@envname}_ENV") || @output[2]
           end
           unless @output[0] == false || @output[0].is_a?(Array)
@@ -244,7 +271,6 @@ module Squared
           @version = val if (val = env('BUILD', suffix: 'VERSION'))
           return unless (val = env('BUILD', strict: true))
 
-          @global = false
           if val == '0'
             @output = [false]
           elsif script?
@@ -326,6 +352,10 @@ module Squared
                      end
         end
 
+        def global=(val)
+          @global = val unless val.nil?
+        end
+
         def ref
           Base.ref
         end
@@ -353,17 +383,17 @@ module Squared
                         out, done = graph(args, out: [])
                         out.map! do |val|
                           n = done.index { |proj| val.match?(/ #{Regexp.escape(proj.name)}(?:@\d|\z)/) }
-                          n ? "#{val} (#{n.succ})" : val
+                          n ? val.subhint(n.succ) : val
                         end
                         emphasize(out, title: path, right: true, border: borderstyle, sub: [
-                          { pat: /\A(#{Regexp.escape(path.to_s)})(.*)\z/, styles: theme[:header] },
-                          { pat: /\A(#{Regexp.escape(name)})(.*)\z/, styles: theme[:active] },
-                          { pat: /\A((?~ \() \()(\d+)(\).*)\z/, styles: theme[:inline], index: 2 }
+                          opt_style(theme[:header], /\A(#{Regexp.escape(path.to_s)})(.*)\z/),
+                          opt_style(theme[:active], /\A(#{Regexp.escape(name)})(.*)\z/),
+                          opt_style(theme[:inline], /\A((?~ \() \()(\d+)(\).*)\z/, 2)
                         ])
                       end
                     end
                   when 'unpack'
-                    format_desc(action, flag, 'tag/url,dir,digest?,f|force?', before: flag == :ext ? 'ext' : nil)
+                    format_desc(action, flag, 'tag/url,dir,digest?,f/orce?', before: ('ext' if flag == :ext))
                     params = %i[tag dir digest force]
                     params.unshift(:ext) if flag == :ext
                     task flag, params do |_, args|
@@ -371,21 +401,21 @@ module Squared
                       tag = param_guard(action, flag, args: args, key: :tag)
                       dir = param_guard(action, flag, args: args, key: :dir)
                       unless tag.match?(URI_SCHEME)
-                        if flag == :gem
-                          tag = "https://rubygems.org/downloads/#{File.basename(tag, '.gem')}.gem"
-                        elsif @release
-                          tag = "%s.#{ext}" % [@release.include?('??') ? @release.sub('??', tag) : @release + tag]
-                        else
-                          raise_error("no base uri: #{tag}", hint: ext)
-                        end
-                      end
-                      case (digest = args.digest)
-                      when 'f', 'force'
-                        digest = nil
-                        force = true
-                      else
-                        force = args.fetch(:force, false)
+                        tag = if ext == 'gem'
+                                "https://rubygems.org/downloads/#{File.basename(tag, '.gem')}.gem"
+                              elsif @release
+                                "%s.#{ext}" % [@release.include?('??') ? @release.sub('??', tag) : @release + tag]
+                              else
+                                raise_error ArgumentError, "no base uri: #{tag}", hint: ext
+                              end
                       end
+                      force = case (digest = args.digest)
+                              when 'f', 'force'
+                                digest = nil
+                                true
+                              else
+                                args.fetch(:force, false)
+                              end
                       unpack(basepath(dir), uri: tag, digest: digest, ext: ext, force: force)
                     end
                   when 'asdf'
@@ -393,7 +423,7 @@ module Squared
 
                     case flag
                     when :set
-                      format_desc action, flag, 'version,opts*=u|home,p|parent'
+                      format_desc action, flag, 'version,dir?=u/home|p/arent'
                       task flag, [:version] do |_, args|
                         args = if (version = args.version)
                                  args.extras
@@ -403,14 +433,14 @@ module Squared
                                                                       .map(&:basename)
                                                                       .sort { |a, b| b <=> a }
                                                                       .push('latest', 'system'),
-                                                              accept: [['Confirm?', false, true]],
-                                                              values: ['Options'])
+                                                              accept: [accept_y('Confirm?')],
+                                                              values: 'Options', force: true)
                                  OptionPartition.strip(opts)
                                end
                         asdf(flag, args, version: version)
                       end
                     else
-                      format_desc(action, flag, flag == :exec ? 'command' : nil)
+                      format_desc(action, flag, ('command' if flag == :exec))
                       task flag do |_, args|
                         args = args.to_a
                         args << readline('Enter command', force: true) if args.empty? && flag == :exec
@@ -429,7 +459,7 @@ module Squared
         end
 
         def with(**kwargs, &blk)
-          @withargs = kwargs.empty? ? nil : kwargs
+          @withargs = (kwargs unless kwargs.empty?)
           if block_given?
             instance_eval(&blk)
             @withargs = nil
@@ -450,7 +480,6 @@ module Squared
             kwargs = hashdup(@withargs).update(kwargs) if @withargs
             kwargs[:group] = group if group && !kwargs.key?(:group)
             kwargs[:ref] = ref unless kwargs.key?(:ref)
-            parent = self
             proj = nil
             name = case name
                    when String, Symbol
@@ -458,8 +487,7 @@ module Squared
                    else
                      path.basename
                    end
-            workspace.add(path, name, **kwargs) do
-              __send__ :parent_set, parent
+            workspace.add(path, name, parent: self, **kwargs) do
               proj = self
               instance_eval(&blk) if block_given?
             end
@@ -475,14 +503,14 @@ module Squared
 
         def inject(obj, *args, **kwargs, &blk)
           if enabled?
-            out = obj.link(self, *args, **kwargs, &blk) if obj.respond_to?(:link)
-            if !out
-              print_error('link not compatible', subject: obj, hint: name)
-            elsif out.respond_to?(:build)
-              out.build
-            end
+            raise 'link not compatible' unless obj.respond_to?(:link) && (out = obj.link(self, *args, **kwargs, &blk))
+
+            out.build if out.respond_to?(:build)
           end
           self
+        rescue StandardError => e
+          print_error(e, subject: obj, hint: name)
+          self
         end
 
         def build(*args, sync: invoked_sync?('build'), from: :run, **)
@@ -490,8 +518,8 @@ module Squared
           if args.empty?
             return unless from == :run
 
-            banner = verbosetype > 1 if from_base?('build')
-            run_b(@run, sync: sync, from: from, banner: banner) if series?(@run)
+            banner = verbose? if from_base?('build')
+            run_b(@run, sync: sync, banner: banner, from: from) if series?(@run)
             args = @output
           end
           if args.first.is_a?(Struct)
@@ -499,18 +527,12 @@ module Squared
             args[0] = instance_eval(&blk) || f
             return unless args.first
           end
-          if args.all?(Array)
+          if args.all? { |val| val.is_a?(Array) }
             cmd = []
             var = {}
             args.each do |val|
-              case val.first
-              when Proc
-                instance_exec(*val[1..-1], &val.first)
-                next
-              when Method
-                val.first.call(*val[1..-1])
-                next
-              end
+              next instance_exec(*val[1..-1], &val.first) if val.first.is_a?(Proc)
+
               a, b, c, d, e = val
               case b
               when Hash
@@ -520,7 +542,7 @@ module Squared
               end
               d = append_hash(d, target: []).join(' ') if d.is_a?(Hash)
               if a
-                cmd << [replace_bin(a), d, b].compact.join(' ')
+                cmd << [a, d, b].compact.join(' ')
               else
                 next unless respond_to?(:compose)
 
@@ -531,33 +553,33 @@ module Squared
             cmd = cmd.join(' && ')
           else
             cmd, opts, var, flags, extra = args
-            if cmd
-              return run_b(cmd, sync: sync, from: from) if cmd.is_a?(Proc) || cmd.is_a?(Method)
+          end
+          if cmd
+            return run_b(cmd, sync: sync, from: from) if cmd.is_a?(Proc) || cmd.is_a?(Method)
 
-              cmd = replace_bin as_get(cmd, from)
-              opts = compose(opts, script: false) if opts && respond_to?(:compose)
-              flags = append_hash(flags, target: []).join(' ') if flags.is_a?(Hash)
-              case opts
-              when Hash
-                cmd = Array(cmd).push(flags)
-                                .concat(append_hash(opts, target: [], build: true))
-                                .compact
-                                .join(' ')
-              when Enumerable
-                cmd = Array(cmd).concat(opts.to_a)
-                cmd.map! { |val| "#{val} #{flags}" } if flags
-                cmd = cmd.join(' && ')
-              else
-                cmd = [cmd, flags, opts].compact.join(' ') if opts || flags
-              end
+            cmd = as_get cmd, from
+            opts = compose(opts, script: false) if opts && respond_to?(:compose)
+            flags = append_hash(flags, target: []).join(' ') if flags.is_a?(Hash)
+            case opts
+            when Hash
+              cmd = Array(cmd).push(flags)
+                              .concat(append_hash(opts, target: [], build: true))
+                              .compact
+                              .join(' ')
+            when Enumerable
+              cmd = Array(cmd).concat(opts.to_a)
+              cmd.map! { |val| "#{val} #{flags}" } if flags
+              cmd = cmd.join(' && ')
             else
-              return unless (opts || extra) && respond_to?(:compose)
-
-              cmd = compose(as_get(opts, from), flags, script: true, args: extra, from: from)
-              from = :script if from == :run && script?
+              cmd = [cmd, flags, opts].compact.join(' ') if opts || flags
             end
+          else
+            return unless (opts || extra) && respond_to?(:compose)
+
+            cmd = compose(as_get(opts, from), flags, script: true, args: extra, from: from)
+            from = :script if from == :run && script?
           end
-          run(cmd, var, sync: sync, from: from, banner: banner)
+          run(cmd, var, sync: sync, banner: banner, from: from)
         end
 
         def depend(*, sync: invoked_sync?('depend'), **)
@@ -570,16 +592,16 @@ module Squared
             next if @@graph[:_].include?(proj)
 
             if (val = ENV["PREREQS_#{proj.instance_variable_get(:@envname)}"] || ENV["PREREQS_#{proj.ref.upcase}"])
-              split_escape(val).each do |meth|
+              split_escape(val) do |meth|
                 if proj.respond_to?(meth.to_sym)
                   begin
                     proj.__send__(meth, sync: sync)
+                    next
                   rescue StandardError => e
                     on_error(e, :prereqs, exception: true)
                   end
-                else
-                  print_error(name, "method: #{meth}", subject: 'prereqs', hint: 'undefined')
                 end
+                print_error(name, 'method not found', subject: 'prereqs', hint: meth)
               end
             elsif proj.build?
               proj.build(sync: sync)
@@ -657,9 +679,9 @@ module Squared
         end
 
         def graph(start = [], tasks = nil, *, sync: invoked_sync?('graph'), pass: [], out: nil, **)
-          if (val = env('GRAPH', strict: true))
+          env('GRAPH', strict: true) do |val|
             tasks ||= []
-            split_escape(val).each do |task|
+            split_escape(val) do |task|
               if ref?(task.to_sym) && (script = workspace.script_get(:graph, ref: task.to_sym))
                 tasks.concat(script[:graph])
               else
@@ -667,7 +689,7 @@ module Squared
               end
             end
           end
-          pass.concat(split_escape(val)) if (val = env('GRAPH', suffix: 'PASS'))
+          env('GRAPH', suffix: 'PASS') { |val| pass.concat(split_escape(val)) }
           start, neg = start.partition { |name| !name.start_with?('-') }
           data = graph_collect(self, start, pass: neg.map! { |name| name[1..-1] })
           unless out
@@ -690,9 +712,9 @@ module Squared
           if !target.exist?
             target.mkpath
           elsif !target.directory?
-            raise_error('invalid location', hint: target)
+            raise_error Errno::EEXIST, target, hint: uri
           elsif !file && !target.empty?
-            raise_error('directory not empty', hint: target) unless force || env('UNPACK_FORCE')
+            raise_error Errno::EEXIST, target, hint: uri unless force || env('UNPACK_FORCE')
             create = true
           end
           if digest
@@ -712,25 +734,27 @@ module Squared
                    when 128, 'sha512'
                      Digest::SHA512
                    else
-                     raise_error "invalid checksum: #{digest}"
+                     raise_error "invalid checksum: #{digest}", hint: uri
                    end
           end
-          if (val = env('HEADERS')) && (val = parse_json(val, hint: "HEADERS_#{@envname}"))
-            headers = headers.is_a?(Hash) ? headers.merge(val) : val
+          env('HEADERS') do |val|
+            if (data = parse_json(val, hint: "HEADERS_#{@envname}"))
+              headers = headers.is_a?(Hash) ? headers.merge(data) : data
+            end
           end
           if file
             ext ||= File.extname(file)[1..-1]
           else
             require 'open-uri'
             data = nil
-            (uri = Array(uri)).each_with_index do |url, index|
+            (uri = Array(uri)).each_with_index do |url, i|
               URI.open(url, headers) do |f|
                 data = f.read
                 if algo && algo.hexdigest(data) != digest
                   data = nil
-                  raise_error("checksum failed: #{digest}", hint: url) if index == uri.size - 1
+                  raise_error "invalid checksum: #{digest}", hint: url if i == uri.size.pred
                 end
-                next if ext && index == 0
+                next if ext && i == 0
 
                 case f.content_type
                 when 'application/zip'
@@ -745,8 +769,8 @@ module Squared
               end
               break uri = url if data
             end
-            unless data && (ext ||= URI.decode_www_form_component(URI.parse(uri).path[/\.([\w%]+)(?:\?|\z)/, 1]))
-              raise_error("no content#{data ? ' type' : ''}", hint: uri)
+            unless data && (ext ||= URI.parse(uri).path[/\.(\w+)(?:\?|\z)/, 1])
+              raise_error(data ? TypeError : RuntimeError, "no content#{data ? ' type' : ''}", hint: uri)
             end
           end
           ext = ext.downcase
@@ -755,13 +779,13 @@ module Squared
           end
           begin
             unless file
-              if ext == 'gem'
-                dir = Dir.mktmpdir
-                file = File.new(File.join(dir, File.basename(uri)), 'w')
-              else
-                require 'tempfile'
-                file = Tempfile.new("#{name}-")
-              end
+              file = if ext == 'gem'
+                       dir = Dir.mktmpdir
+                       File.new(File.join(dir, File.basename(uri)), 'w')
+                     else
+                       require 'tempfile'
+                       Tempfile.new("#{name}-")
+                     end
               file.write(data)
               file.close
               file = Pathname.new(file)
@@ -775,7 +799,7 @@ module Squared
             case ext
             when 'zip', 'aar'
               session 'unzip', shell_quote(file), quote_option('d', target)
-            when 'tar', 'tgz', 'txz', 'tar.gz', 'tar.xz', 'gz', 'xz'
+            when 'tar', /\A(?:t|tar\.)?[gx]z\z/
               flags = +(verbose ? 'v' : '')
               if ext.end_with?('gz')
                 flags += 'z'
@@ -818,29 +842,32 @@ module Squared
         def asdf(flag, opts = [], version: nil)
           return unless @asdf
 
-          cmd = session 'asdf', flag
+          cmd = flag == :update ? session('asdf', 'plugin update') : session('asdf', flag)
           name = @asdf.first
-          legacy = @@asdf[1] == 15
+          legacy = @@asdf.version == 15
+          banner = true
           case flag
           when :set
-            u = has_value?(opts, %w[u home])
+            u = has_value?(opts, 'u', 'home')
             cmd << if legacy
                      cmd.delete(flag)
                      u ? 'global' : 'local'
-                   elsif has_value?(opts, %w[p parent])
+                   elsif has_value?(opts, 'p', 'parent')
                      '--parent'
                    elsif u
                      '--home'
                    end
             cmd << name << version
           when :exec
-            cmd << name unless opts.first.start_with?(/#{name}\b/)
             cmd.merge(opts)
           when :current
             cmd << '--no-header' unless legacy
             cmd << name
+          else
+            cmd << name
+            banner = flag == :update || flag == :reshim
           end
-          print_success if success?(run(from: :"asdf:#{flag}"), flag == :set)
+          success?(run(banner: banner, from: :"asdf:#{flag}"), flag == :set || flag == :reshim)
         end
 
         def first(key, *args, **kwargs, &blk)
@@ -880,28 +907,27 @@ module Squared
               instance_variable_set :"@#{key}", [blk]
             end
           else
-            log&.warn "series: @#{key} (invalid)"
+            log&.warn "series: @#{key}".subhint('invalid')
           end
           self
         end
 
-        def run(cmd = @session, var = nil, exception: self.exception, sync: true, from: nil, banner: true, chdir: path,
+        def run(cmd = @session, var = nil, exception: self.exception, sync: true, banner: true, from: nil, chdir: path,
                 interactive: nil, hint: nil, series: true, **)
-          unless cmd
-            print_error('no command session started', subject: project, hint: from, pass: true)
-            return
-          end
+          return print_error('no command session started', subject: project, hint: from, pass: true) unless cmd
+
           cmd = cmd.target if cmd.is_a?(OptionPartition)
-          if interactive && (!@session || !option('y'))
-            title, y = case interactive
-                       when Array
-                         interactive
-                       when String
-                         [interactive, 'N']
-                       else
-                         ['Run', 'Y']
-                       end
-            exit 1 unless confirm("#{title}? [#{sub_style(cmd.to_s, styles: theme[:inline])}]", y)
+          if interactive && sync && (!@session || !option('y'))
+            title, y, hint = case interactive
+                             when Array
+                               interactive
+                             when String
+                               [interactive, 'N']
+                             else
+                               ['Run', 'Y']
+                             end
+            title = "#{title} #{sub_style(hint, styles: theme[:active])}" if hint
+            exit 1 unless confirm_basic("#{title}?", cmd, y)
           end
           cmd = session_done cmd
           log&.info cmd
@@ -911,7 +937,7 @@ module Squared
               log&.warn "ENV discarded: #{var}" if var
               task_invoke(cmd, exception: exception, warning: warning?)
             else
-              print_item(format_banner(hint ? "#{cmd} (#{hint})" : cmd, banner: banner), series: series) if sync
+              print_item(format_banner(cmd, banner: banner, hint: hint), series: series) if sync
               if var != false && (pre = runenv)
                 case pre
                 when Hash
@@ -934,12 +960,6 @@ module Squared
           end
         end
 
-        def scope(*args, **kwargs, &blk)
-          namespace name do
-            task(*args, **kwargs, &blk)
-          end
-        end
-
         def variable_set(key, *args, **kwargs, &blk)
           if block_given?
             if blocks.include?(key)
@@ -949,14 +969,7 @@ module Squared
             args = block_args args, &blk
           end
           if variables.include?(key) || blocks.include?(key)
-            val = case args.size
-                  when 0
-                    nil
-                  when 1
-                    args.first
-                  else
-                    args
-                  end
+            val = args.size > 1 ? args : args.first
             case key
             when :index
               index_set val
@@ -981,13 +994,12 @@ module Squared
             when :env
               run_set(output[0], *args, **kwargs)
             when :dependfile
-              @dependindex = nil
-              @dependfile = val.nil? ? nil : basepath(*args)
+              @dependfile = basepath(*args)
             else
               instance_variable_set(:"@#{key}", val)
             end
           else
-            log&.warn "variable_set: @#{key} (private)"
+            log&.warn "variable_set: @#{key}".subhint('private')
           end
           self
         end
@@ -1010,6 +1022,10 @@ module Squared
           @ref.include?(val)
         end
 
+        def exist?(*args)
+          basepath(*args).exist?
+        end
+
         def build?
           !!@output[0] || script? || series?(@run)
         end
@@ -1083,14 +1099,18 @@ module Squared
           @dependindex ? @dependindex.succ : 0
         end
 
+        def dependname
+          @dependname ||= dependfile&.basename.to_s
+        end
+
         def log
           return @log unless @log.is_a?(Array)
 
-          @log = Logger.new(enabled? ? @log.first : nil, **@log.last)
+          @log = Logger.new((@log.first if enabled?), **@log.last)
         end
 
-        def allref(&blk)
-          @ref.reverse_each(&blk)
+        def allref
+          @ref.reverse_each
         end
 
         def basepath(*args)
@@ -1104,7 +1124,7 @@ module Squared
           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
+            break if (ascend && dir.join(ascend).exist?) || workspace.root == dir || parent&.path == dir
           end
           ret
         end
@@ -1113,6 +1133,12 @@ module Squared
           workspace.task_localname(name)
         end
 
+        def scriptname(from: :run)
+          return unless (name = @output[1]) && respond_to?(:compose)
+
+          as_get name, from
+        end
+
         def inspect
           "#<#{self.class}: #{name} => #{self}>"
         end
@@ -1131,12 +1157,21 @@ module Squared
           log_console(*args, pipe: kwargs[:pipe] || pipe)
         end
 
-        def run_s(*cmd, env: nil, sync: true, from: nil, banner: verbose != false, **kwargs)
+        def run_s(*cmd, sync: true, banner: verbosetype > 0, from: nil, **kwargs)
+          cmd.flatten!
+          case cmd.last
+          when Hash, TrueClass, FalseClass
+            var = cmd.pop
+          end
           on :first, from
           begin
-            cmd.flatten.each { |val| run(val, env, sync: sync, banner: banner, **kwargs) }
+            cmd.each do |val|
+              print_run val, banner
+              run(val, var, sync: sync, banner: banner, **kwargs)
+            end
           rescue StandardError => e
-            on_error(e, from, exception: kwargs.fetch(:exception, exception))
+            ret = on :error, from, e
+            raise unless ret == true
           end
           on :last, from
         end
@@ -1150,7 +1185,12 @@ module Squared
           when Proc
             instance_eval(&obj)
           when Method
-            obj.call
+            args = if (n = obj.arity.abs) > 0
+                     Array.new(n).tap { |data| data[0] = self }
+                   else
+                     []
+                   end
+            obj.call(*args)
           else
             if series?(obj)
               obj.each(&:call)
@@ -1166,7 +1206,6 @@ module Squared
                          single: false, last: false, context: nil)
           tag = ->(proj) { "#{proj.name}#{SEM_VER.match?(proj.version) ? "@#{proj.version}" : ''}" }
           script = ->(proj) { workspace.script_get(:graph, group: proj.group, ref: proj.allref)&.fetch(:graph, nil) }
-          check = ->(deps) { deps.reject { |val| done.include?(val) } }
           dedupe = lambda do |name|
             next [] unless (ret = data[name])
 
@@ -1177,15 +1216,12 @@ module Squared
             end
             ret
           end
-          start = target.name
           if depth == 0
-            items = check.call(dedupe.call(start))
+            items = dedupe.call(target.name) - done
             single = items.size == 1
           else
-            items = check.call(data[start])
+            items = data[target.name] - done
           end
-          return done if items.empty?
-
           if out
             a, b, c, d, e = ARG[:GRAPH]
             f = tag.call(target)
@@ -1199,21 +1235,21 @@ module Squared
                        "#{last ? d : c}#{b * 3}#{e} #{f}"
                      end
                    else
-                     "#{single ? ' ' : a}#{'   ' * (depth - 1)}#{last ? d : c}#{b * 3}#{items.empty? ? b : e} #{f}"
+                     "#{single ? ' ' : a}#{'   ' * depth.pred}#{last ? d : c}#{b * 3}#{items.empty? ? b : e} #{f}"
                    end
           end
           items.each_with_index do |proj, i|
             next if done.include?(proj)
 
-            t = dedupe.call(proj.name)
+            t = dedupe.call(name = proj.name)
             j = if out
-                  if i == items.size - 1 || check.call(post = items[(i + 1)..-1]).empty?
+                  if i == items.size.pred || (post = items[i.succ..-1] - done).empty?
                     true
                   elsif !t.empty? && depth > 0
-                    post.reject { |pr| t.include?(pr) }.empty?
+                    (post - t).empty?
                   end
                 end
-            unless start == proj.name || (none = check.call(t).empty?)
+            unless target.name == name || (none = (t - done).empty?)
               graph_branch(proj, data, tasks, out, sync: sync, pass: pass, done: done, depth: depth.succ,
                                                    single: single, last: j == true, context: target)
             end
@@ -1221,28 +1257,28 @@ module Squared
               (tasks || (subtasks = script.call(proj)) || (dev? ? %w[build copy] : %w[depend build])).each do |meth|
                 next if pass.include?(meth)
 
-                if workspace.task_defined?(cmd = task_join(proj.name, meth))
-                  if ENV.key?(key = "BANNER_#{proj.name.upcase}")
+                if workspace.task_defined?(cmd = task_join(name, meth))
+                  if ENV.key?(key = "BANNER_#{name.upcase}")
                     key = nil
                   else
                     ENV[key] = '0'
                   end
                   run(cmd, sync: false, banner: false)
                   ENV.delete(key) if key
-                elsif proj.has?(meth, tasks || subtasks ? nil : workspace.baseref)
+                elsif proj.has?(meth, (workspace.baseref unless tasks || subtasks))
                   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} #{tag.call(proj)}"
+                       "#{i == items.size.pred ? d : c}#{b * 4} #{tag.call(proj)}"
                      else
                        s = ''.dup
                        k = 0
                        final = data.keys.last
                        while k < depth
-                         indent = k > 0 ? ((last && !j) || (j && k == depth - 1) || single) : j && last && depth == 1
+                         indent = k > 0 ? ((last && !j) || (j && k == depth.pred) || single) : j && last && depth == 1
                          s += "#{indent || (last && data[final].last == context) ? ' ' : a}   "
                          k += 1
                        end
@@ -1260,22 +1296,19 @@ module Squared
             next if pass.include?(val)
 
             if (obj = workspace.find(name: val))
-              next unless obj.enabled?
-
-              items = [obj]
+              obj.enabled? ? [obj] : []
             else
-              items = workspace.find(group: val, ref: val.to_sym)
-            end
-            items.each do |proj|
+              workspace.find(group: val, ref: val.to_sym)
+            end.each do |proj|
               next if pass.include?(name = proj.name)
 
               if proj.graph? && !data.key?(name) && !root.include?(name)
                 graph_collect(proj, data: data, pass: pass, root: root + [name, target.name])
               end
-              next if (objs = data.fetch(name, [])).include?(target)
-
-              deps << proj
-              deps.concat(objs)
+              unless (objs = data.fetch(name, [])).include?(target)
+                deps << proj
+                deps.concat(objs)
+              end
             end
           end
           deps.uniq!
@@ -1301,44 +1334,96 @@ module Squared
         end
 
         def env(key, default = nil, suffix: nil, equals: nil, ignore: nil, strict: false)
-          a = "#{key}_#{@envname}"
+          name = "#{key}_#{@envname}"
           ret = if suffix
-                  ENV.fetch("#{a}_#{suffix}", '')
+                  ENV.fetch("#{name}_#{suffix}", '')
                 elsif strict
-                  ENV[a].to_s
+                  ENV[name].to_s
                 else
                   ignore = ['0'].freeze if ignore.nil?
-                  ENV[a] || ENV.fetch(key, '')
+                  ENV[name] || ENV.fetch(key, '')
                 end
-          return ret == equals.to_s unless equals.nil?
-
-          ret.empty? || (ignore && Array(ignore).any? { |val| ret == val.to_s }) ? default : ret
+          if !equals.nil?
+            ret = ret == equals.to_s
+          elsif ret.empty? || (ignore && Array(ignore).any? { |val| ret == val.to_s })
+            ret = default
+          end
+          block_given? && !ret.nil? ? yield(ret) : ret
         end
 
         def session(*cmd, prefix: cmd.first, main: true, path: true, options: true)
-          prefix = stripext prefix.to_s
+          prefix = prefix.to_s.stripext
           if path && (val = shell_bin(prefix))
             cmd[0] = shell_quote(val, force: false)
           end
           ret = JoinSet.new(cmd.flatten(1))
-          if options && (val = env("#{prefix.upcase}_OPTIONS"))
-            split_escape(val).each { |opt| ret.last(fill_option(opt), /\A(--?[^\[\]=\s-][^\[\]=\s]*)[=\s].+\z/m) }
+          if options
+            env("#{prefix.upcase}_OPTIONS") do |val|
+              if val.start_with('-')
+                ret.concat(shell_parse(val))
+              else
+                split_escape(val) { |opt| ret.last(fill_option(opt), /\A(--?[^= ]+)[= ].+\z/m) }
+              end
+            end
           end
           main ? @session = ret : ret
         end
 
-        def session_delete(*args, target: @session)
-          OptionPartition.delete(target, *args)
-        end
-
         def session_output(*cmd, **kwargs)
           session(*cmd, main: false, options: false, **kwargs)
         end
 
+        def session_get(val, pass: nil)
+          base = OPTIONS[ref]
+          args = []
+          kwargs = {}
+          with = []
+          [:_, name.to_sym].each do |key|
+            next unless base.key?(key) && (a, b, c = base[key][val])
+
+            args.concat(a)
+            append_keys(kwargs, b, :opts)
+            with.concat(c)
+          end
+          OptionPartition.uniq!(args, pass) if pass
+          [args, kwargs, with]
+        end
+
+        def session_apply(val, args: nil, kwargs: nil, pass: [], keys: [:opts], exclude: [])
+          a = []
+          b = {}
+          Array(val).each do |c|
+            d, e, f = session_get c
+            unless (f -= exclude).empty?
+              h = []
+              i = {}
+              session_apply(f.map!(&:to_s), args: h, kwargs: i, pass: pass, keys: keys, exclude: exclude.concat(f))
+              a.concat(h)
+              append_keys(b, i, *keys)
+            end
+            a.concat(d)
+            append_keys(b, e, *keys)
+          end
+          if args
+            args.unshift(*a)
+            OptionPartition.uniq!(args, pass) if pass
+          end
+          kwargs&.update(b) { |_, val| val }
+          nil
+        end
+
+        def session_opts(val, args: nil, kwargs: nil, pass: nil, keys: [:opts])
+          opts = kwargs.delete(:opts) || []
+          return opts unless val
+
+          session_apply(val, args: args, kwargs: kwargs, pass: pass, keys: keys)
+          kwargs.fetch(:opts, []).concat(opts)
+        end
+
         def session_done(cmd)
-          return cmd unless cmd.respond_to?(:done)
+          return cmd.to_s unless cmd.respond_to?(:done)
 
-          raise_error('no args added', hint: cmd.first) unless cmd.size > 1
+          raise_error 'no command added', hint: cmd.first unless cmd.size > 1
           @session = nil if cmd == @session
           cmd.done
         end
@@ -1353,33 +1438,40 @@ module Squared
           return unless prefix
 
           args.each do |val|
-            next unless (ret = env(env_key(stripext(prefix), val), **kwargs))
+            next unless (ret = env(env_key(prefix.to_s.stripext, val), **kwargs))
 
             return block_given? ? yield(ret) : ret
           end
           nil
         end
 
-        def option_clear(opts, target: @session, **kwargs)
+        def option_clear(opts, empty = true, target: @session, **kwargs)
           return unless target
 
           OptionPartition.clear(target, opts, styles: theme[:inline], **kwargs)
+          opts.clear if empty
+          nil
         end
 
-        def print_success(*)
+        def print_success
           puts 'Success'
         end
 
         def print_error(*args, loglevel: Logger::WARN, **kwargs)
-          return unless warning?
+          warn log_message(loglevel, *args, **kwargs) if warning?
+        end
 
-          warn log_message(loglevel, *args, **kwargs)
+        def print_run(cmd, banner = true, verbose: nil, **)
+          return if banner || !stdout? || verbose == false
+
+          puts "\n> #{cmd}"
+          printsucc
         end
 
         def print_item(*val, series: true)
           puts unless printfirst?
           printsucc if series
-          puts val unless val.empty? || (val.size == 1 && val.first.nil?)
+          puts val unless val.empty? || (val.size == 1 && !val.first)
         end
 
         def print_banner(*lines, client: false, styles: theme[:banner], border: borderstyle, **)
@@ -1408,14 +1500,15 @@ module Squared
 
         def print_footer(*lines, sub: nil, reverse: false, right: false, border: borderstyle, **)
           n = line_width lines
+          sub = as_a sub
           lines.map! do |val|
             s = right ? val.rjust(n) : val.ljust(n)
-            sub&.each { |h| s = sub_style(s, **h) }
+            sub.each { |h| s = sub_style(s, **h) }
             s
           end
-          ret = [sub_style(ARG[:BORDER][1] * n, styles: border)].concat(lines)
-          ret.reverse! if reverse
-          ret.join("\n")
+          [sub_style(ARG[:BORDER][1] * n, styles: border)].concat(lines)
+                                                          .tap { |ret| ret.reverse! if reverse }
+                                                          .join("\n")
         end
 
         def print_status(*args, from: nil, **kwargs)
@@ -1424,15 +1517,15 @@ module Squared
           case from
           when :outdated
             out = print_footer("major #{args[0]} / minor #{args[1]} / patch #{args[2]}", right: true).split("\n")
-            out[1] = sub_style(out[1], pat: /^( +major )(\d+)(.+)$/, styles: theme[:major], index: 2)
-            out[1] = sub_style(out[1], pat: /^(.+)(minor )(\d+)(.+)$/, styles: theme[:active], index: 3)
+            out[1] = sub_style(out[1], **opt_style(theme[:major], /^( +major )(\d+)(.+)$/, 2))
+            out[1] = sub_style(out[1], **opt_style(theme[:active], /^(.+)(minor )(\d+)(.+)$/, 3))
+            out[1] = sub_style(out[1], **opt_style(theme[:current], /^(.+)(patch )(\d+)(.+)$/, 3)) if theme[:current]
             puts out
           when :completed
-            if verbose && kwargs[:start]
-              msg = sub_style('completed', styles: theme[:active])
-              puts log_message(Logger::INFO, *args, msg, subject: kwargs[:subject],
-                                                         hint: time_format(time_epoch - kwargs[:start]))
-            end
+            return unless verbose && kwargs[:start]
+
+            puts log_message(Logger::INFO, *args, sub_style('completed', styles: theme[:active]),
+                             subject: kwargs[:subject], hint: time_format(time_epoch - kwargs[:start]))
           end
         end
 
@@ -1442,7 +1535,7 @@ module Squared
           workspace.format_desc([@desc, action, flag].compact, opts, **kwargs)
         end
 
-        def format_banner(cmd, banner: true)
+        def format_banner(cmd, banner: true, hint: nil, strip: nil)
           return unless banner && banner?
 
           if (data = workspace.banner_get(*@ref, group: group))
@@ -1456,11 +1549,14 @@ module Squared
             out = []
             if data.command
               if cmd =~ /\A(?:"((?:[^"]|(?<=\\)")+)"|'((?:[^']|(?<=\\)')+)'|(\S+))( |\z)/
-                path = $3 || $2 || $1
-                name = stripext path
-                cmd = cmd.sub(path, data.command == 0 ? name : name.upcase)
+                arg = $3 || $2 || $1
+                cmd = cmd.sub(arg, data.command == 0 ? arg.stripext : arg.stripext.upcase)
               end
-              out << cmd
+              if strip || (strip.nil? && data.order.include?(:path))
+                cmd = cmd.gsub(/(?:#{s = Regexp.escape(File.join(path, ''))}?(?=["'])|#{s})/, '')
+                         .gsub(/(?: -[^ ])? (?:""|'')/, '')
+              end
+              out << cmd.subhint(hint)
             end
             data.order.each do |val|
               if val.is_a?(Array)
@@ -1488,7 +1584,7 @@ module Squared
           end
         end
 
-        def format_list(items, cmd, type, grep: [], from: nil, each: nil)
+        def format_list(items, cmd, type, grep: [], from: nil)
           reg = grep.map { |val| Regexp.new(val) }
           out = []
           unless items.empty?
@@ -1496,29 +1592,29 @@ module Squared
             items.each_with_index do |val, i|
               next unless matchany?(val.first, reg)
 
-              out << ('%*d. %s' % [pad, i.succ, each ? each.call(val) : val.first])
+              out << ('%*d. %s' % [pad, i.succ, block_given? ? yield(val) : val.first])
             end
           end
           sub = [headerstyle]
-          if out.empty?
-            out = ["No #{type} were found:", '']
-            unless grep.empty?
-              i = 0
-              out.concat(grep.map { |s| "#{i += 1}. #{s}" })
-              out << ''
-            end
-            if from
-              out << (from = from.to_s)
-              pat = /\A(#{Regexp.escape(from)})(.*)\z/
-            end
-          else
-            pat = /\A(\s*\d+\.)(.+)\z/
-            unless grep.empty?
-              footer = "#{out.size} found "
-              sub << { pat: /\A(\d+)( .+)\z/, styles: theme[:inline] }
-            end
-          end
-          sub << { pat: pat, styles: theme[:active] } if pat
+          pat = if out.empty?
+                  out = ["No #{type} were found:", '']
+                  unless grep.empty?
+                    i = 0
+                    out.concat(grep.map { |s| "#{i += 1}. #{s}" })
+                    out << ''
+                  end
+                  if from
+                    out << (from = from.to_s)
+                    /\A(#{Regexp.escape(from)})(.*)\z/
+                  end
+                else
+                  unless grep.empty?
+                    footer = "#{out.size} found "
+                    sub << opt_style(theme[:inline], /\A(\d+)( .+)\z/)
+                  end
+                  /\A(\s*\d+\.)(.+)\z/
+                end
+          sub << opt_style(theme[:active], pat) if pat
           emphasize(out, title: task_join(name, cmd), border: borderstyle, sub: sub, footer: footer, right: true)
         end
 
@@ -1526,14 +1622,13 @@ module Squared
           "#{msg}#{!always && (!obj || obj == 0 || obj.to_s.empty?) ? '' : message(hint: message(title, obj.to_s))}"
         end
 
-        def append_repeat(flag, opts, target: @session, **kwargs)
-          opts.each { |val| target << shell_option(flag, val, **kwargs) }
+        def append_repeat(flag, opts, target: @session)
+          opts.each { |val| target << shell_option(flag, val) }
         end
 
         def append_hash(data, target: @session || [], build: false)
           if build && (type = env('BUILD', suffix: 'TYPE') || ENV['BUILD_TYPE'])
-            type = "__#{type}__"
-            if (extra = data[type] || data[type.to_sym]).is_a?(Hash)
+            if (extra = data[type = "__#{type}__"] || data[type.to_sym]).is_a?(Hash)
               data = data.merge(extra)
             else
               extra = nil
@@ -1553,33 +1648,25 @@ module Squared
               target << basic_option(key, val)
             when FalseClass
               target << shell_option(key).sub(/^--(?!no-)/, '--no-')
-            when Pathname
-              target << shell_option(key, val, escape: false)
             else
-              target << shell_option(key, val.is_a?(String) ? val : nil)
+              target << shell_option(key, (val if val.is_a?(String)))
             end
           end
           target
         end
 
         def append_any(val, target: @session, build: false, delim: false)
-          return unless val
-
           if delim && !target.include?('--')
             target << '--'
           else
             delim = false
           end
-          val = shell_split(val) if val.is_a?(String)
+          val = shell_split val if val.is_a?(String)
           case val
           when Hash
             append_hash(val, target: target, build: build)
           when Enumerable
-            if target.is_a?(Array)
-              target.concat(val.to_a)
-            else
-              target.merge(val.to_a)
-            end
+            merge_list target, val
           else
             target.delete('--') if delim
             nil
@@ -1600,7 +1687,7 @@ module Squared
             next unless (val = option(opt, **kwargs))
 
             return target << if flag
-                               shell_option(opt, equals ? val : nil, quote: quote, escape: escape, force: force)
+                               shell_option(opt, (val if equals), quote: quote, escape: escape, force: force)
                              else
                                shell_quote val
                              end
@@ -1612,25 +1699,44 @@ module Squared
                           **kwargs)
           return if list.empty?
 
-          kwargs[:ignore] = false if no && !kwargs.key?(:ignore)
-          ret = []
-          list.flatten.each do |flag|
-            next unless (val = option(flag, target: target, **kwargs))
+          [].tap do |ret|
+            list.flatten.each do |flag|
+              next unless (val = option(flag, target: target, **kwargs))
 
-            if no && val == '0'
-              flag = "no-#{flag}"
-              val = nil
+              if val == '0' && no
+                flag = "no-#{flag}"
+                val = nil
+              end
+              ret << shell_option(flag, (val if equals), escape: escape, quote: quote, force: force)
             end
-            ret << shell_option(flag, equals ? val : nil, escape: escape, quote: quote, force: force)
+            next if ret.empty?
+
+            merge_list target, ret
           end
-          ret.each { |val| target << val } unless ret.empty?
-          ret
         end
 
         def append_nocolor(target: @session)
           target << '--no-color' if !ARG[:COLOR] || stdin? || option('color', target: target, equals: '0')
         end
 
+        def append_keys(base, data, *keys)
+          out = {}
+          keys.each do |key|
+            next unless data.key?(key)
+
+            out[key] = case (val = data[key])
+                       when Array
+                         base.fetch(key, []) + val
+                       when Hash
+                         base.fetch(key, {}).update(val)
+                       else
+                         val
+                       end
+          end
+          base.update(data)
+              .update(out)
+        end
+
         def merge_opts(base, data)
           case data
           when String
@@ -1671,27 +1777,31 @@ module Squared
           end
         end
 
+        def merge_list(base, data)
+          data = Array(data)
+          case base
+          when Array
+            base.concat(data)
+          when Set
+            base.merge(data)
+          else
+            Array(base).concat(data)
+          end
+        end
+
         def collect_hash(data, pass: [])
           ret = []
           data.each { |key, val| ret.concat(val) unless pass.include?(key) }
           ret
         end
 
-        def replace_bin(val)
-          a, b = val.split(' ', 2)
-          return val if val.start_with?(/["']/) || a.include?(File::Separator)
-
-          [shell_bin(a), b].compact.join(' ')
-        end
-
         def parse_json(val, kind: Hash, hint: nil)
           ret = JSON.parse(val)
-          raise_error("invalid JSON #{kind.name}", val, hint: hint) if kind && !ret.is_a?(kind)
+          raise_error 'invalid JSON'.subhint(kind.name), val, hint: hint if kind && !ret.is_a?(kind)
+          ret
         rescue StandardError => e
           log&.warn e
           print_error(e, subject: name)
-        else
-          ret
         end
 
         def param_guard(action, flag, args:, key: nil, pat: nil, values: nil)
@@ -1703,12 +1813,16 @@ module Squared
             raise_error(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
           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 confirm_outdated(pkg, ver, rev, cur = nil, lock: false, col1: 0)
+        def confirm_basic(msg, target, default = 'Y', style: :inline, **kwargs)
+          confirm("#{msg} [#{sub_style(target.to_s, styles: theme[style])}]", default, **kwargs)
+        end
+
+        def confirm_outdated(pkg, ver, rev, cur = nil, lock: false, col1: 0, **kwargs)
           a = sub_style(case rev
                         when 1
                           'MAJOR'
@@ -1720,16 +1834,17 @@ module Squared
           b = sub_style(pkg.ljust(col1), styles: theme[:inline])
           c = lock ? sub_style((cur || 'locked').rjust(7), styles: color(:red)) : cur&.rjust(7)
           d = rev == 1 || lock ? 'N' : 'Y'
-          confirm "#{a}: #{b}#{c} #{sub_style(ver.rjust(col1 > 0 ? 10 : 0), styles: theme[:inline])}   ", d
+          confirm("#{a}: #{b}#{c} #{sub_style(ver.rjust(col1 > 0 ? 10 : 0), styles: theme[:inline])}  ", d, **kwargs)
         end
 
         def choice_index(msg, list, values: nil, accept: nil, series: false, trim: nil, column: nil, multiple: false,
                          force: true, **kwargs)
-          puts if !series && !printfirst?
-          msg = "#{msg} (optional)" unless force
-          unless (ret = choice(msg, list, multiple: multiple, force: force, **kwargs)) && !ret.empty?
+          puts unless series || printfirst?
+          ret = choice(msg, list, multiple: multiple, force: force, **kwargs).tap do |val|
+            next unless val.to_s.empty?
+
             exit 1 if force
-            return
+            return nil
           end
           ret = multiple ? ret.map! { |val| val.sub(trim, '') } : ret.sub(trim, '') if trim
           if column
@@ -1743,7 +1858,7 @@ module Squared
             ret = Array(ret) if accept.any? { |val| val[1] == true }
             loop do
               item = accept.first
-              c = confirm("#{item[0]}#{hint ? " [#{hint}]" : ''}", item[2] ? 'Y' : 'N', timeout: 60)
+              c = confirm("#{item[0]}#{hint ? " [#{hint}]" : ''}", item[2] ? 'Y' : 'N')
               if item[1] == true
                 ret << c
               elsif !c
@@ -1764,25 +1879,29 @@ module Squared
                 force = false
               end
               val = readline(val, force: force)
-              ret << (val.empty? ? nil : val)
+              ret << (val unless val.empty?)
             end
           end
           printsucc unless series
           ret
         end
 
+        def accept_b(val, yes = false)
+          [val, true, yes]
+        end
+
+        def accept_y(val, bool = false)
+          [val, bool, true]
+        end
+
         def command_args(args, min: 0, force: false, **kwargs)
           return if args.size > min || option('i', 'interactive', **kwargs, equals: '0')
 
           readline('Enter arguments', force: force)
         end
 
-        def block_args(val = nil, &blk)
-          if (ret = instance_eval(&blk)).nil?
-            val
-          else
-            Array(ret)
-          end
+        def block_args(fallback = nil, &blk)
+          (ret = instance_eval(&blk)).nil? ? fallback : Array(ret)
         end
 
         def runenv
@@ -1792,7 +1911,7 @@ module Squared
         def command(*args)
           return args.join(' && ') unless workspace.powershell?
 
-          "#{shell_bin('powershell.exe')} -Command \"& {#{args.join(' ; ')}}\""
+          "powershell.exe -Command #{shell_quote("& {#{args.join(' ; ')}}", option: false, double: true)}"
         end
 
         def relativepath(*list, all: false)
@@ -1815,12 +1934,10 @@ module Squared
 
         def matchmap(list, prefix = nil)
           list.map do |val|
-            if val.is_a?(Regexp)
-              val
-            else
-              val = ".*#{val}" if prefix && !val.sub!(/\A(\^|\\A)/, '')
-              Regexp.new("#{prefix}#{val == '*' ? '.+' : val}")
-            end
+            next val if val.is_a?(Regexp)
+
+            val = ".*#{val}" if prefix && !val.sub!(/\A(\^|\\A)/, '')
+            Regexp.new("#{prefix}#{val == '*' ? '.+' : val}")
           end
         end
 
@@ -1837,7 +1954,8 @@ module Squared
         end
 
         def semscan(val, fill: true)
-          val.scan(SEM_VER).first.yield_self { |data| fill ? semver(data) : data }
+          ret = val.scan(SEM_VER).first
+          fill ? semver(ret) : ret
         end
 
         def semcmp(val, other)
@@ -1853,14 +1971,38 @@ module Squared
             end
             [c[0], c[2], c[4] || '0', d]
           end
-          a.each_with_index do |c, index|
-            next if c == (d = b[index])
+          a.each_with_index do |c, i|
+            next if c == (d = b[i])
 
             return c.to_i < d.to_i ? 1 : -1
           end
           0
         end
 
+        def sembump(val, flag = :patch, join: true)
+          ret = semscan(val, fill: false)
+          case flag
+          when :major
+            ret[2] = if ret[0] != '0' || ret[2].nil?
+                       ret[0] = ret[0].succ
+                       '0'
+                     else
+                       ret[2].succ
+                     end
+            ret[4] = '0'
+          when :minor
+            if ret[0] == '0'
+              ret[4] &&= ret[4].succ
+            else
+              ret[2] = ret[2].succ
+              ret[4] &&= '0'
+            end
+          when :patch
+            ret[4] &&= ret[4].succ
+          end
+          join ? ret.join : ret
+        end
+
         def semgte?(val, other)
           semcmp(val, other) != 1
         end
@@ -1870,7 +2012,7 @@ module Squared
         end
 
         def indexerror(val, list = nil)
-          raise_error("requested index #{val}", hint: list && "of #{list.size}")
+          raise_error IndexError, "requested index #{val}", hint: list && "of #{list.size}"
         end
 
         def indexchar
@@ -1889,10 +2031,6 @@ module Squared
           val.compact.flat_map { |s| color(s) }
         end
 
-        def epochtime
-          Time.now.strftime('%s%L').to_i
-        end
-
         def verbosetype
           case verbose
           when TrueClass
@@ -1924,7 +2062,7 @@ module Squared
           end
         end
 
-        def on_error(err, from, exception: self.exception, pass: false, dryrun: false)
+        def on_error(err, from, pass: false, exception: self.exception, dryrun: false)
           log&.error err
           unless dryrun
             ret = on :error, from, err
@@ -1933,26 +2071,24 @@ module Squared
           print_error(err, pass: pass) unless ret
         end
 
-        def pwd_set(pass: false, dryrun: false, from: nil)
-          return yield if (path.to_s == Dir.pwd || pass == true) && (workspace.mri? || !workspace.windows?)
-
+        def pwd_set(pass: false, exception: self.exception, dryrun: false, from: nil)
           pwd = Dir.pwd
-          Dir.chdir(path)
-          yield
+          return yield if (path.to_s == pwd || pass == true) && (workspace.mri? || !workspace.windows?)
+
+          Dir.chdir path
+          yield.tap { Dir.chdir pwd }
         rescue StandardError => e
-          on_error(e, from, dryrun: dryrun)
-        ensure
-          Dir.chdir(pwd) if pwd
+          on_error(e, from, exception: exception, dryrun: dryrun)
         end
 
-        def run_set(cmd, val = nil, opts: nil, **)
+        def run_set(cmd, val = nil, opts: nil, global: false, **)
           noopt = @output[1] == false && !@output[0].nil?
           noenv = @output[2] == false
           parse = lambda do |data|
             ret = []
             if data[:command]
               ret[0] = data[:command]
-              ret[1] = data[:opts] unless noopt
+              ret[1] = data[:opts] unless diso
               ret[3] = data[:args]
             elsif data[:script]
               ret[1] = data[:script]
@@ -1961,12 +2097,13 @@ module Squared
             else
               ret[0] = false
             end
-            ret[2] = data[:env] unless noenv
+            ret[2] = data[:env] unless dise
             ret
           end
+          self.global = global
           case cmd
           when Array
-            @output = if cmd.all?(Hash)
+            @output = if cmd.all? { |data| data.is_a?(Hash) }
                         noopt = false
                         noenv = false
                         cmd.map { |data| parse.call(data) }
@@ -1995,11 +2132,12 @@ module Squared
           end
         end
 
-        def script_set(cmd, prod: nil, args: nil, **)
+        def script_set(cmd, prod: nil, args: nil, global: false, **)
           return if @output[1] == false && @output[0].nil?
 
+          self.global = global
           @output[0] = nil
-          @output[1] = if @global && cmd.is_a?(Array)
+          @output[1] = if self.global && cmd.is_a?(Array)
                          cmd[prod == true ? 1 : 0]
                        else
                          cmd
@@ -2044,7 +2182,7 @@ module Squared
 
         def asdf_set(val)
           @asdf = if @@asdf && val
-                    dir = @@asdf[0].join('installs', val)
+                    dir = @@asdf.path.join('installs', val)
                     [val, dir] if dir.exist? && !dir.empty?
                   end
         end
@@ -2060,9 +2198,12 @@ module Squared
         end
 
         def dependfile_set(list)
-          @dependindex = list.index { |file| basepath(file).exist? }.tap do |index|
-            @dependfile = basepath(list[index || 0])
-          end
+          @dependindex = if @dependname
+                           @dependfile = basepath @dependname
+                           list.index(@dependname)
+                         else
+                           list.index { |file| exist?(file) }.tap { |i: 0| @dependfile = basepath(list[i]) }
+                         end
         end
 
         def as_get(val, from)
@@ -2104,12 +2245,10 @@ module Squared
         end
 
         def checkdir?(val)
-          if val.directory? && !val.empty?
-            true
-          else
-            log&.warn "directory \"#{val}\" (#{val.directory? ? 'empty' : 'not found'})"
-            false
-          end
+          return true if val.directory? && !val.empty?
+
+          log&.warn "directory \"#{val}\"".subhint(val.directory? ? 'empty' : 'missing')
+          false
         end
 
         def semmajor?(cur, want)
@@ -2122,7 +2261,7 @@ module Squared
 
         def runnable?(val)
           case val
-          when String, Enumerable, Proc, Method, Struct
+          when String, Enumerable, Proc, Method
             true
           else
             false
@@ -2149,14 +2288,24 @@ module Squared
           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?
-          return false if workspace.series.chain?(val = task_join(name, action))
-          return true if task_invoked?(val) && (!task_invoked?(ac) || !workspace.task_defined?(ac, 'sync'))
+          return false if workspace.series.chain?(key = task_join(name, action))
+          return true if task_invoked?(key) && (!task_invoked?(ac) || !workspace.task_defined?(ac, 'sync'))
 
-          workspace.series.name_get(action).yield_self { |name| name != action && invoked_sync?(name) }
+          ret = workspace.series.name_get(action)
+          ret != action && invoked_sync?(ret)
         end
 
-        def success?(ret, display = true)
-          ret == true && display && stdout? && banner?
+        def success?(run, *cond)
+          case run
+          when TrueClass
+            true
+          when FalseClass
+            false
+          else
+            $?.success?
+          end.tap do |ret|
+            print_success if ret && stdout? && banner? && cond.none? { |val| val == false }
+          end
         end
 
         def banner?
@@ -2183,10 +2332,16 @@ module Squared
           workspace.warning
         end
 
-        def has_value?(data, other)
-          return false unless data.is_a?(Enumerable)
-
-          other.is_a?(Enumerable) ? other.any? { |obj,| data.include?(obj) } : data.include?(other)
+        def has_value?(target, *args)
+          args = args.first if args.size == 1 && args.first.is_a?(Enumerable)
+          case target
+          when Hash
+            args.is_a?(Enumerable) ? args.any? { |obj| target.value?(obj) } : target.value?(args)
+          when Enumerable
+            args.is_a?(Enumerable) ? args.any? { |obj| target.include?(obj) } : target.include?(args)
+          else
+            false
+          end
         end
 
         def variables
@@ -2197,28 +2352,16 @@ module Squared
           BLK_SET
         end
 
-        def hashobj
-          Workspace::Support.hashobj
-        end
-
-        def hashlist
-          Workspace::Support.hashlist
-        end
-
-        def hashdup
-          Workspace::Support.hashdup
-        end
-
         def borderstyle
           workspace.banner_get(*@ref, group: group)&.border || theme[:border]
         end
 
         def headerstyle
-          { pat: /^(\S+)(\s+)$/, styles: theme[:header] }
+          opt_style theme[:header], /^(\S+)(\s+)$/
         end
 
         def scriptargs
-          { target: script? ? @output[1] : @output[0], ref: ref, group: group, global: @global }
+          { target: script? ? @output[1] : @output[0], script: script?, ref: ref, group: group, global: @global }
         end
       end