squared 0.0.11 → 0.0.12

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

@@ -8,23 +8,22 @@ module Squared
   module Workspace
     module Project
       class Base
-        include Common
-        include Format
+        include Common::Format
         include System
         include Shell
-        include Task
         include Utils
         include ::Rake::DSL
 
         SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?/.freeze
 
-        VAR_SET = %i[parent global envname theme run script env depend doc test copy clean].freeze
+        VAR_SET = %i[parent global envname dependfile theme run script env depend graph doc test copy clean].freeze
         private_constant :VAR_SET
 
         class << self
           def populate(*); end
           def batchargs(*); end
           def aliasargs(*); end
+          def bannerargs(*); end
 
           def tasks
             [].freeze
@@ -44,7 +43,7 @@ module Squared
           end
 
           def to_s
-            super.to_s.match(/[^:]+$/)[0]
+            super.match(/[^:]+$/)[0]
           end
 
           def config?(*)
@@ -52,12 +51,18 @@ module Squared
           end
         end
 
+        @@tasks = {
+          "#{ref}": {
+            graph: %i[run print].freeze
+          }.freeze
+        }
         @@print_order = 0
-        @@tasks = {}
 
-        attr_reader :name, :project, :workspace, :path, :exception, :pipe, :verbose, :theme, :group, :parent
+        attr_reader :name, :project, :workspace, :path, :exception, :pipe, :theme, :group, :parent,
+                    :dependfile, :verbose
 
-        def initialize(workspace, path, name, *, group: nil, pass: nil, exclude: nil, common: ARG[:COMMON], **kwargs)
+        def initialize(workspace, path, name, *, group: nil, graph: nil, pass: nil, exclude: nil,
+                       common: ARG[:COMMON], **kwargs)
           @path = path
           @workspace = workspace
           @name = name.to_s.freeze
@@ -81,6 +86,9 @@ module Squared
           @output = []
           @ref = []
           @children = []
+          @graph = if graph
+                     as_a(graph, workspace.prefix ? ->(val) { workspace.task_name(val).to_sym } : :to_sym).freeze
+                   end
           @pass = (pass ? as_a(pass, :to_sym) : []).freeze
           @exclude = (exclude ? as_a(exclude, :to_sym) : []).freeze
           @envname = @name.gsub(/[^\w]+/, '_').upcase.freeze
@@ -212,17 +220,48 @@ module Squared
             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
+              s = workspace.series.name_get(key)
+              unless workspace.task_defined?(name, s)
+                desc message(@desc, s)
+                task s 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) }
+              desc message(@desc, s, 'workspace')
+              task task_join(s, 'workspace') => items.map { |item| task_join(item.name, s) }
+            end
+            next unless ref?(Base.ref)
+
+            @@tasks[Base.ref].each do |action, flags|
+              namespace action do
+                flags.each do |flag|
+                  case action
+                  when :graph
+                    next unless graph?
+
+                    if flag == :run
+                      desc format_desc(action, flag, 'pass*')
+                      task flag, [:pass] do |_, args|
+                        graph(pass: args.to_a)
+                      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 }
+                                       ])
+                      end
+                    end
+                  end
+                end
+              end
             end
           end
         end
@@ -238,15 +277,17 @@ module Squared
 
         def add(path, name = nil, **kwargs, &blk)
           if path.is_a?(::String) && (data = %r{^(.+)[\\/]\*+$}.match(path))
-            path = base_path(data[1]).children.select(&:directory?)
+            path = basepath(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))
+          elsif !projectpath?(path = basepath(path))
             return self
-          elsif !name.is_a?(::String) && !name.is_a?(::Symbol)
+          elsif name.is_a?(::Symbol)
+            name = name.to_s
+          elsif !name.is_a?(::String)
             name = nil
           end
           if @withargs
@@ -317,13 +358,13 @@ module Squared
             as_a(@clean).each do |val|
               if (val = val.to_s) =~ %r{[\\/]$}
                 dir = Pathname.new(val)
-                dir = base_path(dir) unless dir.absolute?
+                dir = basepath(dir) unless dir.absolute?
                 next unless dir.directory?
 
                 log.warn "rm -rf #{dir}"
                 dir.rmtree(verbose: true)
               else
-                files = val.include?('*') ? Dir[base_path(val)] : [base_path(val)]
+                files = val.include?('*') ? Dir[basepath(val)] : [basepath(val)]
                 files.each do |file|
                   begin
                     File.delete(file) if File.file?(file)
@@ -336,13 +377,20 @@ 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 base_path(*args, ascend: nil)
+        def basepath(*args, ascend: nil)
           ret = path.join(*args)
           return ret unless ascend && !ret.exist?
 
@@ -370,6 +418,15 @@ module Squared
               run_set(output[0], *val, **kwargs)
             when :parent
               @parent = val if (val = val.first).is_a?(Project::Base)
+            when :graph
+              @graph = case val.first
+                       when nil, false
+                         nil
+                       else
+                         val.flatten.map!(&:to_s).freeze
+                       end
+            when :dependfile
+              @dependfile = basepath(*val)
             else
               instance_variable_set :"@#{key}", val.first
             end
@@ -378,14 +435,14 @@ module Squared
           end
         end
 
-        def variables
-          VAR_SET
-        end
-
         def allref
           @ref.reverse_each
         end
 
+        def dependtype(*)
+          @dependindex ? @dependindex.succ : 0
+        end
+
         def version(*); end
 
         def inspect
@@ -428,6 +485,10 @@ module Squared
           !!@depend
         end
 
+        def graph?
+          @graph.is_a?(::Array) && !@graph.empty?
+        end
+
         def copy?
           runnable?(@copy) || workspace.task_defined?(name, 'copy')
         end
@@ -454,22 +515,22 @@ module Squared
 
         private
 
+        def variables
+          VAR_SET
+        end
+
         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
+        def run(cmd = @session, var = nil, exception: @exception, sync: true, banner: true, **)
           cmd = session_done(cmd)
           log.info cmd
           begin
             if cmd =~ /^\S+:(\S+:?)+$/ && workspace.task_defined?(cmd)
               print_item if sync
               log.warn "ENV was discarded: #{var}" if var
-              invoke(cmd, exception: exception, warning: warning?)
+              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]
@@ -481,15 +542,72 @@ module Squared
           end
         end
 
-        def run_s(*cmd, env: nil, **kwargs)
-          cmd.each { |val| run(val, env, banner: !!verbose, **kwargs) }
+        def run_s(*cmd, env: nil, banner: verbose != false, **kwargs)
+          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)
+          check = ->(deps) { deps.reject { |val| done.include?(val) } }
+          items = check.(data[start])
+          if out
+            a, b, c, d, e = ARG[:GRAPH]
+            out << case depth
+                   when 0
+                     start
+                   when 1
+                     if items.empty?
+                       "#{d}#{b * 4} #{start}"
+                     else
+                       "#{last ? d : c}#{b * 3}#{e} #{start}"
+                     end
+                   else
+                     "#{a}#{'   ' * (depth - 1)}#{d}#{b * 2}#{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)
+            end
+            if !out
+              if (script = workspace.script_get(group: proj.group, ref: proj.ref))
+                tasks = script[:graph]
+              end
+              (tasks || (dev? ? %w[build copy] : %w[depend build])).each do |meth|
+                next if pass.include?(meth)
+
+                if workspace.task_defined?(cmd = task_join(s, meth))
+                  run(cmd, sync: false, banner: false)
+                elsif proj.has?(meth)
+                  proj.__send__(meth.to_sym, sync: sync)
+                end
+              end
+            elsif none
+              a, b, c, d = ARG[:GRAPH]
+              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}"
+                     end
+            end
+            done << proj
+          end
         end
 
-        def run_task(key)
-          return false unless workspace.task_defined?(key)
+        def graph_collect(target, data: {})
+          deps = []
+          target.instance_variable_get(:@graph)&.each do |val|
+            next unless (proj = workspace.find(name: val))
 
-          invoke(key, **workspace.invokeargs)
-          true
+            deps << proj
+            graph_collect(proj, data: data) if proj.graph? && !data.key?(proj.name)
+            deps += data.fetch(val, [])
+          end
+          data[target.name] = deps.uniq.reject { |proj| proj == target }
+          data
         end
 
         def env(key, default = nil, suffix: nil, equals: nil, ignore: nil, strict: false)
@@ -531,7 +649,7 @@ module Squared
         end
 
         def print_item(*val)
-          puts unless @@print_order == 0 || stdin?
+          puts if @@print_order > 0 && verbose && !stdin?
           @@print_order += 1
           puts val unless val.empty? || (val.size == 1 && val.first.nil?)
         end
@@ -542,7 +660,7 @@ module Squared
             if styles.any? { |s| s.to_s.end_with?('!') }
               pad = 1
             elsif !client && styles.size <= 1
-              styles = [:bold] + styles
+              styles = %i[bold] + styles
             end
           end
           n = Project.max_width(lines)
@@ -577,19 +695,19 @@ module Squared
 
         def format_desc(action, flag, opts = nil, req: nil, arg: 'opts*')
           opts = "#{arg}=#{opts.join(',')}" if opts.is_a?(::Array)
-          val = [@desc]
+          out = [@desc]
           if flag
-            val << action
+            out << action
           else
             flag = action
           end
-          req = opts ? "#{req}," : "[#{req}]" if req
-          val << (opts ? "#{flag}[#{req}#{opts}]" : "#{flag}#{req}")
-          message(*val)
+          req &&= opts ? "#{req}," : "[#{req}]"
+          out << (opts ? "#{flag}[#{req}#{opts}]" : "#{flag}#{req}")
+          message(*out)
         end
 
-        def format_banner(cmd, banner: ARG[:BANNER], multiple: false)
-          return unless banner
+        def format_banner(cmd, banner: true)
+          return unless banner && ARG[:BANNER]
 
           if (data = workspace.banner_get(*@ref, group: group))
             client = true
@@ -625,6 +743,36 @@ module Squared
           end
         end
 
+        def format_list(items, cmd, type, grep: [], from: nil, each: nil)
+          reg = grep.map { |val| Regexp.new(val) }
+          out = []
+          if (pad = items.size) > 0
+            pad = pad.to_s.size
+            items.each_with_index do |val, i|
+              next unless reg.empty? || reg.any? { |pat| pat.match?(val[0]) }
+
+              out << "#{(i + 1).to_s.rjust(pad)}. #{each ? each.(val) : val[0]}"
+            end
+          end
+          if out.empty?
+            out = ["No #{type} were found:", '']
+            unless grep.empty?
+              i = 0
+              out += grep.map { |s| "#{i += 1}. #{s}" }
+              out << ''
+            end
+            if from
+              out << from
+              pat = /^(#{Regexp.escape(out.last)})(.*)$/
+            end
+          else
+            pat = /^(\s*\d+\.)(.+)$/
+          end
+          sub = [headerstyle]
+          sub << { pat: pat, styles: theme[:active] } if pat
+          emphasize(out, title: task_join(name, cmd), border: borderstyle, sub: sub)
+        end
+
         def empty_status(msg, title, obj, always: false)
           "#{msg}#{!always && (!obj || obj == 0 || obj.to_s.empty?) ? '' : message(hint: message(title, obj.to_s))}"
         end
@@ -641,42 +789,18 @@ module Squared
           @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)
           if args && key
-            return unless (val = args[key]).nil? || (pat && !val.match?(pat))
+            val = args[key]
+            return val unless val.nil? || (pat && !val.match?(pat))
 
             @session = nil
             raise_error(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
-          elsif args.is_a?(::Array)
-            return unless args.empty?
-
+          elsif args.is_a?(::Array) && args.empty?
             @session = nil
-            raise_error(action, "#{flag}[]", hint: 'empty')
-          end
-        end
-
-        def semver(val)
-          return val if val[3]
-
-          val[3] = '.'
-          val[4] = '0'
-          unless val[1]
-            val[1] = '.'
-            val[2] = '0'
+            raise_error(action, "#{flag}+", hint: 'empty')
           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
+          args
         end
 
         def pwd_set(done = nil, &blk)
@@ -733,8 +857,12 @@ module Squared
                        end
         end
 
-        def source_path?(val)
-          Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.match?(%r{^\.\.[/\\]})
+        def projectpath?(val)
+          Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.start_with?('..')
+        end
+
+        def semmajor?(cur, want)
+          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
         end
 
         def runnable?(val)
@@ -749,7 +877,7 @@ module Squared
         end
 
         def from_sync?(*val)
-          if invoked?(key = task_join(*val))
+          if task_invoked?(key = task_join(*val))
             !workspace.task_defined?(key, 'sync')
           elsif workspace.series.sync?(task_join(key, 'sync'))
             true
@@ -758,14 +886,15 @@ 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 true if invoked?(name, ac) && (!invoked?(ac) || !workspace.task_defined?(ac, 'sync'))
-
-          val = workspace.series.name_get(action)
-          val == action ? false : invoked_sync?(val)
+          if task_invoked?(task_join(name, ac)) && (!task_invoked?(ac) || !workspace.task_defined?(ac, 'sync'))
+            true
+          else
+            val = workspace.series.name_get(action)
+            val == action ? false : invoked_sync?(val)
+          end
         end
 
         def stdin?
@@ -776,18 +905,54 @@ 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
+        end
+
         def borderstyle
           if (data = workspace.banner_get(*@ref, group: group))
             data[:border]
           end
         end
 
+        def headerstyle
+          { pat: /^(\S+)(\s+)$/, styles: theme[:header] }
+        end
+
         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.base_project = Base
+      Application.impl_project = Base
+      Application.attr_banner = Common::SymSet.new(%i[name project path ref group parent])
     end
   end
 end