squared 0.0.10 → 0.0.11

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

@@ -23,6 +23,8 @@ module Squared
 
         class << self
           def populate(*); end
+          def batchargs(*); end
+          def aliasargs(*); end
 
           def tasks
             [].freeze
@@ -44,30 +46,31 @@ 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, :parent
-        attr_accessor :exception, :pipe, :verbose
+        attr_reader :name, :project, :workspace, :path, :exception, :pipe, :verbose, :theme, :group, :parent
 
-        def initialize(name, path, workspace, *,
-                       group: nil, verbose: nil, pass: nil, exclude: nil,
-                       common: Common::KEY[:COMMON], pipe: Common::KEY[:PIPE], **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]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
-          @exception = workspace.exception
-          @pipe = env_pipe(pipe, workspace.pipe)
-          @verbose = verbose.nil? ? workspace.verbose : 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 common
@@ -80,10 +83,11 @@ module Squared
           @children = []
           @pass = (pass ? as_a(pass, :to_sym) : []).freeze
           @exclude = (exclude ? as_a(exclude, :to_sym) : []).freeze
-          @envname = @name.gsub(/[^\w]+/, '_').upcase
-          @desc = @name.split(':').join(' => ')
+          @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]
+          run_set(kwargs[:run], kwargs[:env], opts: kwargs.fetch(:opts, true))
           initialize_ref(Base.ref)
         end
 
@@ -93,7 +97,7 @@ module Squared
 
         def initialize_build(ref, **kwargs)
           initialize_ref(ref)
-          if (@script = @workspace.script(group: @group, ref: ref))
+          if (@script = @workspace.script_get(group: @group, ref: ref))
             if @script[:log] && !kwargs.key?(:log)
               kwargs[:log] = @script[:log]
               @log = nil
@@ -107,7 +111,7 @@ module Squared
           initialize_logger(**kwargs)
           return if @output[0] == false
 
-          data = @workspace.script(*@ref, @group)
+          data = @workspace.script_find(*@ref, @group)
           if @output[0].nil?
             if (scr = data[:script])
               @global = true
@@ -140,8 +144,8 @@ module Squared
           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'
@@ -152,7 +156,7 @@ 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
@@ -163,7 +167,7 @@ module Squared
             end
           end
           log[:progname] ||= @name
-          if (val = env('LOG_LEVEL', ignore: nil))
+          if (val = env('LOG_LEVEL', ignore: false))
             log[:level] = val
           end
           log.delete(:file)
@@ -171,10 +175,14 @@ module Squared
         end
 
         def initialize_env(dev: nil, prod: nil, **)
-          prefix = "BUILD_#{@envname}"
-          @dev = env_match("#{prefix}_DEV", dev)
-          @prod = env_match("#{prefix}_PROD", prod)
-          if (val = env('BUILD', suffix: 'ENV'))
+          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
+          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)
@@ -186,10 +194,12 @@ module Squared
           return unless (val = env('BUILD', strict: true))
 
           @global = false
-          if script?
+          if val == '0'
+            @output = [false]
+          elsif script?
             script_set val
           else
-            run_set(val, opts: false)
+            run_set val
           end
         end
 
@@ -198,36 +208,57 @@ module Squared
         end
 
         def populate(*)
-          check = lambda do |proj, key|
-            workspace.series.include?(key) ? proj.has?(key, Base.ref) : workspace.task_extend?(proj, key)
-          end
-
           namespace name do
             workspace.series.each_key do |key|
-              next unless check.(self, key)
+              next unless workspace.task_include?(self, key)
 
-              unless workspace.task_defined?("#{name}:#{key}")
-                desc message(@desc, key)
-                task key do
+              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| check.(item, key) }).empty?
+              next if (items = @children.select { |item| workspace.task_include?(item, key) }).empty?
 
-              desc message(@desc, key, 'workspace')
-              task "#{key}:workspace" => items.map { |item| "#{item.name}:#{key}" }
+              desc message(@desc, alt, 'workspace')
+              task task_join(alt, 'workspace') => items.map { |item| task_join(item.name, alt) }
             end
           end
         end
 
-        def add(path, name = nil, **kwargs, &blk)
-          return self unless source_path?(path = base_path(path))
+        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.to_s, **kwargs) do
+          workspace.add(path, name || path.basename, **kwargs) do
             variable_set :parent, parent
             proj = self
           end
@@ -236,54 +267,49 @@ module Squared
           self
         end
 
-        def build(*args, sync: true)
+        def build(*args, sync: invoked_sync?('build'), **)
           if args.empty?
-            cmd, opts, var = @output
-            opts &&= shell_split(opts, join: true)
+            cmd, opts, var, flags = @output
+            banner = verbose == 1
           else
             cmd = args.shift
             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 != false
           else
             return unless respond_to?(:compose)
 
-            cmd = compose(opts)
-            banner = verbose == 1
+            cmd = compose(opts, flags, script: true)
           end
           run(cmd, var, banner: banner, sync: sync)
         end
 
-        def refresh(*)
-          build(sync: invoked_sync?('refresh') || invoked_sync?('build'))
-          return if run_task "#{name}:copy"
-
-          copy if copy?
+        def depend(*, sync: invoked_sync?('depend'), **)
+          run(@depend, sync: sync) if @depend
         end
 
-        def depend(*)
-          run(@depend, sync: invoked_sync?('depend')) if @depend
+        def copy(*, sync: invoked_sync?('copy'), **)
+          run_s(@copy, sync: sync) if @copy
         end
 
-        def copy(*)
-          run_s(@copy, sync: invoked_sync?('copy')) if @copy
+        def doc(*, sync: invoked_sync?('doc'), **)
+          build(@doc, sync: sync) if @doc
         end
 
-        def doc
-          build(@doc, sync: invoked_sync?('doc')) if @doc
+        def test(*, sync: invoked_sync?('test'), **)
+          build(@test, sync: sync) if @test
         end
 
-        def test
-          build(@test, sync: invoked_sync?('test')) if @test
-        end
-
-        def clean
+        def clean(*)
           case @clean
           when ::String
             run_s(@clean, sync: invoked_sync?('clean'))
@@ -311,15 +337,21 @@ module Squared
         end
 
         def log
-          if @log.is_a?(::Array)
-            @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
-          else
-            @log
-          end
+          return @log unless @log.is_a?(::Array)
+
+          @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)
@@ -328,26 +360,34 @@ module Squared
         end
 
         def variable_set(key, *val, **kwargs)
-          if variable_all.include?(key)
+          if variables.include?(key)
             case key
             when :run
-              run_set(*val, opts: false, **kwargs)
+              run_set(*val, **kwargs)
             when :script
               script_set(*val, **kwargs)
             when :env
-              run_set(output[0], *val, opts: false, **kwargs)
+              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} (not defined)"
+            log.warn "variable_set: @#{key} (private)"
           end
         end
 
-        def variable_all
+        def variables
           VAR_SET
         end
 
+        def allref
+          @ref.reverse_each
+        end
+
+        def version(*); end
+
         def inspect
           "#<#{self.class}: #{name} => #{self}>"
         end
@@ -384,12 +424,12 @@ module Squared
           @output[0].nil? && !!@output[1] && respond_to?(:compose)
         end
 
-        def refresh?
-          build? && copy?
+        def depend?
+          !!@depend
         end
 
-        def depend?
-          @depend != false && (!@depend.nil? || has?('outdated'))
+        def copy?
+          runnable?(@copy) || workspace.task_defined?(name, 'copy')
         end
 
         def doc?
@@ -400,12 +440,8 @@ module Squared
           !!@test
         end
 
-        def copy?
-          runnable?(@copy) || workspace.task_defined?("#{name}:copy")
-        end
-
         def clean?
-          runnable?(@clean) || workspace.task_defined?("#{name}:clean")
+          runnable?(@clean) || workspace.task_defined?(name, 'clean')
         end
 
         def dev?
@@ -418,12 +454,16 @@ module Squared
 
         private
 
-        def run(cmd = @session, var = nil, exception: @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)
@@ -441,50 +481,55 @@ module Squared
           end
         end
 
-        def run_s(cmd, **kwargs)
-          as_a(cmd).each { |val| run(val, banner: !!verbose, **kwargs) if val.is_a?(::String) }
+        def run_s(*cmd, env: nil, **kwargs)
+          cmd.each { |val| run(val, env, banner: !!verbose, **kwargs) }
         end
 
         def run_task(key)
           return false unless workspace.task_defined?(key)
 
-          invoke(key, exception: exception, warning: warning?)
+          invoke(key, **workspace.invokeargs)
           true
         end
 
-        def env(key, default = nil, equals: nil, ignore: ['0'].freeze, suffix: nil, strict: false)
+        def env(key, default = nil, suffix: nil, equals: nil, ignore: nil, strict: false)
           a = "#{key}_#{@envname}"
-          b = ''
-          if suffix
-            a = "#{a}_#{suffix}"
-          elsif !strict
-            b = ENV.fetch(key, '')
-          end
-          ret = ENV.fetch(a, b)
+          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 puts(*args)
-          pipe == 2 ? $stderr.puts(*args) : $stdout.puts(*args)
-        end
-
-        def session(*cmd, prefix: nil)
-          if (val = ENV["#{(prefix || 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('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 || stdin?
           @@print_order += 1
@@ -516,33 +561,37 @@ 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(@desc, 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] }
@@ -550,7 +599,26 @@ module Squared
           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)} ##"
@@ -569,8 +637,12 @@ module Squared
           opts.each { |val| @session << val }
         end
 
-        def append_nocolor
-          @session << (!ENV.fetch('NO_COLOR', '').empty? || stdin? ? '--no-color' : '')
+        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)
@@ -587,6 +659,26 @@ module Squared
           end
         end
 
+        def semver(val)
+          return val if val[3]
+
+          val[3] = '.'
+          val[4] = '0'
+          unless val[1]
+            val[1] = '.'
+            val[2] = '0'
+          end
+          val
+        end
+
+        def semmajor(cur, want)
+          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
+        end
+
+        def semscan(val)
+          val.scan(SEM_VER).first
+        end
+
         def pwd_set(done = nil, &blk)
           pwd = Pathname.pwd
           if block_given?
@@ -612,39 +704,27 @@ module Squared
           end
         end
 
-        def semver(val)
-          unless val[3]
-            val[3] = '.'
-            val[4] = '0'
+        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
-          unless val[1]
-            val[1] = '.'
-            val[2] = '0'
+          unless @output[2] == false
+            if val.is_a?(::Hash)
+              @output[2] = val
+            elsif val == false
+              @output[2] = false
+            end
           end
-          val
-        end
-
-        def semmajor(cur, want)
-          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
-        end
-
-        def scriptargs
-          { target: script? ? @output[1] : @output[0], ref: ref, group: group, global: @global }
-        end
-
-        def run_set(cmd, val = nil, *, opts: true, **)
           @output[0] = cmd
-          @output[1] = if cmd && opts
-                         env('BUILD', opts.is_a?(::String) ? opts : nil, suffix: 'OPTS')
-                       end
-          if val.is_a?(::Hash)
-            @output[2] = val
-          elsif val == false
-            @output[2] = nil
-          end
         end
 
-        def script_set(cmd, *, prod: nil, **)
+        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]
@@ -657,14 +737,6 @@ module Squared
           Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.match?(%r{^\.\.[/\\]})
         end
 
-        def warning?
-          workspace.warning
-        end
-
-        def stdin?
-          pipe == 0
-        end
-
         def runnable?(val)
           case val
           when ::String
@@ -676,10 +748,10 @@ module Squared
           end
         end
 
-        def from_sync?(val)
-          if invoked?(val)
-            !workspace.task_defined?("#{val}:sync")
-          elsif workspace.series.sync?("#{val}:sync")
+        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
         end
@@ -687,12 +759,35 @@ module Squared
         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 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
+        end
 
-          invoked?("#{name}:#{ac}") && (!invoked?(ac) || !workspace.task_defined?("#{ac}:sync"))
+        def scriptargs
+          { target: script? ? @output[1] : @output[0], ref: ref, group: group, global: @global }
         end
       end
+
+      Application.base_project = Base
     end
   end
 end