squared 0.4.16 → 0.4.18

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

@@ -10,6 +10,9 @@ module Squared
           include Common::Shell
           extend Forwardable
 
+          OPT_VALUE = /\A([^=]+)=(.+)\z/
+          private_constant :OPT_VALUE
+
           class << self
             include Common::Format
             include Shell
@@ -45,6 +48,15 @@ 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?
@@ -53,14 +65,21 @@ module Squared
               end
               target.any? { |opt| r.any? { |val| opt&.match?(val) } }
             end
+
+            def pattern?(val)
+              val.match?(/(?:\A\^|\$\z)/) || val.match?(/(?:\.[*+]|\(\?:|\\[dsw]|\[.+\]|\{\d+,?\d*\})/)
+            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, :inspect, :to_a, :to_s
+                         :merge, :delete, :delete?, :delete_if, :grep, :grep_v, :inspect, :to_a, :to_s
           def_delegators :@extras, :empty?, :each, :each_with_index, :partition, :dup, :first, :last, :shift, :unshift,
-                         :pop, :push, :index, :delete_at, :join, :map, :map!, :select, :reject, :size
+                         :pop, :push, :concat, :index, :delete_at, :join, :map, :map!, :select, :reject, :size
+
+          def_delegator :@extras, :delete, :remove
+          def_delegator :@extras, :delete_if, :remove_if
 
           def initialize(opts, list, target = Set.new, project: nil, path: nil, **kwargs, &blk)
             @target = target.is_a?(Set) ? target : Set.new(target)
@@ -138,35 +157,35 @@ module Squared
             skip = false
             opts.each do |opt|
               next skip = true if opt == '--'
-              next @extras << opt if skip
+              next push opt if skip
 
               if single&.match?(opt)
-                target << "-#{opt}"
+                add "-#{opt}"
               elsif bare.include?(opt)
-                target << (opt.size == 1 ? "-#{opt}" : "--#{opt}")
+                add(opt.size == 1 ? "-#{opt}" : "--#{opt}")
               elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
-                target << "--no-#{name}"
+                add "--no-#{name}"
               else
-                if opt =~ /\A([^=]+)=(.+)\z/
+                if opt =~ OPT_VALUE
                   key = $1
                   val = $2
                   merge = m.include?(key)
                   if e.include?(key)
-                    target << shell_option(key, val, merge: merge)
+                    add shell_option(key, val, merge: merge)
                   elsif q.include?(key)
-                    target << quote_option(key, val, double: qq.include?(key), merge: merge)
+                    add quote_option(key, val, double: qq.include?(key), merge: merge)
                   elsif p.include?(key) && path
-                    target << quote_option(key, path + val, merge: merge)
+                    add quote_option(key, path + val, merge: merge)
                   elsif b.include?(key) || numcheck.call(key, val)
-                    target << basic_option(key, val, merge: merge)
+                    add basic_option(key, val, merge: merge)
                   elsif merge
-                    target << basic_option(key, val, merge: true)
+                    add basic_option(key, val, merge: true)
                   else
-                    @extras << opt
+                    push opt
                   end
                   opt = key
                 else
-                  @extras << opt
+                  push opt
                   skip = true if args
                 end
                 skip = true if first&.any? { |s| s.is_a?(Regexp) ? opt.match?(s) : !opt.include?(s) }
@@ -192,6 +211,22 @@ module Squared
             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
@@ -229,10 +264,63 @@ module Squared
               args = items[0...i] + args + items[i..-1]
               target.clear
             end
-            merge(args)
+            merge args
             self
           end
 
+          def add_path(*args, **kwargs)
+            add shell_quote(path ? path.join(*args) : File.join(*args), **kwargs)
+            self
+          end
+
+          def add_quote(*args, **kwargs)
+            merge(args.map { |val| shell_quote(val, **kwargs) })
+            self
+          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)
+              end
+            end
+            self
+          end
+
+          def append?(key, val = nil, type: nil, **kwargs)
+            return false if arg?(key)
+
+            val = yield self if block_given?
+            return false unless val
+
+            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
+          end
+
           def reset(errors: false)
             extras.clear
             clear(errors: true) if errors
@@ -242,6 +330,12 @@ module Squared
           def arg?(*args, **kwargs)
             OptionPartition.arg?(target, *args, **kwargs)
           end
+
+          private
+
+          def nameonly(val)
+            val[OPT_VALUE, 1] || val
+          end
         end
       end
     end

data/lib/squared/workspace/repo.rb

@@ -113,56 +113,41 @@ module Squared
       def __repo__(**kwargs)
         kwargs.delete(:parallel) if env('REPO_SYNC', ignore: '0')
 
-        namespace(name = task_name('repo')) do |repo|
+        namespace task_name('repo') do |ns|
+          path = ns.scope.path
           branch = env('REPO_MANIFEST') || Repo.read_manifest(root)
           target = branch || manifest
+          cmd = nil
           stage = nil
-          failfast = true
-          cmd = []
+          opts = %w[force rebase detach submodules fail no-update gc]
           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*=force,rebase,detach,gc,no-update,no-fail')
-              task_desc(task_name('repo'), val, ver)
+              val = val.sub('{0}', "opts*=#{opts.join(',')}")
+              task_desc(path, val, ver)
             else
               task_desc 'inactive'
             end
           end
 
           desc.call('all[{0}]')
-          task 'all', [:opts] do |_, args|
-            parse_opts.call(args)
+          task 'all' do |_, args|
+            cmd ||= repo_opts args
             stage ||= 'all'
-            repo['sync'].invoke
-            next if env('REPO_DRYRUN', equals: '2')
+            ns['sync'].invoke
+            next if env('REPO_STAGE', equals: '1')
 
             @project.select do |_, proj|
               next unless proj.enabled?(proj.workspace.baseref)
 
               proj.depend(sync: true) if proj.depend?
-              proj.build? unless env('REPO_DRYRUN', ignore: '0')
+              next if env('REPO_STAGE', equals: '2')
+
+              proj.build?
             end
             .each_value do |proj|
               proj.build(sync: true)
-              next unless proj.dev? && proj.copy?
+              next unless proj.dev? && proj.copy? && !env('REPO_STAGE', equals: '3')
 
               if (ws = proj.workspace).task_defined?(target = task_join(proj.name, 'copy'))
                 task_invoke(target, **ws.invokeargs)
@@ -172,40 +157,57 @@ module Squared
             end
           end
 
-          desc.call("init[manifest?=#{target},{0}]", target)
-          task 'init', [:manifest, :opts] do |_, args|
-            parse_opts.call(args)
+          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
             stage = 'init'
             puts if newline
-            Common::System.shell("repo init -u #{env('REPO_URL') || manifest_url} -m #{args.manifest || target}.xml",
-                                 chdir: root)
-            repo['all'].invoke
+            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
           end
 
           desc.call('sync[{0}]')
-          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)
+          task 'sync' do |t, args|
+            raise_error 'repo not initialized' unless branch || stage == 'init'
+            cmd ||= repo_opts args
             cmd << "-j#{ENV.fetch('REPO_JOBS', Rake::CpuCounter.count)}"
-            cmd << '--fail-fast' if failfast
-            puts if newline && stage != 'init'
+            puts unless !newline || stage == 'init'
             begin
-              Common::System.shell("repo sync #{cmd.join(' ')}", chdir: root, exception: failfast)
+              Common::System.shell("#{repo_bin} sync #{cmd.join(' ')}", chdir: root,
+                                                                        exception: cmd.include?('--fail-fast'))
             rescue Errno::ENOENT => e
               emphasize(e, title: root)
               raise
             rescue StandardError => e
-              emphasize(e, title: "rake stash #{task_name(task_join('repo', stage || 'sync'))}")
+              emphasize(e, title: "rake stash #{t.name}")
               raise
             end
           end
 
           series.sync.push(
-            task_join(name, 'all'),
-            task_join(name, 'init'),
-            task_join(name, 'sync')
+            task_join(path, 'all'),
+            task_join(path, 'init'),
+            task_join(path, 'sync')
           )
         end
       end
@@ -221,6 +223,31 @@ 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/squared.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Rake task generator for managing multi-language workspaces.}
   spec.description   = %q{Rake task generator for managing multi-language workspaces.}
-  spec.homepage      = "https://github.com/anpham6/squared"
+  spec.homepage      = "https://github.com/anpham6/squared-ruby"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
   spec.licenses      = ["BSD-3-Clause"]
 
@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.metadata["documentation_uri"] = "https://squared.readthedocs.io"
 
   spec.files         = Dir["lib/**/*"] +
-                       %w[CHANGELOG.md LICENSE README.md README.ruby.md squared.gemspec]
+                       %w[CHANGELOG.md LICENSE README.md squared.gemspec]
   spec.bindir        = "exe"
   spec.executables   = []
   spec.require_paths = ["lib"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.4.16
+  version: 0.4.18
 platform: ruby
 authors:
 - An Pham
@@ -75,7 +75,6 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
-- README.ruby.md
 - lib/squared.rb
 - lib/squared/app.rb
 - lib/squared/common.rb
@@ -105,12 +104,12 @@ files:
 - lib/squared/workspace/support/base.rb
 - lib/squared/workspace/support/data.rb
 - squared.gemspec
-homepage: https://github.com/anpham6/squared
+homepage: https://github.com/anpham6/squared-ruby
 licenses:
 - BSD-3-Clause
 metadata:
-  homepage_uri: https://github.com/anpham6/squared
-  source_code_uri: https://github.com/anpham6/squared
+  homepage_uri: https://github.com/anpham6/squared-ruby
+  source_code_uri: https://github.com/anpham6/squared-ruby
   documentation_uri: https://squared.readthedocs.io
 rdoc_options: []
 require_paths: