squared 0.0.12 → 0.1.0

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

@@ -12,12 +12,11 @@ module Squared
         include System
         include Shell
         include Utils
-        include ::Rake::DSL
-
-        SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?/.freeze
+        include Rake::DSL
 
         VAR_SET = %i[parent global envname dependfile theme run script env depend graph doc test copy clean].freeze
-        private_constant :VAR_SET
+        SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?/.freeze
+        private_constant :VAR_SET, :SEM_VER
 
         class << self
           def populate(*); end
@@ -31,9 +30,9 @@ module Squared
 
           def as_path(val)
             case val
-            when ::Pathname
+            when Pathname
               val
-            when ::String
+            when String
               Pathname.new(val)
             end
           end
@@ -42,13 +41,13 @@ module Squared
             @ref ||= to_s.downcase.to_sym
           end
 
-          def to_s
-            super.match(/[^:]+$/)[0]
-          end
-
           def config?(*)
             false
           end
+
+          def to_s
+            super.match(/[^:]+$/)[0]
+          end
         end
 
         @@tasks = {
@@ -151,7 +150,7 @@ module Squared
         def initialize_logger(log: nil, **)
           return if @log
 
-          log = log.is_a?(::Hash) ? log.dup : { file: log }
+          log = log.is_a?(Hash) ? log.dup : { file: log }
           unless (file = env('LOG_FILE'))
             file = case env('LOG_AUTO')
                    when 'y', 'year'
@@ -171,7 +170,7 @@ module Squared
               raise if @exception
 
               file = nil
-              warn log_message(::Logger::WARN, e) if warning?
+              warn log_message(Logger::WARN, e) if warning?
             end
           end
           log[:progname] ||= @name
@@ -187,13 +186,13 @@ module Squared
           @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?
+          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)
+              raise_error('invalid JSON object', val, hint: "#{prefix}_ENV") unless data.is_a?(Hash)
               @output[2] = data
             rescue StandardError => e
               log.warn e
@@ -241,22 +240,34 @@ module Squared
                   when :graph
                     next unless graph?
 
+                    check = lambda do |args|
+                      next args if (args = args.to_a).empty?
+
+                      guard_params(action, flag, args: args.reject { |val| name == val.to_s })
+                    end
+
+                    desc format_desc(action, flag, 'project*')
                     if flag == :run
-                      desc format_desc(action, flag, 'pass*')
-                      task flag, [:pass] do |_, args|
-                        graph(pass: args.to_a)
+                      task flag, [:project] do |_, args|
+                        graph check.(args)
                       end
                     else
-                      desc format_desc(action, flag)
-                      task flag do
-                        out = graph(out: [])
-                        emphasize(out, title: path, right: true, border: borderstyle,
-                                       footer: "dependencies: #{out.size - 1}",
-                                       sub: [
-                                         { pat: /^(#{Regexp.escape(path.to_s)})(.*)$/, styles: theme[:header] },
-                                         { pat: /^(#{Regexp.escape(name)})(.*)$/, styles: theme[:active] },
-                                         { pat: /^(\s*)([a-z]+: )(\d+)$/, styles: theme[:inline], index: 3 }
-                                       ])
+                      task flag, [:project] do |_, args|
+                        out, done = graph(check.(args), out: [])
+                        out.map! do |val|
+                          done.each_with_index do |proj, i|
+                            next unless val.end_with?(" #{proj.name}")
+
+                            val += " (#{i.succ})"
+                            break
+                          end
+                          val
+                        end
+                        emphasize(out, title: path, right: true, border: borderstyle, sub: [
+                          { pat: /^(#{Regexp.escape(path.to_s)})(.*)$/, styles: theme[:header] },
+                          { pat: /^(#{Regexp.escape(name)})(.*)$/, styles: theme[:active] },
+                          { pat: /^(.+ )(\()(\d+)(\))(.*)$/, styles: theme[:inline], index: 3 }
+                        ])
                       end
                     end
                   end
@@ -276,18 +287,28 @@ module Squared
         end
 
         def add(path, name = nil, **kwargs, &blk)
-          if path.is_a?(::String) && (data = %r{^(.+)[\\/]\*+$}.match(path))
-            path = basepath(data[1]).children.select(&:directory?)
+          checkdir = lambda do |val|
+            if val.directory? && val.exist?
+              true
+            else
+              log.warn "workspace \"#{val}\" (not found)"
+              false
+            end
+          end
+          if path.is_a?(String) && (data = %r{^(.+)[\\/]\*+$}.match(path))
+            return self unless checkdir.(path = basepath(data[1]))
+
+            path = path.children.select { |val| checkdir.(val) }
           end
-          if path.is_a?(::Array)
+          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 !projectpath?(path = basepath(path))
+          elsif !projectpath?(path = basepath(path)) || !checkdir.(path)
             return self
-          elsif name.is_a?(::Symbol)
+          elsif name.is_a?(Symbol)
             name = name.to_s
-          elsif !name.is_a?(::String)
+          elsif !name.is_a?(String)
             name = nil
           end
           if @withargs
@@ -319,9 +340,9 @@ module Squared
           end
           if cmd
             case opts
-            when ::String
+            when String
               cmd = "#{cmd} #{opts}"
-            when ::Array
+            when Array
               cmd = cmd.join(' && ')
             else
               cmd = [cmd, compose(opts, script: false)].compact.join(' ') unless opts == false || !respond_to?(:compose)
@@ -352,9 +373,9 @@ module Squared
 
         def clean(*)
           case @clean
-          when ::String
+          when String
             run_s(@clean, sync: invoked_sync?('clean'))
-          when ::Enumerable
+          when Enumerable
             as_a(@clean).each do |val|
               if (val = val.to_s) =~ %r{[\\/]$}
                 dir = Pathname.new(val)
@@ -377,34 +398,22 @@ module Squared
           end
         end
 
-        def graph(*, sync: invoked_sync?('graph'), pass: [], out: nil)
-          data = graph_collect(self)
-          data[name] << self unless out
-          run_graph(data, name, out, sync: sync, pass: pass)
-          out
-        end
-
-        def log
-          return @log unless @log.is_a?(::Array)
-
-          @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
-        end
-
-        def basepath(*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
+        def graph(start = [], tasks = nil, sync: invoked_sync?('graph'), pass: [], out: nil)
+          if (val = env('GRAPH', strict: true))
+            tasks ||= []
+            split_escape(val).each do |task|
+              if ref?(task.to_sym) && (script = workspace.script_get(:graph, ref: task.to_sym))
+                tasks += script[:graph]
+              else
+                tasks << task
+              end
+            end
           end
-          ret
-        end
-
-        def color(val)
-          ret = theme[val]
-          ret && !ret.empty? ? ret : [val]
+          pass.concat(split_escape(val)) if (val = env('GRAPH_PASS', strict: true))
+          data = graph_collect(self, start)
+          data[name] << self unless out
+          done = run_graph(data, name, tasks, out, sync: sync, pass: pass)
+          [out, done] if out
         end
 
         def variable_set(key, *val, **kwargs)
@@ -435,28 +444,6 @@ module Squared
           end
         end
 
-        def allref
-          @ref.reverse_each
-        end
-
-        def dependtype(*)
-          @dependindex ? @dependindex.succ : 0
-        end
-
-        def version(*); end
-
-        def inspect
-          "#<#{self.class}: #{name} => #{self}>"
-        end
-
-        def to_s
-          path.to_s
-        end
-
-        def to_sym
-          name.to_sym
-        end
-
         def enabled?(ref = nil)
           return false if ref && !ref?(ref)
 
@@ -486,7 +473,7 @@ module Squared
         end
 
         def graph?
-          @graph.is_a?(::Array) && !@graph.empty?
+          @graph.is_a?(Array) && !@graph.empty?
         end
 
         def copy?
@@ -513,12 +500,48 @@ module Squared
           @prod != false && workspace.prod?(pat: @prod, **scriptargs)
         end
 
-        private
+        def version(*); end
 
-        def variables
-          VAR_SET
+        def dependtype(*)
+          @dependindex ? @dependindex.succ : 0
+        end
+
+        def log
+          return @log unless @log.is_a?(Array)
+
+          @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
+        end
+
+        def allref
+          @ref.reverse_each
+        end
+
+        def basepath(*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 inspect
+          "#<#{self.class}: #{name} => #{self}>"
+        end
+
+        def to_s
+          path.to_s
         end
 
+        def to_sym
+          name.to_sym
+        end
+
+        private
+
         def puts(*args)
           puts_oe(*args, pipe: pipe)
         end
@@ -533,7 +556,7 @@ module Squared
               task_invoke(cmd, exception: exception, warning: warning?)
             else
               print_item format_banner(cmd, banner: banner) if sync
-              args = var.is_a?(::Hash) ? [var, cmd] : [cmd]
+              args = var.is_a?(Hash) ? [var, cmd] : [cmd]
               shell(*args, chdir: path, exception: exception)
             end
           rescue StandardError => e
@@ -546,9 +569,25 @@ module Squared
           cmd.each { |val| run(val, env, banner: banner, **kwargs) }
         end
 
-        def run_graph(data, start, out = nil, sync: true, pass: [], done: [], depth: 0, last: false)
+        def run_graph(data, start, tasks = nil, out = nil, sync: true, pass: [], done: [], depth: 0, last: false,
+                      single: false)
           check = ->(deps) { deps.reject { |val| done.include?(val) } }
-          items = check.(data[start])
+          dedupe = lambda do |name|
+            next [] unless (ret = data[name])
+
+            ret.dup.each do |proj|
+              next if proj.name == name
+
+              data[proj.name]&.each { |dep| ret.delete(dep) if ret.include?(dep) }
+            end
+            ret
+          end
+          if depth == 0
+            items = check.(dedupe.(start))
+            single = items.size == 1
+          else
+            items = check.(data[start])
+          end
           if out
             a, b, c, d, e = ARG[:GRAPH]
             out << case depth
@@ -561,22 +600,30 @@ module Squared
                        "#{last ? d : c}#{b * 3}#{e} #{start}"
                      end
                    else
-                     "#{a}#{'   ' * (depth - 1)}#{d}#{b * 2}#{items.empty? ? b : e} #{start}"
+                     "#{single ? ' ' : a}#{'   ' * (depth - 1)}#{last ? d : c}#{b * 3}#{items.empty? ? b : e} #{start}"
                    end
           end
           items.each_with_index do |proj, i|
             next if done.include?(proj)
 
-            j = out ? i == items.size - 1 || check.(items[i + 1..-1]).empty? : false
             s = proj.name
-            unless start == s || (none = check.(data.fetch(s, [])).empty?)
-              run_graph(data, s, out, sync: sync, pass: pass, done: done, depth: depth.succ, last: j)
+            t = dedupe.(s)
+            j = if out
+                  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?
+                  end
+                end
+            unless start == s || (none = check.(t).empty?)
+              run_graph(data, s, tasks, out, sync: sync, pass: pass, done: done, depth: depth.succ, single: single,
+                                             last: j == true)
             end
             if !out
-              if (script = workspace.script_get(group: proj.group, ref: proj.ref))
-                tasks = script[:graph]
+              unless tasks || !(script = workspace.script_get(:graph, group: proj.group, ref: proj.allref))
+                group = script[:graph]
               end
-              (tasks || (dev? ? %w[build copy] : %w[depend build])).each do |meth|
+              (tasks || group || (dev? ? ['build', 'copy'] : ['depend', 'build'])).each do |meth|
                 next if pass.include?(meth)
 
                 if workspace.task_defined?(cmd = task_join(s, meth))
@@ -590,17 +637,24 @@ module Squared
               out << if depth == 0
                        "#{i == items.size - 1 ? d : c}#{b * 4} #{s}"
                      else
-                       "#{last && depth == 1 ? ' ' : a}#{'   ' * depth}#{j ? d : c}#{b * 3} #{s}"
+                       f = ''.dup
+                       k = 0
+                       while k < depth
+                         f += "#{(last && !j) || (j && k > 0 && k == depth - 1) || single ? ' ' : a}   "
+                         k += 1
+                       end
+                       f + "#{j ? d : c}#{b * 3} #{s}"
                      end
             end
             done << proj
           end
+          done
         end
 
-        def graph_collect(target, data: {})
+        def graph_collect(target, start = [], data: {})
           deps = []
-          target.instance_variable_get(:@graph)&.each do |val|
-            next unless (proj = workspace.find(name: val))
+          (start.empty? ? target.instance_variable_get(:@graph) : start)&.each do |val|
+            next unless (proj = workspace.find(name: val)) && proj.enabled?
 
             deps << proj
             graph_collect(proj, data: data) if proj.graph? && !data.key?(proj.name)
@@ -614,9 +668,11 @@ module Squared
           a = "#{key}_#{@envname}"
           ret = if suffix
                   ENV.fetch("#{a}_#{suffix}", '')
+                elsif strict
+                  ENV[a].to_s
                 else
-                  ignore = ['0'].freeze if ignore.nil? && !strict
-                  ENV[a] || (strict ? '' : ENV.fetch(key, ''))
+                  ignore = ['0'].freeze if ignore.nil?
+                  ENV[a] || ENV.fetch(key, '')
                 end
           return ret == equals.to_s unless equals.nil?
 
@@ -694,7 +750,7 @@ module Squared
         end
 
         def format_desc(action, flag, opts = nil, req: nil, arg: 'opts*')
-          opts = "#{arg}=#{opts.join(',')}" if opts.is_a?(::Array)
+          opts = "#{arg}=#{opts.join(',')}" if opts.is_a?(Array)
           out = [@desc]
           if flag
             out << action
@@ -718,11 +774,11 @@ module Squared
             out = []
             out << cmd.sub(/^\S+/, &:upcase) if data[:command]
             data[:order].each do |val|
-              if val.is_a?(::Array)
+              if val.is_a?(Array)
                 s = ' '
                 found = false
                 val = val.map do |meth|
-                  if meth.is_a?(::String)
+                  if meth.is_a?(String)
                     s = ''
                     meth
                   elsif respond_to?(meth)
@@ -782,7 +838,11 @@ module Squared
         end
 
         def append_value(opts)
-          opts.each { |val| @session << val }
+          opts.each { |val| @session << shell_escape(val) }
+        end
+
+        def append_option(list, **kwargs)
+          list.each { |val| @session << "--#{val}" if option(val, **kwargs) }
         end
 
         def append_nocolor(flag = nil)
@@ -796,13 +856,50 @@ module Squared
 
             @session = nil
             raise_error(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
-          elsif args.is_a?(::Array) && args.empty?
+          elsif args.is_a?(Array) && args.empty?
             @session = nil
             raise_error(action, "#{flag}+", hint: 'empty')
           end
           args
         end
 
+        def projectmap(files, parent: false)
+          files = files.select { |val| projectpath?(val) } unless parent
+          files.map { |val| val == '.' ? '.' : shell_quote(basepath(val.strip)) }
+        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 semscan(val, fill: true)
+          ret = val.scan(SEM_VER).first
+          fill ? semver(ret) : ret
+        end
+
+        def indexitem(val)
+          return unless (data = /\A\^(\d+)(:.+)?\z/.match(val))
+
+          [data[1].to_i, data[2] ? data[2][1..-1] : nil]
+        end
+
+        def indexerror(val, list = nil)
+          raise_error("requested index #{val}", hint: list && "of #{list.size}")
+        end
+
+        def color(val)
+          ret = theme[val]
+          ret && !ret.empty? ? ret : [val]
+        end
+
         def pwd_set(done = nil, &blk)
           pwd = Pathname.pwd
           if block_given?
@@ -837,7 +934,7 @@ module Squared
             end
           end
           unless @output[2] == false
-            if val.is_a?(::Hash)
+            if val.is_a?(Hash)
               @output[2] = val
             elsif val == false
               @output[2] = false
@@ -850,7 +947,7 @@ module Squared
           return if @output[1] == false && @output[0].nil?
 
           @output[0] = nil
-          @output[1] = if @global && cmd.is_a?(::Array)
+          @output[1] = if @global && cmd.is_a?(Array)
                          cmd[prod == true ? 1 : 0]
                        else
                          cmd
@@ -867,10 +964,10 @@ module Squared
 
         def runnable?(val)
           case val
-          when ::String
+          when String
             true
-          when ::Enumerable
-            !val.is_a?(::Hash)
+          when Enumerable
+            !val.is_a?(Hash)
           else
             false
           end
@@ -905,31 +1002,14 @@ module Squared
           workspace.warning
         end
 
-        def projectmap(files, parent: false)
-          files = files.select { |val| projectpath?(val) } unless parent
-          files.map { |val| val == '.' ? '.' : shell_quote(basepath(val.strip)) }
-        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 semscan(val)
-          val.scan(SEM_VER).first
+        def variables
+          VAR_SET
         end
 
         def borderstyle
-          if (data = workspace.banner_get(*@ref, group: group))
-            data[:border]
-          end
+          return unless (data = workspace.banner_get(*@ref, group: group))
+
+          data[:border]
         end
 
         def headerstyle
@@ -939,16 +1019,6 @@ module Squared
         def scriptargs
           { target: script? ? @output[1] : @output[0], ref: ref, group: group, global: @global }
         end
-
-        def indexdata(val)
-          if (data = /\A\^(\d+)(:.+)?\z/.match(val))
-            [data[1].to_i, data[2] ? data[2][1..-1] : nil]
-          end
-        end
-
-        def indexerror(val, list = nil)
-          raise_error("requested index #{val}", hint: list && "of #{list.size}")
-        end
       end
 
       Application.impl_project = Base