squared 0.4.41 → 0.5.0

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

@@ -2,6 +2,7 @@
 
 require 'json'
 require 'date'
+require 'time'
 require 'logger'
 
 module Squared
@@ -18,10 +19,10 @@ module Squared
         include Rake::DSL
 
         VAR_SET = %i[parent global script index envname desc dependfile dependindex theme archive env dev prod graph
-                     pass only exclude].freeze
+                     pass exclude].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
+        SEM_VER = /\b(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?\b/.freeze
+        URI_SCHEME = %r{^([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
 
@@ -72,9 +73,8 @@ module Squared
           'unpack' => %i[zip tar gem ext].freeze
         })
 
-        attr_reader :name, :workspace, :path, :theme, :group, :parent, :dependfile,
-                    :exception, :pipe, :verbose
-        attr_accessor :global, :project
+        attr_reader :name, :project, :workspace, :path, :theme, :exception, :pipe, :verbose,
+                    :group, :parent, :dependfile
 
         def initialize(workspace, path, name, *, group: nil, first: {}, last: {}, error: {}, common: ARG[:COMMON],
                        **kwargs)
@@ -83,36 +83,38 @@ module Squared
           @name = name.to_s.freeze
           @project = @path.basename.to_s.freeze
           @group = group&.to_s.freeze
-          @envname = env_key(@name).freeze
           @depend = kwargs[:depend]
           @doc = kwargs[:doc]
           @lint = kwargs[:lint]
           @test = kwargs[:test]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
+          @version = kwargs[:version]
           @release = kwargs[:release]
-          self.version = kwargs[:version]
-          self.exception = env_bool(kwargs[:exception], workspace.exception, strict: true)
-          self.pipe = env_pipe(kwargs[:pipe], workspace.pipe, strict: true)
-          self.verbose = case (val = env('VERBOSE', kwargs[:verbose]))
-                         when String
-                           env_bool(val, workspace.verbose, strict: true, index: true)
-                         else
-                           val.nil? ? workspace.verbose : val
-                         end
           @output = []
           @ref = []
           @children = []
-          @events = hashobj.update({ first: first, last: last, error: error })
-          @as = hashobj
+          @events = {
+            first: first,
+            last: last,
+            error: error
+          }
+          @envname = @name.gsub(/[^\w]+/, '_').upcase.freeze
           @desc = (@name.include?(':') ? @name.split(':').join(ARG[:SPACE]) : @name).freeze
           @parent = nil
           @global = false
+          @log = nil
+          @dev = nil
+          @prod = nil
+          @withargs = nil
+          @session = nil
           @index = -1
           run_set(kwargs[:run], kwargs[:env], opts: kwargs.fetch(:opts, true))
+          exception_set kwargs[:exception]
+          pipe_set kwargs[:pipe]
+          verbose_set kwargs[:verbose]
           graph_set kwargs[:graph]
           pass_set kwargs[:pass]
-          only_set kwargs[:only]
           exclude_set kwargs[:exclude]
           archive_set kwargs[:archive]
           theme_set common
@@ -144,10 +146,8 @@ module Squared
           data = @workspace.script_find(*@ref, @group)
           if @output[0].nil?
             if (scr = data[:script])
-              unless kwargs[:script] == false
-                @global = true
-                script_set(scr, args: data.fetch(:args, kwargs[:args]), prod: kwargs[:prod])
-              end
+              @global = true
+              script_set(scr, args: data.fetch(:args, kwargs[:args]), prod: kwargs[:prod])
             elsif (run = data[:run])
               @global = true
               run_set run
@@ -170,12 +170,15 @@ module Squared
             @global = true
             run_set data[:run]
           end
+          @global = true
         end
 
         def initialize_events(ref, **)
           return unless (events = @workspace.events_get(group: @group, ref: ref))
 
-          events.each { |task, data| data.each { |ev, blk| @events[ev][task] ||= [blk] } }
+          events.each do |task, data|
+            data.each { |ev, blk| (@events[ev] ||= {})[task] ||= [blk] }
+          end
         end
 
         def initialize_logger(log: nil, **)
@@ -202,7 +205,7 @@ module Squared
             file &&= @workspace.home.join(env('LOG_DIR', ''), file).realdirpath
           rescue StandardError => e
             file = nil
-            print_error e
+            warn log_message(Logger::WARN, e, pass: true) if warning?
           end
           log[:progname] ||= @name
           if (val = env('LOG_LEVEL', ignore: false))
@@ -215,7 +218,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)
@@ -240,26 +243,21 @@ module Squared
           end
         end
 
-        def ==(other)
-          equal?(other)
-        end
-
         def <=>(other)
-          return unless workspace == other.workspace
-          return 0 if equal?(other)
+          return 0 unless workspace == other.workspace
 
           a, b = graph_deps
           return 1 if a.include?(other)
 
           c, d = graph_deps other
-          e = b - d
-          f = d - b
+          e = b.reject { |val| d.include?(val) }
+          f = d.reject { |val| b.include?(val) }
           if parent == other.parent
             g = []
             h = []
           else
-            g = a - c
-            h = c - a
+            g = a.reject { |val| c.include?(val) }
+            h = c.reject { |val| a.include?(val) }
           end
           g << self
           h << other
@@ -269,47 +267,18 @@ module Squared
             -1
           elsif h.any? { |val| e.include?(val) }
             1
-          elsif e.any? { |val| f.include?(val) } # rubocop:disable Lint/DuplicateBranch
+          elsif e.any? { |val| f.include?(val) }
             -1
-          elsif f.any? { |val| e.include?(val) } # rubocop:disable Lint/DuplicateBranch
+          elsif f.any? { |val| e.include?(val) }
             1
           elsif @index >= 0 && (i = other.instance_variable_get(:@index)) >= 0
-            @index <=> i
+            @index <= i ? -1 : 1
+          else
+            0
           end
         rescue StandardError => e
           log&.debug e
-          nil
-        end
-
-        def version=(val)
-          @version = val&.to_s
-        end
-
-        def exception=(val)
-          @exception = case val
-                       when Numeric, TrueClass, FalseClass
-                         val
-                       else
-                         workspace.exception
-                       end
-        end
-
-        def pipe=(val)
-          @pipe = case val
-                  when Numeric, Pathname
-                    val
-                  else
-                    workspace.pipe
-                  end
-        end
-
-        def verbose=(val)
-          @verbose = case val
-                     when Numeric, TrueClass, FalseClass
-                       val
-                     else
-                       workspace.verbose
-                     end
+          0
         end
 
         def ref
@@ -322,13 +291,13 @@ module Squared
 
           namespace name do
             Base.subtasks do |action, flags|
-              next if task_pass?(action)
+              next if @pass.include?(action)
 
               namespace action do
                 flags.each do |flag|
                   case action
                   when 'graph'
-                    break unless graph?
+                    next unless graph?
 
                     format_desc action, flag, '(-)project*'
                     task flag do |_, args|
@@ -338,20 +307,25 @@ module Squared
                       else
                         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
+                          done.each_with_index do |proj, i|
+                            if val.match?(/ #{Regexp.escape(proj.name)}(?:@\d|\z)/)
+                              val += " (#{i.succ})"
+                              break
+                            end
+                          end
+                          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: 3 }
+                          { pat: /\A((?~ \() \()(\d+)(\).*)\z/, styles: theme[:inline], index: 2 }
                         ])
                       end
                     end
                   when 'unpack'
                     format_desc(action, flag, 'tag/url,dir,digest?,f|force?', before: flag == :ext ? 'ext' : nil)
                     params = %i[tag dir digest force]
-                    params.unshift(:ext) if flag == :ext
+                    params.prepend(:ext) if flag == :ext
                     task flag, params do |_, args|
                       ext = flag == :ext ? param_guard(action, flag, args: args, key: :ext) : flag.to_s
                       tag = param_guard(action, flag, args: args, key: :tag)
@@ -372,7 +346,7 @@ module Squared
                       else
                         force = args.fetch(:force, false)
                       end
-                      unpack(basepath(dir), uri: tag, digest: digest, ext: ext, force: force)
+                      unpack(path + dir, uri: tag, digest: digest, ext: ext, force: force)
                     end
                   end
                 end
@@ -395,33 +369,35 @@ module Squared
         end
 
         def add(path, name = nil, **kwargs, &blk)
-          if path.is_a?(String) && path =~ %r{\A(.+)[\\/]\*+\z}
-            return self unless checkdir?(path = basepath($1))
+          if path.is_a?(String) && (seg = path[%r{\A(.+)[\\/]\*+\z}, 1])
+            return self unless checkdir?(path = basepath(seg))
 
             path = path.children.select { |val| checkdir?(val) }
           end
           if path.is_a?(Array)
-            name = self.name if name == true
+            name = @name if name == true
             path.each { |val| add(val, name && task_join(name, File.basename(val)), **kwargs, &blk) }
-          elsif projectpath?(path = basepath(path)) && checkdir?(path)
-            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
-                     name.to_s
-                   else
-                     path.basename
-                   end
-            workspace.add(path, name, **kwargs) do
-              __send__ :parent_set, parent
-              proj = self
-              instance_eval(&blk) if block_given?
-            end
-            @children << proj
-          end
+            return self
+          elsif !projectpath?(path = basepath(path)) || !checkdir?(path)
+            return self
+          end
+          kwargs = @withargs.yield_self { |data| data.dup.update(kwargs) } if @withargs
+          kwargs[:group] = group unless kwargs.key?(:group)
+          kwargs[:ref] = ref unless kwargs.key?(:ref)
+          parent = self
+          proj = nil
+          name = case name
+                 when String, Symbol
+                   name.to_s
+                 else
+                   path.basename
+                 end
+          workspace.add(path, name, **kwargs) do
+            __send__ :parent_set, parent
+            proj = self
+          end
+          @children << proj
+          proj.instance_eval(&blk) if block_given?
           self
         end
 
@@ -431,13 +407,13 @@ module Squared
         end
 
         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
+          return self unless enabled?
+
+          out = obj.link(self, *args, **kwargs, &blk) if obj.respond_to?(:link)
+          if !out
+            warn log_message(Logger::WARN, 'link not compatible', subject: obj.to_s, hint: name, pass: true)
+          elsif out.respond_to?(:build)
+            out.build
           end
           self
         end
@@ -447,72 +423,62 @@ 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)
+            run_b(@run, sync: sync, from: from) if series?(@run)
             args = @output
+            banner = verbosetype > 1 if from_base?('build')
           end
           if args.first.is_a?(Struct)
             f, blk = args.first.to_a
             args[0] = instance_eval(&blk) || f
-            return unless args.first
+            return unless args[0]
           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[0]) if val.first.is_a?(Proc)
+
               a, b, c, d, e = val
               case b
               when Hash
-                b = append_hash(b, target: [], build: true).join(' ')
+                b = append_hash(b, build: true).join(' ')
               when Enumerable
                 b = b.to_a.join(' ')
               end
-              d = append_hash(d, target: []).join(' ') if d.is_a?(Hash)
+              d = append_hash(d).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)
 
-                cmd << a if (a = compose(as_get(b, from), d, script: true, args: e, from: from))
+                cmd << a if (a = compose(as_get(b), d, script: true, args: e, from: from))
               end
-              var.merge!(c) if c.is_a?(Hash)
+              var.update(c) if c.is_a?(Hash)
             end
             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)
-
-              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
+          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 Hash
+              opts = append_hash(opts, build: true)
+              cmd = as_a(cmd).append(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
-              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), flags, script: true, args: extra, from: from)
+            from = :script if from == :run && script?
           end
           run(cmd, var, sync: sync, from: from, banner: banner)
         end
@@ -527,15 +493,19 @@ 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|
+              val.split(/\s*,\s*/).each do |meth|
                 if proj.respond_to?(meth.to_sym)
                   begin
                     proj.__send__(meth, sync: sync)
                   rescue StandardError => e
-                    on_error(e, :prereqs, exception: true)
+                    ret = on(:error, :prereqs, e)
+                    raise unless ret == true
+                  else
+                    next
                   end
-                else
-                  print_error(name, "method: #{meth}", subject: 'prereqs', hint: 'undefined')
+                end
+                if warning?
+                  warn log_message(Logger::WARN, name, 'method not found', subject: 'prereqs', hint: meth, pass: true)
                 end
               end
             elsif proj.build?
@@ -553,7 +523,7 @@ module Squared
         end
 
         def doc(*, sync: invoked_sync?('doc'), **)
-          run_b(@doc, sync: sync, banner: verbosetype > (from_base?('doc') ? 1 : 0), from: :doc)
+          run_b(@doc, sync: sync, from: :doc, banner: from_base?('doc') ? verbosetype > 1 : verbose)
         end
 
         def lint(*, sync: invoked_sync?('lint'), **)
@@ -574,9 +544,9 @@ module Squared
           on :first, :clean unless pass
           case @clean
           when Struct
-            if (val = instance_eval(&@clean.block) || @clean.run)
+            if (any = instance_eval(&@clean.block) || @clean.run)
               temp = @clean
-              @clean = val
+              @clean = any
               clean(*args, sync: sync, pass: true, **kwargs)
               @clean = temp
             end
@@ -586,15 +556,17 @@ module Squared
             begin
               @clean.each { |cmd, opts| build(cmd.to_s, opts, sync: sync) }
             rescue StandardError => e
-              on_error e, :clean
+              log&.error e
+              ret = on(:error, from, e)
+              raise if exception && ret != true
             end
           else
             if @clean.is_a?(Enumerable) && !series?(@clean)
               @clean.each do |val|
-                entry = basepath(val = val.to_s)
+                entry = path + (val = val.to_s)
                 if entry.directory? && val.match?(%r{[\\/]\z})
                   log&.warn "rm -rf #{entry}"
-                  rm_rf(entry, verbose: verbosetype > 0)
+                  rm_rf(entry, verbose: verbose)
                 else
                   log&.warn "rm #{entry}"
                   (val.include?('*') ? Dir[entry] : [entry]).each do |file|
@@ -635,7 +607,8 @@ module Squared
           end
           ret = graph_branch(self, data, tasks, out, sync: sync, pass: pass)
         rescue StandardError => e
-          on_error(e, :graph, exception: true)
+          ret = on(:error, :graph, e)
+          raise unless ret == true
         else
           if out
             [out, ret]
@@ -644,13 +617,13 @@ module Squared
           end
         end
 
-        def unpack(target, file = nil, uri: nil, sync: true, digest: nil, ext: nil, force: false, depth: 1, headers: {},
-                   verbose: self.verbose, from: :unpack)
+        def unpack(target, uri:, sync: true, digest: nil, ext: nil, force: false, depth: 1, headers: {}, from: :unpack)
+          require 'open-uri'
           if !target.exist?
             target.mkpath
           elsif !target.directory?
             raise_error('invalid location', hint: target)
-          elsif !file && !target.empty?
+          elsif !target.empty?
             raise_error('directory not empty', hint: target) unless force || env('UNPACK_FORCE')
             create = true
           end
@@ -671,95 +644,87 @@ module Squared
                    when 128, 'sha512'
                      Digest::SHA512
                    else
-                     raise_error "invalid checksum: #{digest}"
+                     raise_error("invalid checksum: #{digest}", hint: name)
                    end
           end
           if (val = env('HEADERS')) && (val = parse_json(val, hint: "HEADERS_#{@envname}"))
             headers = headers.is_a?(Hash) ? headers.merge(val) : val
           end
-          if file
-            ext ||= File.extname(file)[1..-1]
-          else
-            data = nil
-            (uri = Array(uri)).each_with_index do |url, index|
-              fetch_uri(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
-                end
-                next if ext && index == 0
-
-                case f.content_type
-                when 'application/zip'
-                  ext = 'zip'
-                when %r{application/(?:x-)?gzip}
-                  ext = 'tgz'
-                when 'application/x-xz'
-                  ext = 'txz'
-                when 'application/x-7z-compressed'
-                  ext = '7z'
-                end
+          data = nil
+          (uri = as_a(uri)).each_with_index do |url, index|
+            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
+              end
+              next if ext && index == 0
+
+              case f.content_type
+              when 'application/zip'
+                ext = 'zip'
+              when 'application/x-gzip'
+                ext = 'tgz'
+              when 'application/x-xz'
+                ext = 'txz'
               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)
             end
+            break uri = url if data
+          end
+          unless data && (ext ||= URI.parse(uri).path[/\.(\w+)(?:\?|\z)/, 1])
+            raise_error("no content#{data ? ' type' : ''}", hint: uri)
           end
           ext = ext.downcase
           if (val = env("#{%w[zip 7z gem].include?(ext) ? ext.upcase : 'TAR'}_DEPTH", ignore: false))
             depth = val.to_i
           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.write(data)
-              file.close
-              file = Pathname.new(file)
-              delete = true
+            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.write(data)
+            file.close
             if create
-              print_error('force remove', subject: name, hint: target)
+              warn log_message(Logger::WARN, 'force remove', subject: name, hint: target, pass: true)
               target.rmtree
               target.mkpath
             end
             case ext
             when 'zip', 'aar'
-              session 'unzip', shell_quote(file), quote_option('d', target)
-            when 'tar', 'tgz', 'txz', 'tar.gz', 'tar.xz', 'gz', 'xz'
+              session 'unzip', shell_quote(file.path), quote_option('d', target)
+            when 'tar', 'tgz', 'tar.gz', 'tar.xz', 'gz', 'xz'
               flags = +(verbose ? 'v' : '')
               if ext.end_with?('gz')
                 flags += 'z'
               elsif ext.end_with?('xz')
                 flags += 'J'
               end
-              session 'tar', "-x#{flags}", basic_option('strip-components', depth), quote_option('f', file),
+              session 'tar', "-x#{flags}", basic_option('strip-components', depth), quote_option('f', file.path),
                       quote_option('C', target)
               depth = 0
             when '7z'
-              session '7z', 'x', shell_quote(file), "-o#{shell_quote(target)}"
+              session '7z', 'x', shell_quote(file.path), "-o#{shell_quote(target)}"
             when 'gem'
-              session 'gem', 'unpack', shell_quote(file), quote_option('target', target)
+              session 'gem', 'unpack', shell_quote(file.path), quote_option('target', target)
               depth = 0 unless val
             else
-              raise_error("unsupported format: #{ext}", hint: uri || file)
+              raise_error("unsupported format: #{ext}", hint: uri)
             end
-            run(sync: sync, banner: verbose, from: from)
+            run(sync: sync, from: from)
             while depth > 0 && target.children.size == 1
               entry = target.children.first
               break unless entry.directory?
 
               i = 0
-              i += 1 while (dest = target + "#{File.basename(file)}-#{i}").exist?
+              while (dest = target + "#{File.basename(file.path)}-#{i}").exist?
+                i += 1
+              end
               FileUtils.mv(entry, dest)
-              dest.children.each { |child| FileUtils.mv(child, target) }
+              dest.each_child { |child| FileUtils.mv(child, target) }
               dest.rmdir
               target = entry
               depth -= 1
@@ -767,8 +732,8 @@ module Squared
           ensure
             if dir
               remove_entry dir
-            elsif delete && file&.exist?
-              file.unlink
+            else
+              file&.unlink
             end
           end
         end
@@ -786,7 +751,7 @@ module Squared
         end
 
         def event(name, key, *args, override: false, **kwargs, &blk)
-          data = @events[name.to_sym]
+          data = @events[name.to_sym] ||= {}
           items = if override
                     data[key.to_sym] = []
                   else
@@ -797,8 +762,9 @@ module Squared
         end
 
         def as(cmd, script, to = nil)
-          data = @as[cmd.to_sym]
-          (to ? [[script, to]] : script).each { |key, val| data[key.to_s] = val }
+          script = { "#{script}": to } if to
+          data = (@as ||= {})[cmd.to_sym] ||= {}
+          script.each { |key, val| data[key.to_s] = val }
           self
         end
 
@@ -815,63 +781,14 @@ module Squared
           self
         end
 
-        def run(cmd = @session, var = nil, exception: self.exception, sync: true, from: nil, banner: true, chdir: path,
-                interactive: nil, hint: nil, send: :system, **)
-          unless cmd
-            print_error('no command session started', subject: project, hint: from, pass: true)
-            return
-          end
-          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
-            yn = y == 'Y' ? 'Y/n' : 'y/N'
-            exit 1 unless confirm("#{title}? [#{sub_style(cmd.to_s, styles: theme[:inline])}] [#{yn}] ", y)
-          end
-          cmd = session_done cmd
-          log&.info cmd
-          on :first, from
-          begin
-            if cmd.match?(/\A[^:]+:[^:]/) && workspace.task_defined?(cmd)
-              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) if sync
-              if var != false && (pre = runenv)
-                case pre
-                when Hash
-                  var = var.is_a?(Hash) ? pre.merge(var) : pre
-                when Enumerable
-                  cmd = command(*pre.to_a, cmd)
-                else
-                  cmd = command(pre, cmd)
-                end
-              end
-              args = var.is_a?(Hash) ? [var, cmd] : [cmd]
-              ret = shell(*args, name: send, chdir: chdir, exception: exception)
+        def variable_set(key, *args, **kwargs, &blk)
+          if block_given?
+            if blocks.include?(key)
+              series key, &blk
+              return self
             end
-          rescue StandardError => e
-            on_error(e, from, exception: true)
-            false
-          else
-            on :last, from
-            ret
+            args = block_args args, &blk
           end
-        end
-
-        def scope(*args, **kwargs, &blk)
-          namespace name do
-            task(*args, **kwargs, &blk)
-          end
-        end
-
-        def variable_set(key, *args, **kwargs, &blk)
           if variables.include?(key) || blocks.include?(key)
             val = case args.size
                   when 0
@@ -888,14 +805,10 @@ module Squared
               graph_set val
             when :pass
               pass_set val
-            when :only
-              only_set val
             when :exclude
               exclude_set val
             when :parent
               parent_set val
-            when :archive
-              archive_set val
             when :run
               run_set(*args, **kwargs)
             when :script
@@ -903,17 +816,9 @@ module Squared
             when :env
               run_set(output[0], *args, **kwargs)
             when :dependfile
-              @dependindex = nil
-              @dependfile = (basepath(*args) if val)
+              @dependfile = basepath(*args)
             else
-              if block_given?
-                if blocks.include?(key)
-                  series key, &blk
-                  return self
-                end
-                val = block_args val, &blk
-              end
-              instance_variable_set(:"@#{key}", val.first)
+              instance_variable_set(:"@#{key}", val)
             end
           else
             log&.warn "variable_set: @#{key} (private)"
@@ -921,8 +826,6 @@ module Squared
           self
         end
 
-        alias apply variable_set
-
         def enabled?(ref = nil, **)
           return false if ref && !ref?(ref)
 
@@ -1009,17 +912,17 @@ module Squared
         end
 
         def dependtype(*)
-          dependindex&.succ || 0
+          @dependindex ? @dependindex.succ : 0
         end
 
         def log
           return @log unless @log.is_a?(Array)
 
-          @log = Logger.new(enabled? ? @log.first : nil, **@log.last)
+          @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
         end
 
-        def allref(&blk)
-          @ref.reverse_each(&blk)
+        def allref
+          @ref.reverse_each
         end
 
         def basepath(*args)
@@ -1056,8 +959,51 @@ module Squared
 
         private
 
-        def puts(*args, **kwargs)
-          log_console(*args, pipe: kwargs[:pipe] || pipe)
+        def puts(*args)
+          puts_oe(*args, pipe: pipe)
+        end
+
+        def run(cmd = @session, var = nil, exception: @exception, sync: true, from: nil, banner: true, chdir: path, **)
+          unless cmd
+            if warning?
+              from &&= from.to_s
+              warn log_message(Logger::WARN, from || 'unknown', subject: project, hint: 'no command given', pass: true)
+            end
+            return
+          end
+          cmd = cmd.target if cmd.is_a?(OptionPartition)
+          cmd = session_done cmd
+          log&.info cmd
+          on :first, from
+          begin
+            if cmd.start_with?(/[^:]+:[^:]/) && workspace.task_defined?(cmd)
+              log&.warn "ENV discarded: #{var}" if var
+              task_invoke(cmd, exception: exception, warning: warning?)
+            else
+              print_item format_banner(cmd, banner: banner) if sync
+              if var != false && (pre = runenv)
+                case pre
+                when Hash
+                  var = var.is_a?(Hash) ? pre.merge(var) : pre
+                when Enumerable
+                  cmd = command(*pre.to_a, cmd)
+                else
+                  cmd = command pre, cmd
+                end
+              end
+              args = var.is_a?(Hash) ? [var, cmd] : [cmd]
+              ret = shell(*args, chdir: chdir, exception: exception)
+            end
+          rescue StandardError => e
+            log&.error e
+            ret = on(:error, from, e)
+            raise unless ret == true
+
+            false
+          else
+            on :last, from
+            ret
+          end
         end
 
         def run_s(*cmd, env: nil, sync: true, from: nil, banner: verbose != false, **kwargs)
@@ -1065,7 +1011,8 @@ module Squared
           begin
             cmd.flatten.each { |val| run(val, env, sync: sync, banner: banner, **kwargs) }
           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
@@ -1073,8 +1020,8 @@ module Squared
         def run_b(obj, **kwargs)
           case obj
           when Struct
-            if (val = instance_eval(&obj.block) || obj.run)
-              run_b(val, **kwargs)
+            if (any = instance_eval(&obj.block) || obj.run)
+              run_b(any, **kwargs)
             end
           when Proc
             instance_eval(&obj)
@@ -1086,7 +1033,7 @@ module Squared
             elsif obj.is_a?(Array) && obj.any? { |val| !val.is_a?(String) }
               build(*obj, **kwargs)
             elsif obj
-              run_s(*Array(obj), **kwargs)
+              run_s(obj.is_a?(Enumerable) ? obj.to_a : obj, **kwargs)
             end
           end
         end
@@ -1094,7 +1041,6 @@ module Squared
         def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], depth: 0,
                          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])
@@ -1113,8 +1059,6 @@ module Squared
           else
             items = check.call(data[start])
           end
-          return done if items.empty?
-
           if out
             a, b, c, d, e = ARG[:GRAPH]
             f = tag.call(target)
@@ -1136,7 +1080,7 @@ module Squared
 
             t = dedupe.call(proj.name)
             j = if out
-                  if i == items.size - 1 || check.call(post = items[(i + 1)..-1]).empty?
+                  if i == items.size - 1 || check.call(post = items[i + 1..-1]).empty?
                     true
                   elsif !t.empty? && depth > 0
                     post.reject { |pr| t.include?(pr) }.empty?
@@ -1147,7 +1091,10 @@ module Squared
                                                    single: single, last: j == true, context: target)
             end
             if !out
-              (tasks || (subtasks = script.call(proj)) || (dev? ? %w[build copy] : %w[depend build])).each do |meth|
+              if !tasks && (script = workspace.script_get(:graph, group: proj.group, ref: proj.allref))
+                group = script[:graph]
+              end
+              (tasks || group || (dev? ? ['build', 'copy'] : ['depend', 'build'])).each do |meth|
                 next if pass.include?(meth)
 
                 if workspace.task_defined?(cmd = task_join(proj.name, meth))
@@ -1158,7 +1105,7 @@ module Squared
                   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, tasks || group ? nil : workspace.baseref)
                   proj.__send__(meth.to_sym, sync: sync)
                 end
               end
@@ -1183,7 +1130,7 @@ module Squared
           done
         end
 
-        def graph_collect(target, start = [], data: {}, pass: [], root: [])
+        def graph_collect(target, start = [], data: {}, pass: [])
           deps = []
           (start.empty? ? target.instance_variable_get(:@graph) : start)&.each do |val|
             next if pass.include?(val)
@@ -1195,13 +1142,12 @@ module Squared
             else
               items = workspace.find(group: val, ref: val.to_sym)
             end
+
             items.each do |proj|
-              next if pass.include?(name = proj.name)
+              next if pass.include?(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)
+              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
               deps.concat(objs)
@@ -1232,7 +1178,7 @@ module Squared
         def env(key, default = nil, suffix: nil, equals: nil, ignore: nil, strict: false)
           a = "#{key}_#{@envname}"
           ret = if suffix
-                  ENV["#{a}_#{suffix}"] || (ignore == false && ENV["#{key}_#{suffix}"]) || ''
+                  ENV.fetch("#{a}_#{suffix}", '')
                 elsif strict
                   ENV[a].to_s
                 else
@@ -1241,23 +1187,31 @@ module Squared
                 end
           return ret == equals.to_s unless equals.nil?
 
-          ret.empty? || (ignore && Array(ignore).any? { |val| ret == val.to_s }) ? default : ret
+          ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
         end
 
         def session(*cmd, prefix: cmd.first, main: true, path: true, options: true)
-          prefix = stripext prefix.to_s
-          if path && (val = shell_bin(prefix))
+          prefix = stripext(prefix.to_s).upcase
+          if path && (val = ENV["PATH_#{prefix}"] || PATH[prefix] || PATH[prefix.to_sym])
             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 && (val = env("#{prefix}_OPTIONS"))
+            split_escape(val).each { |opt| ret.last(fill_option(opt), /\A(--?[^ =]+)[ =].+\z/m) }
           end
           main ? @session = ret : ret
         end
 
         def session_delete(*args, target: @session)
-          OptionPartition.delete(target, *args)
+          ret = []
+          args.each do |val|
+            pat = /\A#{Regexp.escape(shell_option(val))}(?: |=|\z)/
+            if (key = target.find { |opt| opt.match?(pat) })
+              target.delete(key)
+              ret << key
+            end
+          end
+          ret
         end
 
         def session_output(*cmd, **kwargs)
@@ -1267,8 +1221,8 @@ module Squared
         def session_done(cmd)
           return cmd unless cmd.respond_to?(:done)
 
-          raise_error('no args added', hint: cmd.first) unless cmd.size > 1
-          @session = nil if cmd.equal?(@session)
+          raise_error('no args added', hint: cmd.first || name) unless cmd.size > 1
+          @session = nil if cmd == @session
           cmd.done
         end
 
@@ -1279,20 +1233,17 @@ module Squared
         end
 
         def option(*args, target: @session, prefix: target&.first, **kwargs)
-          return unless prefix
+          if prefix
+            args.each do |val|
+              next unless (ret = env("#{stripext(prefix)}_#{val.gsub(/\W/, '_')}".upcase, **kwargs))
+              return ret unless block_given?
 
-          args.each do |val|
-            ret = env(env_key(stripext(prefix), val), **kwargs)
-            return ret if ret
+              return yield ret
+            end
           end
           nil
         end
 
-        def option_sanitize(opts, list, target: @session, **kwargs)
-          op = OptionPartition.new(opts, list, target, project: self, **kwargs)
-          [op.extras, op.values]
-        end
-
         def option_clear(opts, target: @session, **kwargs)
           return unless target
 
@@ -1300,22 +1251,16 @@ module Squared
         end
 
         def print_success(*)
-          puts ARG[:SUCCESS]
-        end
-
-        def print_error(*args, loglevel: Logger::WARN, **kwargs)
-          return unless warning?
-
-          warn log_message(loglevel, *args, **kwargs)
+          puts 'Success'
         end
 
         def print_item(*val)
           puts unless printfirst?
           printsucc
-          puts val unless val.empty? || (val.size == 1 && (!val.first || val.first.empty?))
+          puts val unless val.empty? || (val.size == 1 && val.first.nil?)
         end
 
-        def print_banner(*lines, client: false, styles: theme[:banner], border: borderstyle, **)
+        def print_banner(*lines, styles: theme[:banner], border: borderstyle, client: false)
           pad = 0
           if styles
             if styles.any? { |s| s.to_s.end_with?('!') }
@@ -1324,7 +1269,7 @@ module Squared
               styles = [:bold] + styles
             end
           end
-          n = Project.max_width(lines)
+          n = line_width lines
           ch = ' ' * pad
           index = -1
           lines.map! do |val|
@@ -1339,64 +1284,45 @@ module Squared
           (lines << sub_style(ARG[:BORDER][1] * n, styles: border)).join("\n")
         end
 
-        def print_footer(*lines, sub: nil, reverse: false, right: false, border: borderstyle, **)
-          n = Project.max_width(lines)
+        def print_footer(*lines, sub: nil, reverse: false, right: false, **kwargs)
+          n = line_width lines
           lines.map! do |val|
             s = right ? val.rjust(n) : val.ljust(n)
             sub&.each { |h| s = sub_style(s, **h) }
             s
           end
-          ret = [sub_style(ARG[:BORDER][1] * n, styles: border)].concat(lines)
+          ret = [sub_style(ARG[:BORDER][1] * n, styles: kwargs.key?(:border) ? kwargs[:border] : borderstyle), *lines]
           ret.reverse! if reverse
           ret.join("\n")
         end
 
-        def print_status(*args, from: nil, **kwargs)
-          return if stdin?
-
-          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)
-            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(epochtime - kwargs[:start]))
-            end
-          end
-        end
-
         def format_desc(action, flag, opts = nil, **kwargs)
           return unless TASK_METADATA
 
-          ret = [@desc, action]
-          ret << flag if flag
-          workspace.format_desc(ret, opts, **kwargs)
+          workspace.format_desc([@desc, action, flag].compact, opts, **kwargs)
         end
 
         def format_banner(cmd, banner: true)
           return unless banner && banner?
 
           if (data = workspace.banner_get(*@ref, group: group))
-            return if data.empty?
+            return if !data.command && data.order.empty?
 
             client = true
           else
-            data = { command: true, order: [:path], styles: theme[:banner], border: theme[:border] }
+            data = Workspace::Support::BannerData.new(true, [:path], theme[:banner], theme[:border])
           end
           if verbose
             out = []
-            if data[:command]
+            if data.command
               if cmd =~ /\A(?:"((?:[^"]|(?<=\\)")+)"|'((?:[^']|(?<=\\)')+)'|(\S+))( |\z)/
                 path = $3 || $2 || $1
-                cmd = cmd.sub(path, stripext(path).upcase)
+                name = stripext path
+                cmd = cmd.sub(path, data.command == 0 ? name : name.upcase)
               end
               out << cmd
             end
-            data[:order].each do |val|
+            data.order.each do |val|
               if val.is_a?(Array)
                 s = ' '
                 found = false
@@ -1406,19 +1332,19 @@ module Squared
                     meth
                   elsif respond_to?(meth)
                     found = true
-                    __send__(meth)
+                    __send__ meth
                   end
                 end
-                val = val.reject { |item| !item || item == true }.join(s)
+                val = val.compact.join(s)
                 next unless found && !val.empty?
               elsif (val = __send__(val)).nil?
                 next
               end
               out << val.to_s
             end
-            print_banner(*out, styles: data[:styles], border: data[:border], client: client)
+            print_banner(*out, styles: data.styles, border: data.border, client: client)
           elsif workspace.series.multiple?
-            "## #{__send__(data[:order].first || :path)} ##"
+            "## #{__send__(data.order.first || :path)} ##"
           end
         end
 
@@ -1428,9 +1354,9 @@ module Squared
           unless items.empty?
             pad = items.size.to_s.size
             items.each_with_index do |val, i|
-              next unless matchany?(val.first, reg)
+              next unless reg.empty? || reg.any? { |pat| val[0].match?(pat) }
 
-              out << "#{i.succ.to_s.rjust(pad)}. #{each ? each.call(val) : val.first}"
+              out << "#{i.succ.to_s.rjust(pad)}. #{each ? each.call(val) : val[0]}"
             end
           end
           sub = [headerstyle]
@@ -1442,13 +1368,13 @@ module Squared
               out << ''
             end
             if from
-              out << (from = from.to_s)
+              out << from
               pat = /\A(#{Regexp.escape(from)})(.*)\z/
             end
           else
             pat = /\A(\s*\d+\.)(.+)\z/
             unless grep.empty?
-              footer = "#{out.size} found "
+              footer = "#{out.size} found"
               sub << { pat: /\A(\d+)( .+)\z/, styles: theme[:inline] }
             end
           end
@@ -1460,12 +1386,12 @@ 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', ignore: false))
+        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)
               data = data.merge(extra)
@@ -1477,7 +1403,7 @@ module Squared
             next if (key = key.to_s).start_with?('__')
 
             if val.nil? || extra || session_arg?(key, target: target)
-              OptionPartition.delete_key(target, key)
+              session_delete(key, target: target)
               next if val.nil?
             end
             case val
@@ -1487,8 +1413,6 @@ 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)
             end
@@ -1497,14 +1421,15 @@ module Squared
         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)
           case val
-          when String
-            target << val
           when Hash
             append_hash(val, target: target, build: build)
           when Enumerable
@@ -1535,7 +1460,7 @@ module Squared
             return target << (if flag
                                 shell_option(opt, equals ? val : nil, quote: quote, escape: escape, force: force)
                               else
-                                shell_quote(val)
+                                shell_quote val
                               end)
           end
           nil
@@ -1545,18 +1470,18 @@ 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, equals ? val : nil, escape: escape, quote: quote, force: force)
             end
-            ret << shell_option(flag, equals ? val : nil, escape: escape, quote: quote, force: force)
+            ret.each { |val| target << val } unless ret.empty?
           end
-          ret.each { |val| target << val } unless ret.empty?
         end
 
         def append_nocolor(target: @session)
@@ -1570,7 +1495,7 @@ module Squared
             when String
               "#{base} #{data}"
             when Hash
-              "#{append_hash(base, target: []).join(' ')} #{data}"
+              "#{append_hash(base).join(' ')} #{data}"
             when Enumerable
               "#{base.to_a.join(' ')} #{data}"
             else
@@ -1579,11 +1504,11 @@ module Squared
           when Hash
             case base
             when String
-              "#{base} #{append_hash(data, target: []).join(' ')}"
+              "#{base} #{append_hash(data).join(' ')}"
             when Hash
               base.merge(data)
             when Enumerable
-              Set.new(base.to_a + append_hash(data, target: [])).to_a
+              Set.new(base.to_a + append_hash(data)).to_a
             else
               data
             end
@@ -1592,7 +1517,7 @@ module Squared
             when String
               "#{base} #{data.to_a.join(' ')}"
             when Hash
-              "#{append_hash(base, target: []).join(' ')} #{data.to_a.join(' ')}"
+              "#{append_hash(base).join(' ')} #{data.to_a.join(' ')}"
             when Enumerable
               Set.new(base.to_a + data.to_a).to_a
             else
@@ -1604,16 +1529,9 @@ module Squared
         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(' ')
+          [].tap do |ret|
+            data.each { |key, val| ret.concat(val) unless pass.include?(key) }
+          end
         end
 
         def parse_json(val, kind: Hash, hint: nil)
@@ -1621,20 +1539,11 @@ module Squared
           raise_error("invalid JSON #{kind.name}", val, hint: hint) if kind && !ret.is_a?(kind)
         rescue StandardError => e
           log&.warn e
-          print_error(e, subject: name)
+          warn log_message(Logger::WARN, e, subject: name, pass: true) if warning?
         else
           ret
         end
 
-        def fetch_uri(*args, **kwargs, &blk)
-          require 'open-uri'
-          if RUBY_VERSION < '2.5'
-            open(*args, **kwargs, &blk)
-          else
-            URI.open(*args, **kwargs, &blk)
-          end
-        end
-
         def param_guard(action, flag, args:, key: nil, pat: nil, values: nil)
           if args && key
             val = args.fetch(key, nil)
@@ -1649,7 +1558,7 @@ module Squared
           args
         end
 
-        def confirm_outdated(pkg, ver, rev, lock: false)
+        def confirm_outdated(pkg, ver, rev, cur = nil, lock: false, col1: 0)
           a = sub_style(case rev
                         when 1
                           'MAJOR'
@@ -1657,52 +1566,53 @@ module Squared
                           'MINOR'
                         else
                           'PATCH'
-                        end, styles: theme[:header])
-          b = sub_style("#{pkg} #{ver}", styles: theme[:inline])
+                        end, styles: (rev == 1 && theme[:major]) || theme[:header])
+          b = sub_style(pkg.ljust(col1), styles: theme[:inline])
           c, d = rev == 1 || lock ? ['y/N', 'N'] : ['Y/n', 'Y']
-          e = lock ? " #{sub_style('(locked)', styles: color(:red))}" : ''
-          confirm "Upgrade to #{a}? #{b + e} [#{c}] ", d
+          e = lock ? sub_style((cur || 'locked').rjust(7), styles: color(:red)) : cur&.rjust(7)
+          confirm "#{a}: #{b}#{e} #{sub_style(ver.rjust(col1 > 0 ? 10 : 0), styles: theme[:inline])} [#{c}] ", d
         end
 
-        def choice_index(msg, list, values: nil, accept: nil, series: false, trim: nil, column: nil, multiple: false,
-                         force: true, **kwargs)
+        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?
-            exit 1 if force
-            return
+          unless (ret = choice(msg, list, multiple: multiple, force: force, **kwargs)) || !force
+            raise_error 'user cancelled'
+          end
+          if ret.nil? || ret.empty?
+            return unless force
+
+            exit 1
           end
           ret = multiple ? ret.map! { |val| val.sub(trim, '') } : ret.sub(trim, '') if trim
           if column
-            a, b = Array(column)
-            ret = Array(ret).map! { |val| val[a, b || 1] }
+            a, b = as_a column
+            ret = as_a(ret).map! { |val| val[a, b || 1] }
             ret = ret.first unless multiple
           end
           if accept
-            hint = Array(ret).map { |val| sub_style(val, styles: theme[:inline]) }.join(', ')
-            accept = Array(accept).map { |val| Array(val) }
+            a = as_a(ret).map { |val| sub_style(val, styles: theme[:inline]) }.join(', ')
+            accept = as_a(accept).map { |val| as_a(val) }
             if accept.any? { |val| val[1] == true }
               ret = [ret]
               multiple = -1
             end
             loop do
-              item = accept.first
-              d, e = item[2] ? ['Y', '[Y/n]'] : ['N', '[y/N]']
-              c = confirm("#{item[0]}#{hint ? " [#{hint}]" : ''} #{e} ", d, timeout: 60)
-              if item[1] == true
+              c = confirm("#{accept.first[0]}#{a ? " [#{a}]" : ''} [y/N] ", 'N', timeout: 60)
+              if accept.shift[1] == true
                 ret << c
               elsif !c
                 break
               end
-              hint = nil
-              accept.shift
+              a = nil
               break if accept.empty?
             end
             exit 1 unless accept.empty?
           end
           if values
             ret = [ret] unless accept && multiple == -1
-            Array(values).each do |val|
+            values.each do |val|
               if val.is_a?(Array)
                 val, force = val
               else
@@ -1716,8 +1626,8 @@ module Squared
           ret
         end
 
-        def command_args(args, min: 0, force: false, **kwargs)
-          return if args.size > min || option('i', 'interactive', **kwargs, equals: '0')
+        def command_args(args, force: false, **kwargs)
+          return unless args.size == 1 && !option('i', 'interactive', **kwargs, equals: '0')
 
           readline('Enter arguments', force: force)
         end
@@ -1726,7 +1636,7 @@ module Squared
           if (ret = instance_eval(&blk)).nil?
             val
           else
-            Array(ret)
+            ret.is_a?(Array) ? ret : [ret]
           end
         end
 
@@ -1735,17 +1645,21 @@ module Squared
         end
 
         def command(*args)
-          return args.join(' && ') unless workspace.powershell?
-
-          "#{shell_bin('powershell.exe')} -Command \"& {#{args.join(' ; ')}}\""
+          if workspace.powershell?
+            "powershell.exe -Command \"& {#{args.join(' ; ')}}\""
+          else
+            args.join(' && ')
+          end
         end
 
         def relativepath(*list, all: false)
           return [] if list.empty?
 
           list.flatten.map! { |val| Pathname.new(val) }.select { |val| projectpath?(val) }.map! do |val|
-            ret = (val.absolute? ? val.relative_path_from(path) : val.cleanpath).to_s
-            all && val.to_s.end_with?('/') ? "#{ret}/*" : ret
+            val = val.absolute? ? val.relative_path_from(path).to_s : val.to_s
+            val = val[2..-1] if val.start_with?('./')
+            val = "#{val}*" if all && val.end_with?('/')
+            val
           end
         end
 
@@ -1755,22 +1669,7 @@ module Squared
             raise_error 'pathspec not within worktree' unless pass || files.size == proj.size
             files = proj
           end
-          files.map { |val| val == '.' ? '.' : shell_quote(basepath(val)) }
-        end
-
-        def matchmap(list, prefix = nil)
-          list.map do |val|
-            next val if val.is_a?(Regexp)
-
-            if prefix
-              a = nil
-              (val = val.dup).sub!(/\A(\^|\\A)/) do |s|
-                a = s
-                nil
-              end
-            end
-            Regexp.new("#{a}#{prefix}#{val == '*' ? '.+' : val}")
-          end
+          files.map { |val| val == '.' ? '.' : shell_quote(path + val) }
         end
 
         def semver(val)
@@ -1786,53 +1685,23 @@ module Squared
         end
 
         def semscan(val, fill: true)
-          ret = val.scan(SEM_VER).first
-          fill ? semver(ret) : ret
-        end
-
-        def semcmp(val, other)
-          return 0 if val == other
-          return -1 if (b = other.scan(SEM_VER)).empty?
-          return 1 if (a = val.scan(SEM_VER)).empty?
-
-          a, b = [a.first, b.first].map! do |c|
-            begin
-              d = Integer(c[6]).to_s
-            rescue StandardError
-              d = c[6] ? '-1' : '0'
-            end
-            [c[0], c[2], c[4] || '0', d]
-          end
-          a.each_with_index do |c, index|
-            next if c == (d = b[index])
-
-            return c.to_i < d.to_i ? 1 : -1
-          end
-          0
-        end
-
-        def semgte?(val, other)
-          semcmp(val, other) != 1
+          val.scan(SEM_VER).first.yield_self { |data| fill ? semver(data) : data }
         end
 
         def indexitem(val)
-          [$1.to_i, $2 && $2[1..-1]] if val =~ /\A[=^#{indexchar}](\d+)(:.+)?\z/
+          [$1.to_i, $2 && $2[1..-1]] if val =~ /\A\^(\d+)(:.+)?\z/
         end
 
         def indexerror(val, list = nil)
           raise_error("requested index #{val}", hint: list && "of #{list.size}")
         end
 
-        def indexchar
-          workspace.windows? ? '=' : '^'
-        end
-
         def printsucc
           @@print_order += 1
         end
 
         def color(val)
-          (ret = theme[val]) && !ret.empty? ? ret : [val]
+          theme[val].yield_self { |styles| styles && !styles.empty? ? styles : [val] }
         end
 
         def colormap(val)
@@ -1855,9 +1724,9 @@ module Squared
         end
 
         def on(event, from, *args, **kwargs)
-          return unless from && @events.key?(event)
+          return unless from && (data = @events[event])
 
-          Array(@events[event][from]).each do |obj|
+          data[from]&.each do |obj|
             target, opts = if obj.is_a?(Array) && obj[1].is_a?(Hash)
                              [obj[0], kwargs.empty? ? obj[1] : obj[1].merge(kwargs)]
                            else
@@ -1874,52 +1743,32 @@ module Squared
           end
         end
 
-        def on_error(err, from, exception: self.exception, pass: false, dryrun: false)
-          log&.error err
-          unless dryrun
-            ret = on :error, from, err
-            raise err if exception && ret != true
-          end
-          print_error(err, pass: pass) unless ret
-        end
-
-        def pwd_set(done = nil, pass: false, from: nil, dryrun: false)
-          pwd = Pathname.pwd
-          if block_given?
-            begin
-              unless (path == pwd || pass == true) && (workspace.mri? || !workspace.windows?)
-                restore = true
-                Dir.chdir(path)
-              end
-              yield
-            rescue StandardError => e
-              on_error(e, from, dryrun: dryrun)
-            ensure
-              Dir.chdir(pwd) if restore
-            end
-          elsif @pwd == pwd
-            @pwd = nil
-            pwd unless done
-          elsif @pwd
-            return unless path == pwd
-
-            Dir.chdir(@pwd)
-            @pwd = nil
-          elsif !done && path != pwd
-            @pwd = pwd
+        def pwd_set(pass: false, from: nil)
+          pwd = Dir.pwd
+          if path.to_s == pwd || pass == true || (pass.is_a?(String) && semscan(pass).join <= RUBY_VERSION)
+            ret = yield
+          else
             Dir.chdir(path)
-            @pwd
+            ret = yield
+            Dir.chdir(pwd)
           end
+        rescue StandardError => e
+          puts e
+          log&.error e
+          ret = on(:error, from, e)
+          raise if exception && ret != true
+        else
+          ret
         end
 
         def run_set(cmd, val = nil, opts: nil, **)
-          noopt = @output[1] == false && !@output[0].nil?
-          noenv = @output[2] == false
+          diso = @output[1] == false && !@output[0].nil?
+          dise = @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]
@@ -1928,14 +1777,14 @@ module Squared
             else
               ret[0] = false
             end
-            ret[2] = data[:env] unless noenv
+            ret[2] = data[:env] unless dise
             ret
           end
           case cmd
           when Array
-            @output = if cmd.all?(Hash)
-                        noopt = false
-                        noenv = false
+            @output = if cmd.all? { |data| data.is_a?(Hash) }
+                        diso = false
+                        dise = false
                         cmd.map { |data| parse.call(data) }
                       else
                         cmd.dup
@@ -1946,14 +1795,14 @@ module Squared
           else
             @output[0] = cmd
           end
-          unless noopt
+          unless diso
             if opts == false
               @output[1] = false
             elsif opts && opts != true
               @output[1] = opts
             end
           end
-          return if noenv
+          return if dise
 
           if val.is_a?(Hash)
             @output[2] = val
@@ -1982,18 +1831,33 @@ module Squared
           @parent = val if val.is_a?(Project::Base)
         end
 
+        def exception_set(val)
+          @exception = env_bool(val, workspace.exception, strict: true)
+        end
+
+        def pipe_set(val)
+          @pipe = env_pipe(val, workspace.pipe, strict: true)
+        end
+
+        def verbose_set(val)
+          @verbose = case val
+                     when NilClass
+                       workspace.verbose
+                     when String
+                       env_bool(val, workspace.verbose, strict: true, index: true)
+                     else
+                       val
+                     end
+        end
+
         def graph_set(val)
           @graph = if val
-                     Array(val).map { |s| workspace.prefix ? workspace.task_name(s).to_sym : s.to_sym }.freeze
+                     as_a(val).map { |s| workspace.prefix ? workspace.task_name(s).to_sym : s.to_sym }.freeze
                    end
         end
 
         def pass_set(val)
-          @pass = Array(val).freeze
-        end
-
-        def only_set(val)
-          @only = val && as_a(val, :to_s).freeze
+          @pass = (val ? as_a(val, :to_s) : []).freeze
         end
 
         def exclude_set(val)
@@ -2019,25 +1883,16 @@ module Squared
                    end
         end
 
-        def dependfile_set(list, default: 0)
-          @dependindex = if @dependname
-                           @dependfile = basepath @dependname
-                           list.index(@dependname)
-                         else
-                           list.index { |file| basepath(file).exist? }.tap do |i|
-                             @dependfile = basepath(list[i || default])
-                           end
-                         end || (list unless enabled?)
+        def dependfile_set(list)
+          @dependindex = list.index { |file| basepath(file).exist? }.tap do |index|
+            @dependfile = @path + list[index || 0]
+          end
         end
 
-        def dependindex
-          dependfile_set @dependindex if @dependindex.is_a?(Array)
-
-          @dependindex unless @dependindex.is_a?(Array)
-        end
+        def as_get(val)
+          return unless val
 
-        def as_get(val, from)
-          (@global && @as[from][val]) || val
+          @global && (ret = @as && @as[from] && @as[from][val]) ? ret : val
         end
 
         def task_build(keys)
@@ -2050,7 +1905,7 @@ module Squared
               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)
+                  __send__ key
                 end
               end
               next if (items = @children.select { |item| item.task_include?(key) }).empty?
@@ -2061,30 +1916,23 @@ module Squared
           end
         end
 
-        def task_pass?(key)
-          @only ? !@only.include?(key) : @pass.include?(key)
-        end
-
-        def matchany?(val, list, empty: true)
-          list.empty? ? empty : list.any? { |pat| val.match?(pat) }
-        end
-
         def projectpath?(val)
-          ret = Pathname.new(val).cleanpath
-          ret.absolute? ? ret.to_s.start_with?(File.join(path, '')) : !ret.to_s.start_with?(File.join('..', ''))
+          Pathname.new(val).cleanpath.yield_self do |file|
+            file.absolute? ? file.to_s.start_with?(File.join(path, '')) : !file.to_s.start_with?(File.join('..', ''))
+          end
         end
 
         def checkdir?(val)
           if val.directory? && !val.empty?
             true
           else
-            log&.warn "directory \"#{val}\" (#{val.directory? ? 'empty' : 'not found'})"
+            log&.warn "directory \"#{val}\" (#{val.empty? ? 'empty' : 'not found'})"
             false
           end
         end
 
         def semmajor?(cur, want)
-          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[6]
+          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
         end
 
         def printfirst?
@@ -2093,7 +1941,7 @@ module Squared
 
         def runnable?(val)
           case val
-          when String, Enumerable, Proc, Method, Struct
+          when String, Enumerable, Proc, Method
             true
           else
             false
@@ -2123,22 +1971,17 @@ module Squared
           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'))
 
-          val = workspace.series.name_get(action)
-          val != action && invoked_sync?(val)
+          workspace.series.name_get(action).yield_self { |name| name != action && invoked_sync?(name) }
         end
 
-        def success?(ret, display = true)
-          ret == true && display && stdout? && banner?
+        def success?(ret)
+          ret == true && stdout? && banner?
         end
 
         def banner?
           ARG[:BANNER] && !env('BANNER', equals: '0')
         end
 
-        def pwd?
-          path == Pathname.pwd
-        end
-
         def stdin?
           pipe == 0
         end
@@ -2152,9 +1995,14 @@ module Squared
         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)
+          case data
+          when Hash
+            other.is_a?(Enumerable) ? other.any? { |obj| data.value?(obj) } : data.value?(other)
+          when Enumerable
+            other.is_a?(Enumerable) ? other.any? { |obj| data.include?(obj) } : data.include?(other)
+          else
+            false
+          end
         end
 
         def variables
@@ -2165,20 +2013,8 @@ 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
-          ((data = workspace.banner_get(*@ref, group: group)) && data[:border]) || theme[:border]
+          workspace.banner_get(*@ref, group: group)&.border || theme[:border]
         end
 
         def headerstyle
@@ -2191,7 +2027,7 @@ module Squared
       end
 
       Application.implement(Base, base: true)
-      Application.attr_banner = Common::SymSet.new(%i[name project path ref group parent])
+      Application.attr_banner = Set.new(%i[name project path ref group parent])
     end
   end
 end