squared 0.3.14 → 0.4.0

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

@@ -15,8 +15,10 @@ module Squared
         include Rake::DSL
 
         VAR_SET = %i[parent global envname dependfile theme run script env pass].freeze
-        SEM_VER = /\b(\d+)(?:(\.)(\d+))?(?:(\.)(\d+))?[-.]?(\S+)?\b/.freeze
-        private_constant :VAR_SET, :SEM_VER
+        BLK_SET = %i[run depend doc lint test copy clean].freeze
+        SEM_VER = /\b(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?\b/.freeze
+        URI_SCHEME = %r{^([a-z][a-z\d+-.]*)://[^@:\[\]\\^<>|\s]}i.freeze
+        private_constant :VAR_SET, :BLK_SET, :SEM_VER, :URI_SCHEME
 
         class << self
           def populate(*); end
@@ -25,7 +27,7 @@ module Squared
           def bannerargs(*); end
 
           def tasks
-            %i[build depend graph doc lint test copy clean].freeze
+            (%i[build archive graph] + BLK_SET).freeze
           end
 
           def as_path(val)
@@ -51,7 +53,8 @@ module Squared
         end
 
         (@@tasks = {})[ref] = {
-          'graph' => %i[run print].freeze
+          'graph' => %i[run print].freeze,
+          'unpack' => %i[zip tar tgz tar.gz txz tar.xz].freeze
         }.freeze
         @@task_desc = Rake::TaskManager.record_task_metadata
         @@print_order = 0
@@ -59,8 +62,8 @@ module Squared
         attr_reader :name, :project, :workspace, :path, :theme, :exception, :pipe, :verbose,
                     :group, :parent, :dependfile
 
-        def initialize(workspace, path, name, *, group: nil, graph: nil, pass: nil, exclude: nil, verbose: nil,
-                       first: {}, last: {}, error: {}, common: ARG[:COMMON], **kwargs)
+        def initialize(workspace, path, name, *, group: nil, graph: nil, pass: nil, exclude: nil, release: nil,
+                       archive: nil, first: {}, last: {}, error: {}, common: ARG[:COMMON], **kwargs)
           @path = path
           @workspace = workspace
           @name = name.to_s.freeze
@@ -73,6 +76,13 @@ module Squared
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
           @version = kwargs[:version]
+          @archive = case archive
+                     when String, Array
+                       { uri: archive }
+                     when Hash
+                       archive
+                     end
+          @release = release
           @envname = @name.gsub(/[^\w]+/, '_').upcase.freeze
           @exception = env_bool(kwargs[:exception], workspace.exception, strict: true)
           @pipe = env_pipe(kwargs[:pipe], workspace.pipe, strict: true)
@@ -80,7 +90,7 @@ module Squared
                      when nil
                        workspace.verbose
                      when String
-                       env_bool(verbose, workspace.verbose, strict: true, index: true)
+                       env_pipe(verbose, workspace.verbose, strict: true, index: true)
                      else
                        verbose
                      end
@@ -108,7 +118,7 @@ module Squared
           @parent = nil
           @global = false
           run_set(kwargs[:run], kwargs[:env], opts: kwargs.fetch(:opts, true))
-          initialize_ref(Base.ref)
+          initialize_ref Base.ref
         end
 
         def initialize_ref(ref)
@@ -116,7 +126,7 @@ module Squared
         end
 
         def initialize_build(ref, **kwargs)
-          initialize_ref(ref)
+          initialize_ref ref
           if (@script = @workspace.script_get(group: @group, ref: ref))
             if @script[:log] && !kwargs.key?(:log)
               kwargs[:log] = @script[:log]
@@ -166,43 +176,40 @@ module Squared
         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, **)
           return if @log
 
           log = log.is_a?(Hash) ? log.dup : { file: log }
-          if (file = env('LOG_FILE'))
-            file = DateTime.now.strftime(file)
-          elsif (val = env('LOG_AUTO'))
-            file = "#{@name}-%s.log" % [case val
-                                        when 'y', 'year'
-                                          Date.today.year
-                                        when 'm', 'month'
-                                          Date.today.strftime('%Y-%m')
-                                        when 'd', 'day', '1'
-                                          Date.today
-                                        else
-                                          val.include?('%') ? DateTime.now.strftime(val) : DateTime.now.strftime
-                                        end]
-          elsif (val = log[:file])
-            file = val.is_a?(String) ? DateTime.now.strftime(val) : "#{@name}-#{Date.today}.log"
-          end
-          if file
-            file = (val = env('LOG_DIR')) ? @workspace.home.join(val, file) : @workspace.home.join(file)
+          unless (file = env('LOG_FILE'))
+            file = case env('LOG_AUTO')
+                   when 'y', 'year'
+                     "#{@name}-#{Date.today.year}.log"
+                   when 'm', 'month'
+                     "#{@name}-#{Date.today.strftime('%Y-%m')}.log"
+                   when 'd', 'day', '1'
+                     "#{@name}-#{Date.today}.log"
+                   end
+          end
+          if file ||= log[:file]
+            file = Date.today.strftime(file)
+            file = (dir = env('LOG_DIR')) ? @workspace.home.join(dir, file) : @workspace.home.join(file)
             begin
               file = file.realdirpath
             rescue StandardError => e
               raise if @exception
 
               file = nil
-              warn log_message(Logger::WARN, e) if warning?
+              warn log_message(Logger::WARN, e, pass: true) if warning?
             end
           end
           log[:progname] ||= @name
           if (val = env('LOG_LEVEL', ignore: false))
-            log[:level] = val
+            log[:level] = val.match?(/^\d$/) ? log_sym(val.to_i) : val
           end
           log.delete(:file)
           @log = [file, log]
@@ -211,20 +218,18 @@ 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)
-          cmd = @output[0]
-          if @output[2] != false && (val = env('BUILD', suffix: 'ENV'))
-            begin
-              data = JSON.parse(val)
-              raise_error('invalid JSON object', val, hint: "BUILD_#{@envname}_ENV") unless data.is_a?(Hash)
-            rescue StandardError => e
-              log&.warn e
-            else
-              @output[2] = data
+          unless @output[2] == false || !(val = env('BUILD', suffix: 'ENV'))
+            data = parse_json(val, hint: "BUILD_#{@envname}_ENV")
+            @output[2] = data if data
+          end
+          unless @output[0] == false || @output[0].is_a?(Array)
+            if (val = env('BUILD', suffix: 'OPTS'))
+              n = @output[0] ? 1 : 3
+              @output[n] = merge_opts(@output[n], shell_split(val, escape: false))
+            end
+            if (val = env(ref.to_s.upcase, suffix: 'OPTS'))
+              @output[4] = merge_opts(@output[4], shell_split(val, escape: false))
             end
-          end
-          if cmd != false && !cmd.is_a?(Array)
-            @output[cmd ? 1 : 3] = shell_split(val, escape: false, join: true) if (val = env('BUILD', suffix: 'OPTS'))
-            @output[4] = shell_split(val, escape: false, join: true) if !cmd && (val = env('SCRIPT', suffix: 'OPTS'))
           end
           @version = val if (val = env('BUILD', suffix: 'VERSION'))
           return unless (val = env('BUILD', strict: true))
@@ -255,18 +260,18 @@ module Squared
                 flags.each do |flag|
                   case action
                   when 'graph'
-                    break unless graph?
+                    next unless graph?
 
                     format_desc action, flag, '(-)project*'
                     task flag do |_, args|
-                      args = args.to_a.reject { |val| name == val.to_s }
+                      args = param_guard(action, flag, args: args.to_a.reject { |val| name == val.to_s })
                       if flag == :run
                         graph args
                       else
                         out, done = graph(args, out: [])
                         out.map! do |val|
                           done.each_with_index do |proj, i|
-                            next unless val =~ / #{Regexp.escape(proj.name)}(?:@\d|\z)/
+                            next unless val.match?(/ #{Regexp.escape(proj.name)}(?:@\d|\z)/)
 
                             val += " (#{i.succ})"
                             break
@@ -280,6 +285,25 @@ module Squared
                         ])
                       end
                     end
+                  when 'unpack'
+                    format_desc action, flag, 'tag/url,dir,digest?,f/force?'
+                    task flag, [:tag, :dir, :digest, :force] do |_, args|
+                      tag = param_guard(action, flag, args: args, key: :tag)
+                      dir = param_guard(action, flag, args: args, key: :dir)
+                      unless tag.match?(URI_SCHEME)
+                        raise_error 'no base uri' unless @release
+
+                        tag = "#{@release.include?('??') ? @release.sub('??', tag) : @release + tag}.#{flag}"
+                      end
+                      case (digest = args.digest)
+                      when 'f', 'force'
+                        digest = nil
+                        force = true
+                      else
+                        force = args.fetch(:force, false)
+                      end
+                      unpack(basepath(dir), uri: tag, digest: digest, ext: flag.to_s, force: force)
+                    end
                   end
                 end
               end
@@ -348,18 +372,19 @@ module Squared
 
           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)
+            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
 
-        def build(*args, sync: invoked_sync?('build'), from: :run, **)
+        def build(*args, sync: invoked_sync?('build'), from: @buildtype || :build, **)
           banner = verbose
           if args.empty?
-            return unless from == :run
+            return unless from == (@buildtype || :build)
 
+            run_b(@run, sync: sync, from: from) if series?(@run)
             args = @output
             banner = verbose == 1 if task_invoked?('build', 'build:sync')
           end
@@ -370,7 +395,7 @@ module Squared
               a, b, c, d, e = val
               case b
               when Hash
-                b = append_hash(b).join(' ')
+                b = append_hash(b, build: true).join(' ')
               when Enumerable
                 b = b.to_a.join(' ')
               end
@@ -386,7 +411,7 @@ module Squared
             end
             cmd = cmd.join(' && ')
           else
-            cmd, opts, var, flags, scr = args
+            cmd, opts, var, flags, extra = args
           end
           if cmd
             cmd = as_get(cmd)
@@ -394,7 +419,7 @@ module Squared
             flags = append_hash(flags).join(' ') if flags.is_a?(Hash)
             case opts
             when Hash
-              opts = append_hash(opts)
+              opts = append_hash(opts, build: true)
               cmd = as_a(cmd).push(flags).concat(opts).compact.join(' ')
             when Enumerable
               cmd = as_a(cmd).concat(opts.to_a)
@@ -404,10 +429,9 @@ module Squared
               cmd = [cmd, flags, opts].compact.join(' ') if opts || flags
             end
           else
-            return unless respond_to?(:compose)
+            return unless (opts || extra) && respond_to?(:compose)
 
-            cmd = compose(as_get(opts), flags, script: true, args: scr, from: from)
-            from = :script if from == :run && script?
+            cmd = compose(as_get(opts), flags, script: true, args: extra, from: from)
           end
           run(cmd, var, from: from, banner: banner, sync: sync)
         end
@@ -416,6 +440,12 @@ module Squared
           run_b(@depend, sync: sync, from: :depend)
         end
 
+        def archive(*, sync: invoked_sync?('archive'), **)
+          return unless @archive.is_a?(Array)
+
+          unpack(path, **@archive, sync: sync, from: :archive)
+        end
+
         def doc(*, sync: invoked_sync?('doc'), **)
           run_b(@doc, sync: sync, from: :doc)
         end
@@ -445,27 +475,31 @@ module Squared
             rescue StandardError => e
               log&.error e
               ret = on(:error, from, e)
-              raise if @exception && ret != true
+              raise if exception && ret != true
             end
-          when Enumerable
-            as_a(@clean).each do |val|
-              val = val.to_s
-              path = basepath(val)
-              if path.directory? && val =~ %r{[\\/]\z}
-                log&.warn "rm -rf #{path}"
-                FileUtils.rm_rf(path, verbose: verbose)
-              else
-                log&.warn "rm #{path}"
-                (val.include?('*') ? Dir[path] : [path]).each do |file|
-                  next unless File.file?(file)
-
-                  begin
-                    File.delete(file)
-                  rescue StandardError => e
-                    log&.error e
+          else
+            if @clean.is_a?(Enumerable) && !series?(@clean)
+              as_a(@clean).each do |val|
+                val = val.to_s
+                path = basepath(val)
+                if path.directory? && val.match?(%r{[\\/]$})
+                  log&.warn "rm -rf #{path}"
+                  path.rmtree(verbose: verbose)
+                else
+                  log&.warn "rm #{path}"
+                  (val.include?('*') ? Dir[path] : [path]).each do |file|
+                    next unless File.file?(file)
+
+                    begin
+                      File.delete(file)
+                    rescue StandardError => e
+                      log&.error e
+                    end
                   end
                 end
               end
+            else
+              run_b(@clean, sync: sync)
             end
           end
           on :last, :clean
@@ -502,6 +536,119 @@ module Squared
           end
         end
 
+        def unpack(target, sync: true, uri: nil, digest: nil, ext: nil, force: false, depth: 1, headers: {},
+                   from: :unpack)
+          if !target.exist?
+            target.mkpath
+          elsif !target.directory?
+            raise_error('invalid location', hint: target)
+          elsif !target.empty?
+            raise_error('directory not empty', hint: target) unless force || env('UNPACK_FORCE')
+            create = true
+          end
+          if digest
+            if (n = digest.index(':').to_i) > 0
+              size = digest[0, n].downcase
+              digest = digest[n + 1..-1]
+            else
+              size = digest.size
+            end
+            algo = case size
+                   when 32, 'md5'
+                     Digest::MD5
+                   when 'rmd160'
+                     Digest::RMD160
+                   when 40, 'sha1'
+                     Digest::SHA1
+                   when 64, 'sha256'
+                     Digest::SHA256
+                   when 96, 'sha384'
+                     Digest::SHA384
+                   when 128, 'sha512'
+                     Digest::SHA512
+                   else
+                     raise_error("invalid checksum: #{digest}", hint: name)
+                   end
+          end
+          if (val = env('HEADERS')) && (out = parse_json(val, hint: "HEADERS_#{@envname}"))
+            headers = out
+          end
+          require 'open-uri'
+          data = nil
+          (uri = as_a(uri)).each_with_index do |url, index|
+            last = index == uri.size - 1
+            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 last
+              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
+            end
+            if data
+              uri = url
+              break
+            elsif last
+              raise_error('no content', hint: url)
+            end
+          end
+          ext ||= URI.parse(uri).path[/^.+?\.((?:tar\.)?\w+)$/i, 1]
+          if (n = env("#{ext == 'zip' ? 'ZIP' : 'TAR'}_DEPTH", ignore: false))
+            depth = n.to_i
+          end
+          begin
+            require 'tempfile'
+            file = Tempfile.new("#{name}-")
+            file.write(data)
+            file.close
+            if create
+              warn log_message(Logger::WARN, name, 'force remove', hint: target, pass: true)
+              target.rmtree(verbose: true)
+              target.mkpath
+            end
+            case ext
+            when 'zip', 'aar'
+              session 'unzip', shell_quote(file.path), quote_option('d', target)
+            when 'tar', 'tgz', 'tar.gz', 'tar.xz'
+              flags = +(verbose ? 'v' : '')
+              case ext
+              when 'tgz', 'tar.gz'
+                flags += 'z'
+              when 'txz', 'tar.xz'
+                flags += 'J'
+              end
+              session 'tar', "-x#{flags}", basic_option('strip-components', depth), quote_option('f', file.path),
+                      quote_option('C', target)
+              depth = 0
+            else
+              raise_error("unsupported format: #{ext}", hint: uri)
+            end
+            run(sync: sync, from: from)
+            while depth > 0 && target.children.size == 1
+              entry = target.children.first
+              break unless entry.directory?
+
+              dest = target.join(File.basename(file.path))
+              FileUtils.mv(entry, dest)
+              dest.children.each { |file| FileUtils.mv(file, target) }
+              dest.rmdir
+              target = entry
+              depth -= 1
+            end
+          ensure
+            file&.unlink
+          end
+        end
+
         def first(key, *args, **kwargs, &blk)
           event(:first, key, *args, **kwargs, &blk)
         end
@@ -514,17 +661,38 @@ module Squared
           event(:error, key, *args, **kwargs, &blk)
         end
 
-        def event(name, key, *args, **kwargs, &blk)
-          (@events[name.to_sym] ||= {})[key.to_sym] = [block_given? ? [blk] + args : args, kwargs]
+        def event(name, key, *args, override: false, **kwargs, &blk)
+          data = @events[name.to_sym] ||= {}
+          items = if override
+                    data[key.to_sym] = []
+                  else
+                    data[key.to_sym] ||= []
+                  end
+          items << [block_given? ? [blk] + args : args, kwargs]
+          self
         end
 
         def as(cmd, script, to = nil)
           script = { "#{script}": to } if to
           data = (@as ||= {})[cmd.to_sym] ||= {}
           script.each { |key, val| data[key.to_s] = val }
+          self
+        end
+
+        def series(key, override: false, &blk)
+          if blocks.include?(key.to_sym) && block_given?
+            if !override && series?(target = instance_variable_get(:"@#{key}"))
+              target << blk
+            else
+              instance_variable_set :"@#{key}", [blk]
+            end
+          else
+            log&.warn "series: @#{key} (invalid)"
+          end
+          self
         end
 
-        def variable_set(key, *val, **kwargs)
+        def variable_set(key, *val, **kwargs, &blk)
           if variables.include?(key)
             case key
             when :build, :run
@@ -545,17 +713,22 @@ module Squared
             when :dependfile
               @dependfile = basepath(*val)
             else
-              instance_variable_set :"@#{key}", val.first
+              if blocks.include?(key) && block_given?
+                series key, &blk
+              else
+                instance_variable_set(:"@#{key}", block_given? && val.empty? ? blk : val.first)
+              end
             end
           else
             log&.warn "variable_set: @#{key} (private)"
           end
+          self
         end
 
         def enabled?(ref = nil, **)
           return false if ref && !ref?(ref)
 
-          path.directory? && !path.empty?
+          (path.directory? && !path.empty?) || archive?
         end
 
         def has?(meth, ref = nil)
@@ -569,7 +742,7 @@ module Squared
         end
 
         def build?
-          !!@output[0] || script?
+          !!@output[0] || script? || series?(@run)
         end
 
         def script?
@@ -580,6 +753,10 @@ module Squared
           !!@depend
         end
 
+        def archive?
+          @archive.is_a?(Hash) && (!path.exist? || path.empty?)
+        end
+
         def graph?
           @graph.is_a?(Array) && !@graph.empty?
         end
@@ -640,8 +817,12 @@ module Squared
           @ref.reverse_each
         end
 
-        def basepath(*args, ascend: nil)
-          ret = path.join(*args)
+        def basepath(*args)
+          path.join(*args)
+        end
+
+        def rootpath(*args, ascend: nil)
+          ret = basepath(*args)
           return ret unless ascend && !ret.exist?
 
           path.parent.ascend.each do |dir|
@@ -676,8 +857,10 @@ module Squared
 
         def run(cmd = @session, var = nil, exception: @exception, sync: true, banner: true, chdir: path, from: nil, **)
           unless cmd
-            from &&= from.to_s
-            warn log_message(Logger::WARN, from || 'unknown', subject: project, hint: 'no command given')
+            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 = session_done(cmd)
@@ -688,7 +871,7 @@ module Squared
               log&.warn "ENV was discarded: #{var}" if var
               task_invoke(cmd, exception: exception, warning: warning?)
             else
-              print_item format_banner(cmd, banner: banner) if sync && !env('BANNER', equals: '0')
+              print_item format_banner(cmd, banner: banner) if sync
               args = var.is_a?(Hash) ? [var, cmd] : [cmd]
               shell(*args, chdir: chdir, exception: exception)
             end
@@ -713,18 +896,23 @@ module Squared
         end
 
         def run_b(obj, from: nil, sync: true)
-          return unless obj
-
-          if obj.is_a?(Array) && obj.any? { |val| !val.is_a?(String) }
-            build(*obj, from: from, sync: sync)
+          case obj
+          when Proc, Method
+            obj.call
           else
-            run_s(obj.is_a?(Enumerable) ? obj.to_a : obj, from: from, sync: sync)
+            if series?(obj)
+              obj.each(&:call)
+            elsif obj.is_a?(Array) && obj.any? { |val| !val.is_a?(String) }
+              build(*obj, from: from, sync: sync)
+            elsif obj
+              run_s(obj.is_a?(Enumerable) ? obj.to_a : obj, from: from, sync: sync)
+            end
           end
         end
 
         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 =~ proj.version ? "@#{proj.version}" : ''}" }
+          tag = ->(proj) { "#{proj.name}#{SEM_VER.match?(proj.version) ? "@#{proj.version}" : ''}" }
           check = ->(deps) { deps.reject { |val| done.include?(val) } }
           dedupe = lambda do |name|
             next [] unless (ret = data[name])
@@ -764,7 +952,7 @@ module Squared
 
             t = dedupe.(proj.name)
             j = if out
-                  if i == items.size - 1 || check.(post = items[(i + 1)..-1]).empty?
+                  if i == items.size - 1 || check.(post = items[i + 1..-1]).empty?
                     true
                   elsif !t.empty? && depth > 0
                     post.reject { |pr| t.include?(pr) }.empty?
@@ -782,13 +970,7 @@ module Squared
                 next if pass.include?(meth)
 
                 if workspace.task_defined?(cmd = task_join(proj.name, meth))
-                  if ENV.key?(key = "BANNER_#{proj.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 || group ? nil : workspace.baseref)
                   proj.__send__(meth.to_sym, sync: sync)
                 end
@@ -802,7 +984,7 @@ module Squared
                        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 - 1) || single)
                          s += "#{indent || (last && data[final].last == context) ? ' ' : a}   "
                          k += 1
                        end
@@ -814,7 +996,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)
@@ -826,21 +1008,18 @@ 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)
+              deps += objs
             end
           end
-          deps.uniq!
-          deps.delete(target)
-          data[target.name] = deps
+          data[target.name] = deps.uniq.reject { |proj| proj == target }
           data
         end
 
@@ -860,7 +1039,7 @@ module Squared
         end
 
         def session(*cmd, prefix: cmd.first, main: true, options: true)
-          prefix = stripext(prefix.to_s).upcase
+          prefix = prefix.to_s.upcase
           if (val = PATH[prefix] || PATH[prefix.to_sym])
             cmd[0] = shell_quote(val, force: false)
           end
@@ -874,8 +1053,7 @@ module Squared
         def session_delete(*list, target: @session)
           ret = []
           list.each do |val|
-            pat = /^#{Regexp.escape(shell_option(val))}(?: |=|$)/
-            if (key = target.find { |opt| opt =~ pat })
+            if (key = target.find { |opt| opt.match?(/^#{Regexp.escape(shell_option(val))}(?: |=|$)/o) })
               target.delete(key)
               ret << key
             end
@@ -890,30 +1068,33 @@ module Squared
         def session_done(cmd)
           return cmd unless cmd.respond_to?(:done)
 
-          raise_error('no args were added', hint: cmd.first || name) unless cmd.size > 1
+          raise_error('no args added', hint: cmd.first || name) unless cmd.size > 1
           @session = nil if cmd == @session
           cmd.done
         end
 
-        def option(*args, target: @session, prefix: target&.first, **kwargs)
+        def option(*args, prefix: @session&.first, **kwargs)
           if prefix
             args.each do |val|
-              ret = env("#{stripext(prefix)}_#{val.gsub(/\W/, '_')}".upcase, **kwargs)
+              ret = env("#{prefix}_#{val.gsub(/\W/, '_')}".upcase, **kwargs)
               return ret if ret
             end
           end
           nil
         end
 
-        def option_sanitize(opts, list, target: @session, no: nil, args: false, first: false, pass: ['='])
+        def option_sanitize(opts, list, target: @session, no: nil, first: false, pass: ['='])
           ret = []
           reg = []
           bare = []
           e = []
           b = []
+          m = []
           p = []
           q = []
+          qq = []
           i = []
+          f = []
           list = list.map do |val|
             x, y = val.split('|')
             if y
@@ -933,16 +1114,19 @@ module Squared
                 e << flag
               when 'b'
                 b << flag
+              when 'm'
+                m << flag
               when 'q'
+                qq << flag if val[n + 2] == 'q'
                 q << flag
               when 'p'
                 p << flag
               when 'i'
                 i << flag
-              when 'v'
-                reg << Regexp.escape(flag)
+              when 'f'
+                f << flag
               else
-                next
+                reg << Regexp.escape(flag)
               end
               bare << flag if val.end_with?('?')
             else
@@ -960,40 +1144,41 @@ module Squared
             elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
               target << "--no-#{name}"
             else
-              if opt =~ /\A([^=]+)=(.+)\z/
-                a = $1
-                if e.include?(a)
-                  target << shell_option(a, $2)
-                elsif q.include?(a)
-                  target << quote_option(a, $2)
-                elsif p.include?(a)
-                  target << quote_option(a, basepath($2))
-                elsif b.include?(a) || (i.include?(a) && /^\d+$/.match?($2))
-                  target << basic_option(a, $2)
+              if opt =~ /^([^=]+)=(.+)$/
+                key = $1
+                val = $2
+                match = ->(flag, pat) { flag.include?(key) && pat.match?(val) }
+                if e.include?(key)
+                  target << shell_option(key, val)
+                elsif q.include?(key)
+                  target << quote_option(key, val, double: qq.include?(key))
+                elsif p.include?(key)
+                  target << quote_option(key, basepath(val))
+                elsif m.include?(key)
+                  target << basic_option(key, val, merge: true)
+                elsif b.include?(key) || match.(i, /^\d+$/) || match.(f, /^\d*(?:\.\d+)?$/)
+                  target << basic_option(key, val)
                 else
                   ret << opt
                 end
-                opt = a
+                opt = key
               else
                 ret << opt
-                found = true if args
               end
-              found = true if first && pass.none? { |val| opt.include?(val) }
+              found = true if first && pass.none? { |s| opt.include?(s) }
             end
           end
-          [ret, reg.empty? ? /\A\s+\z/ : /\A(#{reg.join('|')})=(.+)\z/]
+          [ret, reg.empty? ? /\A\s+\z/ : /^(#{reg.join('|')})=(.+)$/]
         end
 
         def option_clear(opts, target: @session, **kwargs)
-          return if opts.empty?
-
           kwargs[:subject] ||= target&.first
-          kwargs[:hint] ||= 'unrecognized'
-          warn log_message(:warn, opts.join(', '), **kwargs)
+          kwargs[:hint] ||= 'not used'
+          warn log_message(Logger::WARN, opts.join(', '), pass: true, **kwargs) unless opts.empty?
         end
 
         def print_item(*val)
-          puts if @@print_order > 0
+          puts if @@print_order > 0 && verbose && !stdin?
           @@print_order += 1
           puts val unless val.empty? || (val.size == 1 && val.first.nil?)
         end
@@ -1019,7 +1204,7 @@ module Squared
               val
             end
           end
-          out << sub_style('-' * n, styles: border)
+          out << sub_style(ARG[:BORDER][1] * n, styles: border)
           out.join("\n")
         end
 
@@ -1031,7 +1216,7 @@ module Squared
             sub.each { |h| s = sub_style(s, **h) }
             s
           end
-          ret = [sub_style('-' * n, styles: kwargs.key?(:border) ? kwargs[:border] : borderstyle), *lines]
+          ret = [sub_style(ARG[:BORDER][1] * n, styles: kwargs.key?(:border) ? kwargs[:border] : borderstyle), *lines]
           ret.reverse! if reverse
           ret.join("\n")
         end
@@ -1057,7 +1242,7 @@ module Squared
           if verbose
             out = []
             if data[:command]
-              if /\A(?:"((?:[^"]|(?<=\\)")+)"|'((?:[^']|(?<=\\)')+)'|(\S+)) /.match(cmd)
+              if cmd =~ /\A(?:"((?:[^"]|(?<=\\)")+)"|'((?:[^']|(?<=\\)')+)'|(\S+)) /
                 path = $3 || $2 || $1
                 cmd = cmd.sub(path, File.basename(path).upcase)
               end
@@ -1095,9 +1280,9 @@ module Squared
           unless items.empty?
             pad = items.size.to_s.size
             items.each_with_index do |val, i|
-              next unless reg.empty? || reg.any? { |pat| val[0] =~ pat }
+              next unless reg.empty? || reg.any? { |pat| val[0].match?(pat) }
 
-              out << "#{(i + 1).to_s.rjust(pad)}. #{each ? each.(val) : val[0]}"
+              out << "#{i.succ.to_s.rjust(pad)}. #{each ? each.(val) : val[0]}"
             end
           end
           sub = [headerstyle]
@@ -1131,9 +1316,9 @@ module Squared
           opts.each { |val| target << shell_option(flag, val) }
         end
 
-        def append_hash(data, target: @session)
+        def append_hash(data, target: @session, build: false)
           target ||= []
-          if (type = env('BUILD', suffix: 'TYPE') || ENV['BUILD_TYPE'])
+          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)
@@ -1162,7 +1347,7 @@ module Squared
           target
         end
 
-        def append_any(val, target: @session, delim: false)
+        def append_any(val, target: @session, build: false, delim: false)
           if delim && !target.include?('--')
             target << '--'
           else
@@ -1172,7 +1357,7 @@ module Squared
           when String
             target << val
           when Hash
-            append_hash(val, target: target)
+            append_hash(val, target: target, build: build)
           when Enumerable
             if target.is_a?(Array)
               target.concat(val.to_a)
@@ -1181,6 +1366,7 @@ module Squared
             end
           else
             target.delete('--') if delim
+            nil
           end
         end
 
@@ -1189,8 +1375,9 @@ module Squared
 
           target << '--' if delim && !target.include?('--')
           list.map do |val|
-            target << (val = escape ? shell_escape(val, quote: quote) : shell_quote(val))
-            val
+            item = escape ? shell_escape(val, quote: quote) : shell_quote(val)
+            target << item
+            item
           end
         end
 
@@ -1198,8 +1385,8 @@ module Squared
                          **kwargs)
           return if (list = list.flatten).empty?
 
-          list.flatten.each do |opt|
-            next unless (val = option(opt, target: target, **kwargs))
+          list.each do |opt|
+            next unless (val = option(opt, **kwargs))
 
             return target << (if flag
                                 shell_option(opt, equals ? val : nil, quote: quote, escape: escape, force: force)
@@ -1215,7 +1402,7 @@ module Squared
           return if (list = list.flatten).empty?
 
           ret = []
-          list.flatten.each do |flag|
+          list.each do |flag|
             next unless (val = option(flag, **kwargs))
 
             if val == '0' && no
@@ -1228,7 +1415,45 @@ module Squared
         end
 
         def append_nocolor(target: @session)
-          target << '--no-color' if !ARG[:COLOR] || stdin? || option('no-color', target: target, ignore: false)
+          target << '--no-color' if !ARG[:COLOR] || stdin? || option('no-color', ignore: false)
+        end
+
+        def merge_opts(base, data)
+          return data unless base
+          return base unless data
+
+          ret = case data
+                when String
+                  case base
+                  when String
+                    "#{base} #{data}"
+                  when Hash
+                    "#{append_hash(base).join(' ')} #{data}"
+                  when Enumerable
+                    "#{base.to_a.join(' ')} #{data}"
+                  end
+                when Hash
+                  case base
+                  when String
+                    "#{base} #{append_hash(data).join(' ')}"
+                  when Hash
+                    base.merge(data)
+                  when Enumerable
+                    base.to_a + append_hash(data)
+                  end
+                when Enumerable
+                  case base
+                  when String
+                    "#{base} #{data.to_a.join(' ')}"
+                  when Hash
+                    "#{append_hash(base).join(' ')} #{data.to_a.join(' ')}"
+                  when Enumerable
+                    base.to_a + data.to_a
+                  end
+                else
+                  base
+                end
+          ret || data
         end
 
         def collect_hash(data, pass: [])
@@ -1237,10 +1462,19 @@ module Squared
           ret
         end
 
-        def param_guard(action, flag, args: nil, key: nil, pat: nil)
+        def parse_json(val, hint: nil)
+          ret = JSON.parse(val)
+          raise_error('invalid JSON object', val, hint: hint) unless ret.is_a?(Hash)
+        rescue StandardError => e
+          log&.warn e
+        else
+          ret
+        end
+
+        def param_guard(action, flag, args: nil, key: nil, pat: nil, values: nil)
           if args && key
-            val = args.fetch(key, nil)
-            return val unless val.nil? || (pat && !val.match?(pat))
+            val = args[key]
+            return val unless val.nil? || (pat && !val.match?(pat)) || (values && !values.include?(val))
 
             @session = nil
             raise_error(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
@@ -1251,6 +1485,17 @@ module Squared
           args
         end
 
+        def relativepath(*files, all: false)
+          return [] if files.empty?
+
+          files.flatten.map { |val| Pathname.new(val) }.select { |val| projectpath?(val) }.map do |val|
+            val = val.absolute? ? val.to_s.sub(/^#{Regexp.escape(File.join(path, ''))}/o, '') : val.to_s
+            val = val[2..-1] if val.start_with?('./')
+            val = "#{val}*" if all && val.end_with?('/')
+            val
+          end
+        end
+
         def projectmap(files, parent: false)
           files = files.select { |val| projectpath?(val) } unless parent
           files.map { |val| val == '.' ? '.' : shell_quote(basepath(val.strip)) }
@@ -1273,41 +1518,16 @@ module Squared
           fill ? semver(ret) : ret
         end
 
-        def semcmp(val, other)
-          return 0 if val == other
-
-          a, b = [val, other].map! { |ver| ver.scan(SEM_VER) }
-          return -1 if b.empty?
-          return 1 if a.empty?
-
-          a, b = [a.first, b.first].map! do |c|
-            begin
-              d = Integer(c[5]).to_s
-            rescue StandardError
-              d = c[5] ? '-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 indexitem(val)
-          [$1.to_i, $2 && $2[1..-1]] if val =~ /\A#{Regexp.escape(indexchar)}(\d+)(:.+)?\z/
+          return unless val =~ /\A\^(\d+)(:.+)?\z/
+
+          [$1.to_i, $2 && $2[1..-1]]
         end
 
         def indexerror(val, list = nil)
           raise_error("requested index #{val}", hint: list && "of #{list.size}")
         end
 
-        def indexchar
-          workspace.windows? ? '+' : '^'
-        end
-
         def color(val)
           ret = theme[val]
           ret && !ret.empty? ? ret : [val]
@@ -1317,22 +1537,28 @@ module Squared
           val.compact.map { |s| color(s) }.flatten
         end
 
+        def epochtime
+          DateTime.now.strftime('%Q').to_i
+        end
+
         def on(event, from, *args, **kwargs)
-          return unless from && (obj = @events[event][from])
+          return unless from
 
-          if obj.is_a?(Array) && obj[1].is_a?(Hash)
-            opts = kwargs.empty? ? obj[1] : obj[1].merge(kwargs)
-            target = obj[0]
-          else
-            opts = kwargs
-            target = obj
-          end
-          as_a(target, flat: true).each do |cmd|
-            case cmd
-            when Proc, Method
-              cmd.call(*args, **opts)
-            when String
-              run(cmd, **opts)
+          @events[event][from]&.each do |obj|
+            if obj.is_a?(Array) && obj[1].is_a?(Hash)
+              opts = kwargs.empty? ? obj[1] : obj[1].merge(kwargs)
+              target = obj[0]
+            else
+              opts = kwargs
+              target = obj
+            end
+            as_a(target, flat: true).each do |cmd|
+              case cmd
+              when Proc, Method
+                cmd.call(*args, **opts)
+              when String
+                run(cmd, **opts)
+              end
             end
           end
         end
@@ -1341,8 +1567,7 @@ module Squared
           pwd = Pathname.pwd
           if block_given?
             begin
-              pass = semscan(pass).join <= RUBY_VERSION if pass.is_a?(String)
-              if (path == pwd || pass == true) && !workspace.jruby_win?
+              if path == pwd || pass == true || (pass.is_a?(String) && semscan(pass).join >= RUBY_VERSION)
                 ret = instance_eval(&blk)
               else
                 Dir.chdir(path)
@@ -1374,23 +1599,53 @@ module Squared
         end
 
         def run_set(cmd, val = nil, opts: nil, **)
-          return @output = cmd.dup if cmd.is_a?(Array)
-
-          unless @output[1] == false && !@output[0].nil?
+          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 diso
+              ret[3] = data[:args]
+            elsif data[:script]
+              ret[1] = data[:script]
+              ret[3] = data[:opts]
+              ret[4] = data[:args]
+            else
+              ret[0] = false
+            end
+            ret[2] = data[:env] unless dise
+            ret
+          end
+          case cmd
+          when Array
+            @output = if cmd.all? { |data| data.is_a?(Hash) }
+                        diso = false
+                        dise = false
+                        cmd.map { |data| parse.(data) }
+                      else
+                        cmd.dup
+                      end
+            return
+          when Hash
+            @output = parse.(data)
+          else
+            @output[0] = cmd
+          end
+          unless diso
             if opts == false
               @output[1] = false
             elsif opts && opts != true
               @output[1] = opts
             end
           end
-          unless @output[2] == false
-            if val.is_a?(Hash)
-              @output[2] = val
-            elsif val == false
-              @output[2] = false
-            end
+          return if dise
+
+          if val.is_a?(Hash)
+            @output[2] = val
+          elsif val == false
+            @output[2] = false
           end
-          @output[0] = cmd
         end
 
         def script_set(cmd, prod: nil, args: nil, **)
@@ -1406,6 +1661,8 @@ module Squared
         end
 
         def as_get(val)
+          return unless val
+
           @global && (ret = @as && @as[from] && @as[from][val]) ? ret : val
         end
 
@@ -1431,8 +1688,7 @@ module Squared
         end
 
         def projectpath?(val)
-          val = Pathname.new(val).cleanpath
-          val.absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.start_with?(File.join('..', ''))
+          Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.start_with?('..')
         end
 
         def semmajor?(cur, want)
@@ -1441,19 +1697,20 @@ module Squared
 
         def runnable?(val)
           case val
-          when String
+          when String, Enumerable, Proc, Method
             true
-          when Enumerable
-            !val.is_a?(Hash)
           else
             false
           end
         end
 
+        def series?(val)
+          val.is_a?(Array) && val.all? { |p| p.is_a?(Proc) || p.is_a?(Method) }
+        end
+
         def session_arg?(*list, target: @session, value: false)
           list.any? do |val|
-            pat = /^#{Regexp.escape(shell_option(val))}#{value ? '[ =].' : '(?:[ =]|$)'}/
-            target.any? { |opt| opt =~ pat }
+            target.any? { |opt| opt.match?(/^#{Regexp.escape(shell_option(val))}#{value ? '[ =].' : '(?:[ =]|$)'}/o) }
           end
         end
 
@@ -1490,6 +1747,10 @@ module Squared
           Base.tasks + VAR_SET
         end
 
+        def blocks
+          BLK_SET
+        end
+
         def borderstyle
           ((data = workspace.banner_get(*@ref, group: group)) && data[:border]) || theme[:border]
         end