squared 0.4.18 → 0.5.0

data/lib/squared/workspace/project/support/class.rb

@@ -10,9 +10,6 @@ module Squared
           include Common::Shell
           extend Forwardable
 
-          OPT_VALUE = /\A([^=]+)=(.+)\z/
-          private_constant :OPT_VALUE
-
           class << self
             include Common::Format
             include Shell
@@ -34,11 +31,13 @@ module Squared
             def clear(target, opts, pass: true, styles: nil, **kwargs)
               return if opts.empty?
 
-              kwargs[:subject] ||= stripext(target.first)
+              kwargs[:subject] ||= stripext target.first
               kwargs[:hint] ||= 'unrecognized'
               append(target, opts, delim: true) if kwargs.delete(:append)
               warn log_message(Logger::WARN, opts.join(', '), pass: true, **kwargs)
-              exit 1 unless pass || confirm("Run? [#{sub_style(target, styles: styles)}] [y/N] ", 'N')
+              return if pass || confirm("Run? [#{sub_style(target, styles: styles)}] [y/N] ", 'N')
+
+              raise_error 'user cancelled'
             end
 
             def strip(val)
@@ -48,41 +47,26 @@ module Squared
               val.map { |s| s.sub(/\A-([a-z\d])(.+)\z/i, '\1=\2').sub(/\A--?/, '') }.reject(&:empty?)
             end
 
-            def select(list, bare: true, no: true, single: false, double: false)
-              ret = bare ? list.grep_v(/=/) : list.grep(/=/).map! { |val| val.split('=', 2).first }
-              ret.map! { |val| val.split('|', 2).last }
-              ret = ret.grep_v(/^no-/) unless no
-              return ret if single == double
-
-              ret.select { |val| single ? val.size == 1 : val.size > 1 }
-            end
-
             def arg?(target, *args, value: false, **)
               r, s = args.partition { |val| val.is_a?(Regexp) }
               unless s.empty?
-                s.map! { |val| Regexp.escape(shell_option(val)) }
+                s.map! { |val| Regexp.escape(val.start_with?('-') ? val : shell_option(val)) }
                 r << /\A(?:#{s.join('|')})#{value ? '[ =].' : '(?: |=|\z)'}/
               end
-              target.any? { |opt| r.any? { |val| opt&.match?(val) } }
-            end
-
-            def pattern?(val)
-              val.match?(/(?:\A\^|\$\z)/) || val.match?(/(?:\.[*+]|\(\?:|\\[dsw]|\[.+\]|\{\d+,?\d*\})/)
+              s = target.to_a.compact
+              r.any? { |pat| s.any?(pat) }
             end
           end
 
           attr_reader :target, :extras, :found, :errors, :values, :project, :path
 
           def_delegators :@target, :+, :-, :<<, :any?, :none?, :include?, :add, :add?, :find, :find_all, :find_index,
-                         :merge, :delete, :delete?, :delete_if, :grep, :grep_v, :inspect, :to_a, :to_s
+                         :merge, :delete, :delete?, :delete_if, :grep, :inspect, :to_a, :to_s
           def_delegators :@extras, :empty?, :each, :each_with_index, :partition, :dup, :first, :last, :shift, :unshift,
-                         :pop, :push, :concat, :index, :delete_at, :join, :map, :map!, :select, :reject, :size
-
-          def_delegator :@extras, :delete, :remove
-          def_delegator :@extras, :delete_if, :remove_if
+                         :pop, :push, :join, :map, :map!, :select, :reject, :size
 
           def initialize(opts, list, target = Set.new, project: nil, path: nil, **kwargs, &blk)
-            @target = target.is_a?(Set) ? target : Set.new(target)
+            @target = target.is_a?(Set) ? target : target.to_set
             @project = project
             @path = path || project&.path
             @errors = []
@@ -156,36 +140,35 @@ module Squared
             numcheck = ->(k, v) { numtype.any? { |flag, pat| flag.include?(k) && pat.match?(v) } }
             skip = false
             opts.each do |opt|
-              next skip = true if opt == '--'
-              next push opt if skip
+              next @extras << opt if skip
 
               if single&.match?(opt)
-                add "-#{opt}"
+                target << "-#{opt}"
               elsif bare.include?(opt)
-                add(opt.size == 1 ? "-#{opt}" : "--#{opt}")
+                target << (opt.size == 1 ? "-#{opt}" : "--#{opt}")
               elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
-                add "--no-#{name}"
+                target << "--no-#{name}"
               else
-                if opt =~ OPT_VALUE
+                if opt =~ /\A([^=]+)=(.+)\z/
                   key = $1
                   val = $2
                   merge = m.include?(key)
                   if e.include?(key)
-                    add shell_option(key, val, merge: merge)
+                    target << shell_option(key, val, merge: merge)
                   elsif q.include?(key)
-                    add quote_option(key, val, double: qq.include?(key), merge: merge)
+                    target << quote_option(key, val, double: qq.include?(key), merge: merge)
                   elsif p.include?(key) && path
-                    add quote_option(key, path + val, merge: merge)
+                    target << quote_option(key, path + val, merge: merge)
                   elsif b.include?(key) || numcheck.call(key, val)
-                    add basic_option(key, val, merge: merge)
+                    target << basic_option(key, val, merge: merge)
                   elsif merge
-                    add basic_option(key, val, merge: true)
+                    target << basic_option(key, val, merge: true)
                   else
-                    push opt
+                    @extras << opt
                   end
                   opt = key
                 else
-                  push opt
+                  @extras << opt
                   skip = true if args
                 end
                 skip = true if first&.any? { |s| s.is_a?(Regexp) ? opt.match?(s) : !opt.include?(s) }
@@ -206,27 +189,10 @@ module Squared
           end
 
           def append(*args, **kwargs)
-            args = extras if args.empty?
-            OptionPartition.append(target, *args, **kwargs)
+            OptionPartition.append(target, *(args.empty? ? extras : args), **kwargs)
             self
           end
 
-          def uniq(list)
-            items = map { |val| nameonly(val) }
-            list.reject do |val|
-              next true if items.include?(s = nameonly(val))
-
-              pat = /\A#{s = fill_option(s)}(?:#{s.start_with?('--') ? '[= ]' : '.*'}|\z)/
-              any? { |opt| opt.match?(pat) }
-            end
-          end
-
-          def uniq!(list)
-            n = size
-            concat uniq(list)
-            extras if size > n
-          end
-
           def clear(opts = nil, errors: false, **kwargs)
             styles = project.theme[:inline] if project
             if !opts
@@ -240,101 +206,82 @@ module Squared
             self
           end
 
-          def adjoin(*args, start: false)
-            i = -1
-            (items = to_a).each_with_index do |val, index|
-              if i == 0
-                next unless val.start_with?('-')
-
-                i = index
-                break
-              elsif index > 0 && !val.start_with?('-')
-                if start
-                  i = index + (start.is_a?(Numeric) ? start : 1)
-                  break
-                end
-                i = 0
-              end
-            end
-            if i > 0
-              if args.empty?
-                args = dup
-                reset
-              end
-              args = items[0...i] + args + items[i..-1]
-              target.clear
-            end
-            merge args
-            self
+          def arg?(*args, **kwargs)
+            OptionPartition.arg?(target, *args, **kwargs)
           end
+        end
 
-          def add_path(*args, **kwargs)
-            add shell_quote(path ? path.join(*args) : File.join(*args), **kwargs)
-            self
+        class JoinSet < Set
+          def self.to_s
+            super[/[^:]+\z/, 0]
           end
 
-          def add_quote(*args, **kwargs)
-            merge(args.map { |val| shell_quote(val, **kwargs) })
-            self
+          attr_reader :delim
+
+          def initialize(data = [], delim: ' ')
+            super(data.compact)
+            @delim = delim
           end
 
-          def splice(*exclude, quote: true, delim: true, path: false, pattern: false, &blk)
-            found, other = if block_given?
-                             partition(&blk)
-                           elsif exclude.first.is_a?(Symbol)
-                             partition(&exclude.first)
-                           else
-                             partition do |val|
-                               next false if pattern && OptionPartition.pattern?(val)
-
-                               exclude.none? { |pat| val.match?(Regexp.new(pat)) }
-                             end
-                           end
-            unless found.empty?
-              add '--' if delim
-              extras.clear
-              concat other
-              if path
-                found.each { |val| add_path(val) }
-              else
-                merge(quote ? found.map! { |val| shell_quote(val) } : found)
+          def last(val, pat)
+            (@last ||= []).append([val, pat, $1]) if val =~ pat
+            self << val
+          end
+
+          def pass(&blk)
+            ret = to_a.map!(&:to_s).reject(&:empty?)
+            @last&.each do |val, pat, key|
+              i = []
+              j = nil
+              ret.each_with_index do |opt, index|
+                if opt == val
+                  j = index
+                elsif j && opt[pat, 1] == key
+                  i << index
+                end
+              end
+              next unless j && !i.empty?
+
+              val = ret[j]
+              cur = j
+              i.each do |k|
+                ret[cur] = ret[k]
+                cur = k
               end
+              ret[i.last] = val
             end
-            self
+            block_given? ? ret.reject(&blk) : ret
           end
 
-          def append?(key, val = nil, type: nil, **kwargs)
-            return false if arg?(key)
-
-            val = yield self if block_given?
-            return false unless val
+          def and(*args)
+            self << '&&'
+            merge args
+          end
 
-            type ||= :quote if kwargs.empty?
-            op << case type
-                  when :quote
-                    quote_option(key, val)
-                  when :basic
-                    basic_option(key, val)
-                  else
-                    shell_option(key, val, **kwargs)
-                  end
-            true
+          def or(*args)
+            self << '||'
+            merge args
           end
 
-          def reset(errors: false)
-            extras.clear
-            clear(errors: true) if errors
-            self
+          def with(*args, &blk)
+            temp('&&', *args, &blk)
           end
 
-          def arg?(*args, **kwargs)
-            OptionPartition.arg?(target, *args, **kwargs)
+          def temp(*args, &blk)
+            args.compact!
+            ret = pass(&blk)
+            ret = Set.new(ret.concat(args)).to_a unless args.empty?
+            ret.join(@delim)
           end
 
-          private
+          def done
+            ret = to_s
+            clear
+            ret
+          end
 
-          def nameonly(val)
-            val[OPT_VALUE, 1] || val
+          def to_s
+            pass.join(@delim)
           end
         end
       end

data/lib/squared/workspace/project.rb

@@ -3,16 +3,6 @@
 module Squared
   module Workspace
     module Project
-      class << self
-        attr_accessor :line_width
-
-        def max_width(lines)
-          n = [lines.max_by(&:size).size, 80].max
-          [n, Rake.application.terminal_width].min
-        end
-      end
-
-      @line_width = ENV.fetch('LOG_COLUMNS', 80).to_i
     end
   end
 end

data/lib/squared/workspace/repo.rb

@@ -57,10 +57,10 @@ module Squared
                               when 'verbose'
                                 @verbose = 1
                                 if script.is_a?(Array)
-                                  script[0] = task_join(script[0], 'verbose')
+                                  script[0] = task_join script[0], 'verbose'
                                   script
                                 else
-                                  task_join(script, 'verbose')
+                                  task_join script, 'verbose'
                                 end
                               when 'silent'
                                 @verbose = false
@@ -81,8 +81,8 @@ module Squared
             data[:run] = run
           end
           data[:global] = true
-          data[:dev] = env_match('REPO_DEV', dev)
-          data[:prod] = env_match('REPO_PROD', prod)
+          data[:dev] = env_match 'REPO_DEV', dev
+          data[:prod] = env_match 'REPO_PROD', prod
           if (val = env('REPO_GROUP'))
             script_set(data, group: val.split(','))
             found = true
@@ -113,41 +113,56 @@ module Squared
       def __repo__(**kwargs)
         kwargs.delete(:parallel) if env('REPO_SYNC', ignore: '0')
 
-        namespace task_name('repo') do |ns|
-          path = ns.scope.path
+        namespace(name = task_name('repo')) do |repo|
           branch = env('REPO_MANIFEST') || Repo.read_manifest(root)
           target = branch || manifest
-          cmd = nil
           stage = nil
-          opts = %w[force rebase detach submodules fail no-update gc]
+          failfast = true
+          cmd = []
           newline = ARGV.index { |val| val.start_with?('repo:') }.to_i > 0
+          parse_opts = lambda do |args|
+            args.to_a.each do |val|
+              case val
+              when 'no-fail'
+                failfast = false
+              when 'force'
+                cmd << '--force-checkout'
+              when 'rebase'
+                cmd << '--rebase'
+              when 'detach'
+                cmd << '--detach'
+              when 'gc'
+                cmd << '--auto-gc'
+              when 'no-update'
+                cmd << '--no-manifest-update'
+              end
+            end
+          end
           desc = lambda do |val, alt = nil|
             if (ver = branch || alt)
-              val = val.sub('{0}', "opts*=#{opts.join(',')}")
-              task_desc(path, val, ver)
+              val = val.sub('{0}', 'opts*=force,rebase,detach,gc,no-update,no-fail')
+              task_desc(task_name('repo'), val, ver)
             else
               task_desc 'inactive'
             end
           end
 
           desc.call('all[{0}]')
-          task 'all' do |_, args|
-            cmd ||= repo_opts args
+          task 'all', [:opts] do |_, args|
+            parse_opts.call(args)
             stage ||= 'all'
-            ns['sync'].invoke
-            next if env('REPO_STAGE', equals: '1')
+            repo['sync'].invoke
+            next if env('REPO_DRYRUN', equals: '2')
 
             @project.select do |_, proj|
               next unless proj.enabled?(proj.workspace.baseref)
 
               proj.depend(sync: true) if proj.depend?
-              next if env('REPO_STAGE', equals: '2')
-
-              proj.build?
+              proj.build? unless env('REPO_DRYRUN', ignore: '0')
             end
             .each_value do |proj|
               proj.build(sync: true)
-              next unless proj.dev? && proj.copy? && !env('REPO_STAGE', equals: '3')
+              next unless proj.dev? && proj.copy?
 
               if (ws = proj.workspace).task_defined?(target = task_join(proj.name, 'copy'))
                 task_invoke(target, **ws.invokeargs)
@@ -157,57 +172,39 @@ module Squared
             end
           end
 
-          desc.call("init[manifest?=#{target},groups?,{0}]", target)
-          task 'init' do |_, args|
-            args = args.to_a
-            u = env('REPO_URL') || manifest_url
-            m = args.first && !opts.include?(args.first) ? args.shift : target
-            g = case (g = env('REPO_GROUPS'))
-                when '0', 'false'
-                  nil
-                else
-                  g || (args.first && !opts.include?(args.first) ? args.shift : nil)
-                end
-            cmd = repo_opts args
-            s = case (s = env('REPO_SUBMODULES'))
-                when '0', 'false'
-                  false
-                else
-                  s ? true : cmd.include?('--fetch-submodules')
-                end
+          desc.call("init[manifest?=#{target},{0}]", target)
+          task 'init', [:manifest, :opts] do |_, args|
+            parse_opts.call(args)
             stage = 'init'
             puts if newline
-            args = ["-u #{u}", "-m #{m}.xml"]
-            args << "-g #{g}" if g
-            args << '--submodules' if s
-            Common::System.shell("#{repo_bin} init #{args.join(' ')}", chdir: root)
-            next if env('REPO_STAGE', equals: '0')
-
-            ns['all'].invoke
+            system("repo init -u #{env('REPO_URL') || manifest_url} -m #{args.manifest || target}.xml", chdir: root)
+            repo['all'].invoke
           end
 
           desc.call('sync[{0}]')
-          task 'sync' do |t, args|
-            raise_error 'repo not initialized' unless branch || stage == 'init'
-            cmd ||= repo_opts args
+          task 'sync', [:opts] do |_, args|
+            unless branch || stage == 'init'
+              raise_error('repo not initialized', hint: task_name('repo:init'), kind: LoadError)
+            end
+            parse_opts.call(args)
             cmd << "-j#{ENV.fetch('REPO_JOBS', Rake::CpuCounter.count)}"
-            puts unless !newline || stage == 'init'
+            cmd << '--fail-fast' if failfast
+            puts if newline && stage != 'init'
             begin
-              Common::System.shell("#{repo_bin} sync #{cmd.join(' ')}", chdir: root,
-                                                                        exception: cmd.include?('--fail-fast'))
+              Common::System.shell("repo sync #{cmd.join(' ')}", chdir: root, exception: failfast)
             rescue Errno::ENOENT => e
               emphasize(e, title: root)
               raise
             rescue StandardError => e
-              emphasize(e, title: "rake stash #{t.name}")
+              emphasize(e, title: "rake stash #{task_name(task_join('repo', stage || 'sync'))}")
               raise
             end
           end
 
-          series.sync.push(
-            task_join(path, 'all'),
-            task_join(path, 'init'),
-            task_join(path, 'sync')
+          series.sync.append(
+            task_join(name, 'all'),
+            task_join(name, 'init'),
+            task_join(name, 'sync')
           )
         end
       end
@@ -223,31 +220,6 @@ module Squared
         )
       end
 
-      def repo_opts(args)
-        ret = []
-        args.to_a.each do |val|
-          case val
-          when 'force'
-            ret << '--force-checkout'
-          when 'rebase', 'detach'
-            ret << "--#{val}"
-          when 'submodules'
-            ret << '--fetch-submodules'
-          when 'fail'
-            ret << '--fail-fast'
-          when 'no-update'
-            ret << '--no-manifest-update'
-          when 'gc'
-            ret << '--auto-gc'
-          end
-        end
-        ret
-      end
-
-      def repo_bin
-        Common::Shell.shell_bin('repo')
-      end
-
       def repo?
         !manifest_url.nil? && (repo_install? || @repo_override == true)
       end

data/lib/squared/workspace/series.rb

@@ -10,16 +10,16 @@ module Squared
 
       TASK_BASE = []
       TASK_BATCH = {}
-      TASK_EXTEND = Support.hashlist
+      TASK_EXTEND = {}
       TASK_KEYS = []
-      TASK_ALIAS = Support.hashobj
+      TASK_ALIAS = {}
       TASK_NAME = {}
       private_constant :TASK_BASE, :TASK_BATCH, :TASK_EXTEND, :TASK_KEYS, :TASK_ALIAS, :TASK_NAME
 
       class << self
         def add(task, obj)
           key_set task
-          TASK_EXTEND[task] << obj
+          (TASK_EXTEND[task] ||= []) << obj
         end
 
         def batch(*args, obj)
@@ -37,7 +37,7 @@ module Squared
 
         def alias(ref, obj)
           if obj.is_a?(Hash)
-            obj.each { |key, val| TASK_ALIAS[key][ref] = val }
+            obj.each { |key, val| (TASK_ALIAS[key] ||= {})[ref] = val }
           else
             TASK_ALIAS[obj]&.delete(ref)
           end
@@ -68,7 +68,7 @@ module Squared
 
       attr_reader :sync, :multiple, :parallel
 
-      def_delegators :@data, :[], :each, :each_key, :keys, :fetch, :to_a, :to_s, :inspect, :merge!, :key?
+      def_delegators :@data, :[], :each, :each_key, :keys, :key?, :fetch, :update, :merge!, :to_a, :to_s, :inspect
       def_delegators :@workspace, :task_desc, :task_name, :task_namespace, :task_join, :format_desc
 
       def initialize(workspace, exclude: [])
@@ -79,8 +79,8 @@ module Squared
         @chain = {}
         @exclude = exclude.freeze
         @session = {
-          group: Support.hashlist,
-          parent: Support.hashlist,
+          group: {},
+          parent: {},
           id: []
         }
         @data = {}
@@ -95,7 +95,7 @@ module Squared
 
           if (g = proj.group)
             id << g
-            group[:"#{key}:#{g}"].concat(tasks)
+            (group[:"#{key}:#{g}"] ||= []).concat(tasks)
           else
             items.concat(tasks)
           end
@@ -106,35 +106,35 @@ module Squared
           next unless (b = ws.find_base(proj)) && (n = b.ref.to_s) != g
 
           id << n
-          parent[:"#{key}:#{n}"].concat(tasks)
+          (parent[:"#{key}:#{n}"] ||= []).concat(tasks)
         end
       end
 
       def build(parallel: [], pattern: [], **)
         subcheck = ->(val) { (ns = task_namespace(val)) && parallel.include?(ns) }
-        @data.merge!(@session[:parent]) if @session[:id].uniq.size > 1
-        @data.merge!(@session[:group])
+        @data.update(@session[:parent]) if @session[:id].uniq.size > 1
+        @data.update(@session[:group])
         @data.each do |key, items|
           next if exclude?(key, true) || @workspace.task_exclude?(t = name_get(key))
 
           key = task_name t
-          val = format_desc(key, out: true)
+          title = format_desc(key, out: true)
           if items.size > 1
             @multiple << key
             if parallel.include?(t) || pattern.any? { |pat| t.match?(pat) } || subcheck.call(t)
-              task_desc("#{val} (thread)", name: key)
+              task_desc("#{title} (thread)", name: key) if title
               multitask key => items
               @parallel << key
 
-              s = task_join(key, 'sync')
-              task_desc("#{val} (sync)", name: s)
+              s = task_join key, 'sync'
+              task_desc("#{title} (sync)", name: s) if title
               task s => items
               @sync << s
               next
             end
           end
 
-          task_desc(val, name: key)
+          task_desc(title, name: key) if title
           task key => items
         end
         @multiple.concat(sync)

data/lib/squared/workspace/support/data.rb

@@ -3,8 +3,9 @@
 module Squared
   module Workspace
     module Support
-      RunData = Struct.new('RunData', :run, :block)
-      ChainData = Struct.new('ChainData', :action, :step, :with, :before, :after, :sync)
+      RunData = Struct.new(:run, :block)
+      ChainData = Struct.new(:action, :step, :with, :before, :after, :sync)
+      BannerData = Struct.new(:command, :order, :styles, :border)
     end
   end
 end

data/lib/squared/workspace/support.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
-require_relative 'support/base'
 require_relative 'support/data'

data/lib/squared/workspace.rb

@@ -10,7 +10,7 @@ module Squared
           if id.is_a?(Symbol)
             project id
           else
-            __get__(:project).find { |_, val| File.expand_path(val.path) == File.expand_path(id) }
+            __get__(:project).find { |_, val| File.expand_path(val.path) == File.expand_path(id, __dir__) }
           end
         end
         ret.size == 1 ? ret.first : ret