squared 0.0.9 → 0.0.11

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'date'
 require 'logger'
 
@@ -12,12 +13,18 @@ module Squared
         include System
         include Shell
         include Task
+        include Utils
         include ::Rake::DSL
 
-        SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+))?/.freeze
+        SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?/.freeze
+
+        VAR_SET = %i[parent global envname theme run script env depend doc test copy clean].freeze
+        private_constant :VAR_SET
 
         class << self
           def populate(*); end
+          def batchargs(*); end
+          def aliasargs(*); end
 
           def tasks
             [].freeze
@@ -39,42 +46,106 @@ module Squared
           def to_s
             super.to_s.match(/[^:]+$/)[0]
           end
+
+          def config?(*)
+            false
+          end
         end
 
         @@print_order = 0
         @@tasks = {}
 
-        attr_reader :name, :project, :workspace, :group, :path, :theme
+        attr_reader :name, :project, :workspace, :path, :exception, :pipe, :verbose, :theme, :group, :parent
 
-        def initialize(name, path, workspace, *, group: nil, **kwargs)
-          @name = name.to_s
+        def initialize(workspace, path, name, *, group: nil, pass: nil, exclude: nil, common: ARG[:COMMON], **kwargs)
           @path = path
-          @project = @path.basename.to_s
           @workspace = workspace
-          @group = group&.to_s
+          @name = name.to_s.freeze
+          @project = @path.basename.to_s.freeze
+          @group = group&.to_s.freeze
           @depend = kwargs[:depend]
           @doc = kwargs[:doc]
           @test = kwargs[:test]
-          @output = [kwargs[:run], nil]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
-          @theme = if !workspace.verbose
+          @exception = kwargs.key?(:exception) ? env_bool(kwargs[:exception]) : workspace.exception
+          @pipe = kwargs.key?(:pipe) ? env_pipe(kwargs[:pipe]) : workspace.pipe
+          @verbose = kwargs.key?(:verbose) ? kwargs[:verbose] : workspace.verbose
+          @theme = if !@verbose
                      {}
-                   elsif kwargs.fetch(:common, true)
+                   elsif common
                      workspace.theme
                    else
                      __get__(:theme)[:project][to_sym] ||= {}
                    end
+          @output = []
           @ref = []
-          @exclude = as_a(kwargs[:exclude], :to_sym).freeze
+          @children = []
+          @pass = (pass ? as_a(pass, :to_sym) : []).freeze
+          @exclude = (exclude ? as_a(exclude, :to_sym) : []).freeze
+          @envname = @name.gsub(/[^\w]+/, '_').upcase.freeze
+          @desc = (@name.include?(':') ? @name.split(':').join(ARG[:SPACE]) : @name).freeze
+          @parent = nil
+          @global = false
+          run_set(kwargs[:run], kwargs[:env], opts: kwargs.fetch(:opts, true))
           initialize_ref(Base.ref)
+        end
+
+        def initialize_ref(ref)
+          @ref << ref unless @exclude.include?(ref)
+        end
+
+        def initialize_build(ref, **kwargs)
+          initialize_ref(ref)
+          if (@script = @workspace.script_get(group: @group, ref: ref))
+            if @script[:log] && !kwargs.key?(:log)
+              kwargs[:log] = @script[:log]
+              @log = nil
+            end
+            @depend = @script[:depend] if @depend.nil?
+            @doc = @script[:doc] if @doc.nil?
+            @test = @script[:test] if @test.nil?
+            @clean = @script[:clean] if @clean.nil?
+            @exclude = @script[:exclude] if @exclude.empty? && @script.key?(:exclude)
+          end
           initialize_logger(**kwargs)
+          return if @output[0] == false
+
+          data = @workspace.script_find(*@ref, @group)
+          if @output[0].nil?
+            if (scr = data[:script])
+              @global = true
+              script_set(scr, prod: kwargs[:prod])
+            elsif (run = data[:run])
+              @global = true
+              run_set run
+            end
+            unless data[:env]
+              if (scr = kwargs[:script])
+                @global = false
+                script_set scr
+              elsif @script && !data[:global]
+                if (scr = @script[:script])
+                  @global = false
+                  script_set scr
+                elsif (run = @script[:run])
+                  @global = false
+                  run_set run
+                end
+              end
+            end
+          elsif data[:env] && data[:run]
+            @global = true
+            run_set data[:run]
+          end
         end
 
         def initialize_logger(log: nil, **)
+          return if @log
+
           log = log.is_a?(::Hash) ? log.dup : { file: log }
-          if (file = env('LOG_FILE')).nil? && (auto = env('LOG_AUTO'))
-            file = case auto
+          unless (file = env('LOG_FILE'))
+            file = case env('LOG_AUTO')
                    when 'y', 'year'
                      "#{@name}-#{Date.today.year}.log"
                    when 'm', 'month'
@@ -85,53 +156,51 @@ module Squared
           end
           if file ||= log[:file]
             file = Date.today.strftime(file)
-            file = (dir = env('LOG_DIR')) ? Pathname.new(dir).join(file) : Pathname.new(file)
+            file = (dir = env('LOG_DIR')) ? @workspace.home.join(dir, file) : @workspace.home.join(file)
             begin
               file = file.realdirpath
             rescue StandardError => e
-              raise if @workspace.exception
+              raise if @exception
 
               file = nil
-              warn e if @workspace.warning
+              warn log_message(::Logger::WARN, e) if warning?
             end
           end
-          log[:progname] = @name
-          log[:level] = env('LOG_LEVEL', log[:level] || Logger::INFO, ignore: nil)
+          log[:progname] ||= @name
+          if (val = env('LOG_LEVEL', ignore: false))
+            log[:level] = val
+          end
           log.delete(:file)
           @log = [file, log]
         end
 
-        def initialize_build(ref, **kwargs)
-          initialize_script(ref, **kwargs)
-          if (val = env('BUILD', strict: true))
-            @output[0] = val
-          elsif @script && @output[0] != false
-            @output[0] ||= @script[:run]
+        def initialize_env(dev: nil, prod: nil, **)
+          pre = "BUILD_#{@envname}"
+          @dev = env_match("#{pre}_DEV", dev)
+          @prod = env_match("#{pre}_PROD", prod)
+          cmd = @output[0]
+          unless cmd == false || cmd.is_a?(::Array) || (val = env('BUILD', suffix: 'OPTS')).nil?
+            @output[cmd ? 1 : 3] = shell_split(val, join: true)
           end
-          @dev = kwargs.delete(:dev)
-          if env('BUILD', suffix: 'DEV', equals: '0')
-            @dev = false
-          elsif env('BUILD', suffix: 'DEV')
-            @dev = true
-          elsif @dev.nil?
-            @dev = !group.nil? && workspace.dev?(group: group, global: true)
+          unless @output[2] == false || (val = env('BUILD', suffix: 'ENV')).nil?
+            begin
+              data = JSON.parse(val)
+              raise_error('invalid JSON object', val, hint: "#{prefix}_ENV") unless data.is_a?(::Hash)
+              @output[2] = data
+            rescue StandardError => e
+              log.warn e
+            end
           end
-        end
-
-        def initialize_script(ref, **)
-          initialize_ref(ref)
-          return unless (script = workspace.script(group: group, ref: ref))
-
-          @depend = script[:depend] if @depend.nil?
-          @doc = script[:doc] if @doc.nil?
-          @test = script[:test] if @test.nil?
-          @clean = script[:clean] if @clean.nil?
-          @exclude = script[:exclude] if @exclude.empty? && script.key?(:exclude)
-          @script = script
-        end
+          return unless (val = env('BUILD', strict: true))
 
-        def initialize_ref(ref)
-          @ref << ref unless @exclude.include?(ref)
+          @global = false
+          if val == '0'
+            @output = [false]
+          elsif script?
+            script_set val
+          else
+            run_set val
+          end
         end
 
         def ref
@@ -139,80 +208,114 @@ module Squared
         end
 
         def populate(*)
-          valid = ref?(Base.ref)
-          series = workspace.series
-
           namespace name do
-            series.each_key do |key|
-              next unless series.include?(key) ? has?(key) && valid : workspace.task_extend?(self, key)
-
-              desc message(*name.split(':'), key)
-              task key do
-                __send__(key)
+            workspace.series.each_key do |key|
+              next unless workspace.task_include?(self, key)
+
+              alt = workspace.series.name_get(key)
+              unless workspace.task_defined?(name, alt)
+                desc message(@desc, alt)
+                task alt do
+                  __send__(key)
+                end
               end
+              next if (items = @children.select { |item| workspace.task_include?(item, key) }).empty?
+
+              desc message(@desc, alt, 'workspace')
+              task task_join(alt, 'workspace') => items.map { |item| task_join(item.name, alt) }
             end
           end
         end
 
-        def build(*args, sync: true)
+        def with(**kwargs, &blk)
+          @withargs = kwargs.empty? ? nil : kwargs
+          if block_given?
+            instance_eval(&blk)
+            @withargs = nil
+          end
+          self
+        end
+
+        def add(path, name = nil, **kwargs, &blk)
+          if path.is_a?(::String) && (data = %r{^(.+)[\\/]\*+$}.match(path))
+            path = base_path(data[1]).children.select(&:directory?)
+          end
+          if path.is_a?(::Array)
+            name = @name if name == true
+            path.each { |val| add(val, name && task_join(name, File.basename(val)), **kwargs, &blk) }
+            return self
+          elsif !source_path?(path = base_path(path))
+            return self
+          elsif !name.is_a?(::String) && !name.is_a?(::Symbol)
+            name = nil
+          end
+          if @withargs
+            data = @withargs.dup
+            data.merge!(kwargs)
+            kwargs = data
+          end
+          kwargs[:group] = group unless kwargs.key?(:group)
+          kwargs[:ref] = ref unless kwargs.key?(:ref)
+          parent = self
+          proj = nil
+          workspace.add(path, name || path.basename, **kwargs) do
+            variable_set :parent, parent
+            proj = self
+          end
+          @children << proj
+          proj.instance_eval(&blk) if block_given?
+          self
+        end
+
+        def build(*args, sync: invoked_sync?('build'), **)
           if args.empty?
-            cmd, opts = @output
-            opts &&= shell_escape(opts)
+            cmd, opts, var, flags = @output
+            banner = verbose == 1
           else
             cmd = args.shift
-            opts = sanitize_args(*args)
+            opts = args.map { |val| shell_quote(val, force: false) }.join(' ')
+            banner = verbose
           end
           if cmd
-            if opts
+            case opts
+            when ::String
               cmd = "#{cmd} #{opts}"
-            elsif cmd.is_a?(::Array)
+            when ::Array
               cmd = cmd.join(' && ')
+            else
+              cmd = [cmd, compose(opts, script: false)].compact.join(' ') unless opts == false || !respond_to?(:compose)
             end
-            banner = verbose?
           else
             return unless respond_to?(:compose)
 
-            cmd = compose(opts)
-            banner = env('REPO_BUILD') == 'verbose'
-          end
-          run(cmd, banner: banner, sync: sync)
-        end
-
-        def refresh(*)
-          build(sync: invoked_sync?('depend'))
-          key = "#{name}:copy"
-          if workspace.task_defined?(key)
-            invoke(key, exception: workspace.exception, warning: workspace.warning)
-          else
-            copy
+            cmd = compose(opts, flags, script: true)
           end
+          run(cmd, var, banner: banner, sync: sync)
         end
 
-        def depend(*)
-          run(@depend, sync: invoked_sync?('depend')) if @depend
+        def depend(*, sync: invoked_sync?('depend'), **)
+          run(@depend, sync: sync) if @depend
         end
 
-        def copy(*)
-          run_s(@copy, sync: invoked_sync?('copy')) if @copy
+        def copy(*, sync: invoked_sync?('copy'), **)
+          run_s(@copy, sync: sync) if @copy
         end
 
-        def doc
-          build(@doc, sync: invoked_sync?('doc')) if @doc
+        def doc(*, sync: invoked_sync?('doc'), **)
+          build(@doc, sync: sync) if @doc
         end
 
-        def test
-          build(@test, sync: invoked_sync?('test')) if @test
+        def test(*, sync: invoked_sync?('test'), **)
+          build(@test, sync: sync) if @test
         end
 
-        def clean
-          return unless @clean
-
-          if @clean.is_a?(::String)
+        def clean(*)
+          case @clean
+          when ::String
             run_s(@clean, sync: invoked_sync?('clean'))
-          else
-            @clean.each do |val|
-              val = val.to_s
-              if val =~ %r{[\\/]$}
+          when ::Enumerable
+            as_a(@clean).each do |val|
+              if (val = val.to_s) =~ %r{[\\/]$}
                 dir = Pathname.new(val)
                 dir = base_path(dir) unless dir.absolute?
                 next unless dir.directory?
@@ -239,10 +342,52 @@ module Squared
           @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
         end
 
-        def base_path(*args)
-          path.join(*args)
+        def base_path(*args, ascend: nil)
+          ret = path.join(*args)
+          return ret unless ascend && !ret.exist?
+
+          path.parent.ascend.each do |dir|
+            target = dir.join(*args)
+            return target if target.exist?
+            break if (ascend.is_a?(String) && dir.join(ascend).exist?) || workspace.root == dir || parent&.path == dir
+          end
+          ret
         end
 
+        def color(val)
+          ret = theme[val]
+          ret && !ret.empty? ? ret : [val]
+        end
+
+        def variable_set(key, *val, **kwargs)
+          if variables.include?(key)
+            case key
+            when :run
+              run_set(*val, **kwargs)
+            when :script
+              script_set(*val, **kwargs)
+            when :env
+              run_set(output[0], *val, **kwargs)
+            when :parent
+              @parent = val if (val = val.first).is_a?(Project::Base)
+            else
+              instance_variable_set :"@#{key}", val.first
+            end
+          else
+            log.warn "variable_set: @#{key} (private)"
+          end
+        end
+
+        def variables
+          VAR_SET
+        end
+
+        def allref
+          @ref.reverse_each
+        end
+
+        def version(*); end
+
         def inspect
           "#<#{self.class}: #{name} => #{self}>"
         end
@@ -255,12 +400,16 @@ module Squared
           name.to_sym
         end
 
-        def enabled?
+        def enabled?(ref = nil)
+          return false if ref && !ref?(ref)
+
           path.directory? && !path.empty?
         end
 
-        def has?(method)
-          respond_to?(m = :"#{method}?") && __send__(m)
+        def has?(meth, ref = nil)
+          return false if ref && !ref?(ref)
+
+          respond_to?(meth = :"#{meth}?") && __send__(meth)
         end
 
         def ref?(val)
@@ -268,15 +417,19 @@ module Squared
         end
 
         def build?
-          !!@output[0]
+          !!@output[0] || script?
         end
 
-        def refresh?
-          build? && (copy? || workspace.task_defined?("#{name}:copy"))
+        def script?
+          @output[0].nil? && !!@output[1] && respond_to?(:compose)
         end
 
         def depend?
-          @depend != false && (!@depend.nil? || has?('outdated'))
+          !!@depend
+        end
+
+        def copy?
+          runnable?(@copy) || workspace.task_defined?(name, 'copy')
         end
 
         def doc?
@@ -287,34 +440,40 @@ module Squared
           !!@test
         end
 
-        def copy?
-          @copy.is_a?(::String)
-        end
-
         def clean?
-          !!@clean
+          runnable?(@clean) || workspace.task_defined?(name, 'clean')
         end
 
         def dev?
-          !!@dev
+          @dev != false && workspace.dev?(pat: @dev, **scriptargs)
+        end
+
+        def prod?
+          @prod != false && workspace.prod?(pat: @prod, **scriptargs)
         end
 
         private
 
-        def run(cmd = @session, exception: workspace.exception, banner: true, sync: true, req: nil, **)
+        def puts(*args)
+          puts_oe(*args, pipe: pipe)
+        end
+
+        def run(cmd = @session, var = nil, exception: @exception, sync: true, req: nil, banner: ARG[:BANNER], **)
           if req && !base_path(req).exist?
             log.warn "#{req} (not found)"
             return
           end
-          cmd = close_session(cmd)
+          cmd = session_done(cmd)
           log.info cmd
           begin
             if cmd =~ /^\S+:(\S+:?)+$/ && workspace.task_defined?(cmd)
               print_item if sync
-              invoke(cmd, exception: exception, warning: workspace.warning)
+              log.warn "ENV was discarded: #{var}" if var
+              invoke(cmd, exception: exception, warning: warning?)
             else
               print_item format_banner(cmd, banner: banner) if sync
-              shell(cmd, chdir: path, exception: exception)
+              args = var.is_a?(::Hash) ? [var, cmd] : [cmd]
+              shell(*args, chdir: path, exception: exception)
             end
           rescue StandardError => e
             log.error e
@@ -322,42 +481,57 @@ module Squared
           end
         end
 
-        def run_s(cmd, **kwargs)
-          run(cmd, banner: verbose?, **kwargs) if cmd.is_a?(::String)
+        def run_s(*cmd, env: nil, **kwargs)
+          cmd.each { |val| run(val, env, banner: !!verbose, **kwargs) }
         end
 
-        def env(key, default = nil, equals: nil, ignore: ['0'].freeze, suffix: nil, strict: false)
-          @env ||= name.gsub(/[^\w]+/, '_').upcase
-          a = "#{key}_#{@env}"
-          b = ''
-          if suffix
-            a = [a, suffix].flatten.join('_')
-          elsif !strict
-            b = ENV.fetch(key, '')
-          end
-          ret = ENV.fetch(a, b)
+        def run_task(key)
+          return false unless workspace.task_defined?(key)
+
+          invoke(key, **workspace.invokeargs)
+          true
+        end
+
+        def env(key, default = nil, suffix: nil, equals: nil, ignore: nil, strict: false)
+          a = "#{key}_#{@envname}"
+          ret = if suffix
+                  ENV.fetch("#{a}_#{suffix}", '')
+                else
+                  ignore = ['0'].freeze if ignore.nil? && !strict
+                  ENV[a] || (strict ? '' : ENV.fetch(key, ''))
+                end
           return ret == equals.to_s unless equals.nil?
 
-          ret.empty? || as_a(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, options: nil)
-          if (val = ENV["#{(options || cmd.first).upcase}_OPTIONS"])
+        def session(*cmd, prefix: cmd.first)
+          if (val = env("#{prefix.upcase}_OPTIONS"))
             split_escape(val).each { |opt| cmd << fill_option(opt) }
           end
           @session = JoinSet.new(cmd)
         end
 
-        def close_session(cmd)
-          return cmd unless cmd.respond_to?(:done)
+        def session_done(cmd)
+          return cmd.to_s unless cmd.respond_to?(:done)
 
-          raise_error('none were provided', hint: name) if cmd.empty?
+          raise_error('no args were added', hint: cmd.first || name) unless cmd.size > 1
           @session = nil if cmd == @session
           cmd.done
         end
 
+        def option(*args, prefix: @session&.first, **kwargs)
+          if prefix
+            args.each do |val|
+              ret = env("#{prefix}_#{val.gsub(/\W/, '_')}".upcase, **kwargs)
+              return ret if ret
+            end
+          end
+          nil
+        end
+
         def print_item(*val)
-          puts unless @@print_order == 0 || pipe?
+          puts unless @@print_order == 0 || stdin?
           @@print_order += 1
           puts val unless val.empty? || (val.size == 1 && val.first.nil?)
         end
@@ -387,41 +561,64 @@ module Squared
           out.join("\n")
         end
 
-        def print_footer(*lines, sub: nil, border: theme[:border], reverse: false)
+        def print_footer(*lines, sub: nil, reverse: false, right: false, **kwargs)
+          border = kwargs.key?(:border) ? kwargs[:border] : borderstyle
           n = Project.max_width(lines)
           sub = as_a(sub)
           lines.map! do |val|
-            s = val.ljust(n)
+            s = right ? val.rjust(n) : val.ljust(n)
             sub.each { |h| s = sub_style(s, **h) }
             s
           end
-          ret = [sub_style('-' * n, styles: border), *lines]
+          ret = [sub_style('-' * n, styles: border || theme[:border]), *lines]
           ret.reverse! if reverse
           ret.join("\n")
         end
 
-        def format_desc(action, flag, opts = nil, req: '', arg: 'opts*')
+        def format_desc(action, flag, opts = nil, req: nil, arg: 'opts*')
           opts = "#{arg}=#{opts.join(',')}" if opts.is_a?(::Array)
-          unless flag
+          val = [@desc]
+          if flag
+            val << action
+          else
             flag = action
-            action = ''
           end
-          req = opts ? "#{req}," : "[#{req}]" unless req.to_s.empty?
-          message(*name.split(':'), action, opts ? "#{flag}[#{req}#{opts}]" : flag.to_s + req)
+          req = opts ? "#{req}," : "[#{req}]" if req
+          val << (opts ? "#{flag}[#{req}#{opts}]" : "#{flag}#{req}")
+          message(*val)
         end
 
-        def format_banner(cmd, banner: true, multiple: false)
+        def format_banner(cmd, banner: ARG[:BANNER], multiple: false)
           return unless banner
 
-          if (data = workspace.banner(group: group, ref: ref))
+          if (data = workspace.banner_get(*@ref, group: group))
             client = true
           else
             data = { command: true, order: %i[path], styles: theme[:banner], border: theme[:border] }
           end
-          if verbose?
+          if verbose
             out = []
             out << cmd.sub(/^\S+/, &:upcase) if data[:command]
-            data[:order].each { |val| out << val.to_s if (val = __send__(val)) }
+            data[:order].each do |val|
+              if val.is_a?(::Array)
+                s = ' '
+                found = false
+                val = val.map do |meth|
+                  if meth.is_a?(::String)
+                    s = ''
+                    meth
+                  elsif respond_to?(meth)
+                    found = true
+                    __send__(meth)
+                  end
+                end
+                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)
           elsif multiple && workspace.series.multiple?
             "## #{__send__(data[:order].first || :path)} ##"
@@ -432,8 +629,20 @@ module Squared
           "#{msg}#{!always && (!obj || obj == 0 || obj.to_s.empty?) ? '' : message(hint: message(title, obj.to_s))}"
         end
 
-        def append_nocolor
-          @session << (!ENV.fetch('NO_COLOR', '').empty? || pipe? ? '--no-color' : '')
+        def append_repeat(flag, opts)
+          opts.each { |val| @session << "--#{flag}=#{shell_escape(val, quote: true)}" }
+        end
+
+        def append_value(opts)
+          opts.each { |val| @session << val }
+        end
+
+        def append_nocolor(flag = nil)
+          @session << '--no-color' if flag || !ARG[:COLOR] || stdin?
+        end
+
+        def task_join(*val)
+          val.join(':')
         end
 
         def guard_params(action, flag, args: nil, key: nil, pat: nil)
@@ -450,22 +659,11 @@ module Squared
           end
         end
 
-        def store_pwd(done = nil)
-          if @pwd
-            Dir.chdir(@pwd)
-            @pwd = nil
-          elsif !done && Dir.pwd != path.to_s
-            @pwd = Dir.pwd
-            Dir.chdir(path)
-            @pwd
-          end
-        end
-
         def semver(val)
-          unless val[3]
-            val[3] = '.'
-            val[4] = '0'
-          end
+          return val if val[3]
+
+          val[3] = '.'
+          val[4] = '0'
           unless val[1]
             val[1] = '.'
             val[2] = '0'
@@ -474,39 +672,122 @@ module Squared
         end
 
         def semmajor(cur, want)
-          cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]
+          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
         end
 
-        def verbose?
-          workspace.verbose
+        def semscan(val)
+          val.scan(SEM_VER).first
         end
 
-        def pipe?
-          workspace.pipe
-        end
+        def pwd_set(done = nil, &blk)
+          pwd = Pathname.pwd
+          if block_given?
+            if path == pwd
+              instance_eval(&blk)
+            else
+              Dir.chdir(path)
+              instance_eval(&blk)
+              Dir.chdir(pwd)
+            end
+          elsif @pwd == pwd
+            @pwd = nil
+            pwd unless done
+          elsif @pwd
+            return unless path == pwd
 
-        def invoked_sync?(action, flag = nil)
-          action = workspace.task_name(action)
-          return true if !flag.nil? || workspace.series.sync?("#{action}:sync")
+            Dir.chdir(@pwd)
+            @pwd = nil
+          elsif !done && path != pwd
+            @pwd = pwd
+            Dir.chdir(path)
+            @pwd
+          end
+        end
 
-          check = lambda do |val|
-            if invoked?(val)
-              !workspace.task_defined?("#{val}:sync")
-            elsif workspace.series.sync?("#{val}:sync")
-              true
+        def run_set(cmd, val = nil, opts: nil, **)
+          unless @output[1] == false && !@output[0].nil?
+            if opts == false
+              @output[1] = false
+            elsif opts && opts != true
+              @output[1] = opts
             end
           end
-          if group
-            ret = check.("#{action}:#{group}")
-            return ret unless ret.nil?
+          unless @output[2] == false
+            if val.is_a?(::Hash)
+              @output[2] = val
+            elsif val == false
+              @output[2] = false
+            end
+          end
+          @output[0] = cmd
+        end
+
+        def script_set(cmd, prod: nil, **)
+          return if @output[1] == false && @output[0].nil?
+
+          @output[0] = nil
+          @output[1] = if @global && cmd.is_a?(::Array)
+                         cmd[prod == true ? 1 : 0]
+                       else
+                         cmd
+                       end
+        end
+
+        def source_path?(val)
+          Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.match?(%r{^\.\.[/\\]})
+        end
+
+        def runnable?(val)
+          case val
+          when ::String
+            true
+          when ::Enumerable
+            !val.is_a?(::Hash)
+          else
+            false
+          end
+        end
+
+        def from_sync?(*val)
+          if invoked?(key = task_join(*val))
+            !workspace.task_defined?(key, 'sync')
+          elsif workspace.series.sync?(task_join(key, 'sync'))
+            true
           end
-          if (base = workspace.find_base(self))
-            ret = check.("#{action}:#{base.ref}")
-            return ret unless ret.nil?
+        end
+
+        def invoked_sync?(action, val = nil)
+          return true if !val.nil? || from_sync?(ac = workspace.task_name(action))
+
+          return val if group && !(val = from_sync?(ac, group)).nil?
+          return val if (base = workspace.find_base(self)) && !(val = from_sync?(ac, base.ref)).nil?
+
+          return true if invoked?(name, ac) && (!invoked?(ac) || !workspace.task_defined?(ac, 'sync'))
+
+          val = workspace.series.name_get(action)
+          val == action ? false : invoked_sync?(val)
+        end
+
+        def stdin?
+          pipe == 0
+        end
+
+        def warning?
+          workspace.warning
+        end
+
+        def borderstyle
+          if (data = workspace.banner_get(*@ref, group: group))
+            data[:border]
           end
-          invoked?("#{name}:#{action}") && (!invoked?(action) || !workspace.task_defined?("#{action}:sync"))
+        end
+
+        def scriptargs
+          { target: script? ? @output[1] : @output[0], ref: ref, group: group, global: @global }
         end
       end
+
+      Application.base_project = Base
     end
   end
 end