squared 0.6.9 → 0.7.1

data/lib/squared/workspace/repo.rb

@@ -6,45 +6,54 @@ module Squared
       REPO_URL = 'https://storage.googleapis.com/git-repo-downloads/repo'
       private_constant :REPO_URL
 
-      attr_reader :manifest_url, :manifest
-
-      def repo(url, manifest = 'latest', install: nil, run: nil, script: nil, args: nil, dev: nil, prod: nil,
-               ref: @ref, group: @group)
-        @home = if (val = env('REPO_HOME'))
-                  path = Pathname.new(val)
-                  if main == path.basename.to_s
-                    @root = path.parent
-                    if path.exist?
-                      @root = nil unless path.directory?
-                    elsif !@root.exist?
-                      @root.mkpath
-                    elsif !repo_install? && !repo_confirm
-                      @root = nil
-                    end
-                    raise_error Errno::EEXIST, path.cleanpath, hint: 'REPO_HOME' unless @root
-                  end
-                  path.realdirpath
-                elsif (val = env('REPO_ROOT'))
-                  @root = Pathname.new(val).realdirpath
-                  if !@root.exist?
-                    @root.mkpath
-                  elsif !repo_install?(parent: true) && !repo_confirm
-                    raise_error Errno::EEXIST, @root, hint: 'REPO_ROOT'
-                  end
-                  @root.join(main).realdirpath
-                elsif repo_install?(parent: true) && (!@home.exist? || @root + main == @home)
-                  @home
-                elsif repo_install?(@home)
-                  @home + main
-                else
-                  (path = pwd) == @home || !repo_install?(path) ? @home : path + main
-                end
-        @root = @home.parent
-        @manifest_url = url
-        @manifest = manifest
+      def repo(url, manifest = 'latest', run: nil, script: nil, args: nil, dev: nil, prod: nil, doc: false, test: false,
+               lint: false, install: nil, name: nil, ref: @ref, group: @group)
+        if @repo_bin.nil?
+          self.home = if (val = env('REPO_HOME'))
+                        path = Pathname.new(val)
+                        if main == path.basename.to_s
+                          @root = path.parent
+                          if path.exist?
+                            @root = nil unless path.directory?
+                          elsif !@root.exist?
+                            @root.mkpath
+                          elsif !repo_install? && !repo_confirm
+                            @root = nil
+                          end
+                          raise_error Errno::EEXIST, path.cleanpath, hint: 'REPO_HOME' unless @root
+                        end
+                        path.realdirpath
+                      elsif (val = env('REPO_ROOT'))
+                        @root = Pathname.new(val).realdirpath
+                        if !@root.exist?
+                          @root.mkpath
+                        elsif !repo_install?(parent: true) && !repo_confirm
+                          raise_error Errno::EEXIST, @root, hint: 'REPO_ROOT'
+                        end
+                        @root.join(main).realdirpath
+                      elsif repo_install?(parent: true) && (!home.exist? || @root + main == home)
+                        home
+                      elsif repo_install?(home)
+                        home + main
+                      else
+                        pwd == home || !repo_install?(pwd) ? home : pwd + main
+                      end
+          @repo_bin = if install
+                        install.is_a?(String) ? @root + install : @root
+                      else
+                        false
+                      end
+        end
+        envargs = name ? { suffix: name.upcase, strict: true } : {}
         data = scriptobj
         if repo?
-          sc, ru = env('REPO_BUILD', '').split(',', 2).map!(&:strip)
+          group = env('REPO_GROUP', **envargs) { |val| split_escape(val) }
+          ref = env('REPO_REF', **envargs) { |val| split_escape(val) }
+          data[:dev] = env_match('REPO_DEV', dev, **envargs)
+          data[:prod] = env_match('REPO_PROD', prod, **envargs)
+          @warning = env_match('REPO_WARN', @warning && !root?(@root, pass: ['.repo'])) != false unless name
+          sc, ru = split_escape(env('REPO_BUILD', '', **envargs), limit: 2)
+          global = data[:global]
           if script
             data[:script] = if sc.to_s.empty?
                               script
@@ -67,8 +76,8 @@ module Squared
                                 sc
                               end
                             end
-            data[:args] = (val = env('REPO_SCRIPT')) ? shell_split(val, join: true) : args
-            data[:global][:script] = true
+            data[:args] = env('REPO_SCRIPT', **envargs) { |val| shell_split(val, join: true) } || args
+            global[:script] = true
           else
             ru ||= sc
           end
@@ -79,20 +88,12 @@ module Squared
                            data[:env][:run] = true
                            ru
                          end
-            data[:global][:run] = true
-          end
-          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
-          end
-          if (val = env('REPO_REF'))
-            script_set(data, ref: val.split(','))
-            found = true
+            global[:run] = true
           end
-          script_set(data, group: group, ref: ref) unless found
-          @warning = env_match('REPO_WARN', @warning && !root?(@root, pass: ['.repo'])) != false
+          global[:doc] = doc
+          global[:lint] = lint
+          global[:test] = test
+          script_set('repo', data, name: name, group: group, ref: ref, extras: { url: url, manifest: manifest })
           @extensions << :__repo__
         elsif script || run
           if script
@@ -102,126 +103,150 @@ module Squared
           data[:run] = run if run
           data[:dev] = dev
           data[:prod] = prod
-          script_set(data, group: group, ref: ref)
+          script_set('repo', data, name: name, group: group, ref: ref)
         end
-        @repo_bin = install.is_a?(String) ? @root + install : @root if install
         self
       end
 
+      def repo?(active = false)
+        active ? @extensions.include?(:__repo__) : !windows? && (repo_install? || @repo_override == true)
+      end
+
       private
 
       def __repo__(**kwargs)
+        self.closed = 'repo:begin'
         kwargs.delete(:parallel) if env('REPO_SYNC', ignore: '0')
-
-        namespace task_name('repo') do |ns|
-          path = ns.scope.path
-          branch = env('REPO_MANIFEST') || repo_manifest
-          target = branch || manifest
-          stage = nil
-          opts = %w[force rebase detach submodules fail no-update gc]
-          desc = lambda do |val, alt = nil|
-            if (ver = branch || alt)
-              val = val.sub('{0}', "opts*=#{opts.join(',')}")
-              task_desc(path, val, ver)
-            else
-              task_desc 'inactive'
+        script_each 'repo' do |name, data|
+          namespace task_name(name == '_' ? 'repo' : "repo:#{name}") do |ns|
+            path = ns.scope.path
+            envargs = name == '_' ? {} : { suffix: name.upcase, strict: true }
+            branch = env('REPO_MANIFEST', **envargs) || repo_manifest
+            target = branch || data[:extras][:manifest]
+            stage = nil
+            opts = %w[force rebase detach submodules fail no-update gc]
+            desc = lambda do |val, alt = nil|
+              if (ver = branch || alt)
+                val = val.sub('{0}', "opts*=#{opts.join(',')}")
+                task_desc(path, val, ver)
+              else
+                task_desc 'inactive'
+              end
             end
-          end
 
-          desc.call('all[{0}]')
-          task 'all' do |_, args|
-            stage ||= 'all'
-            ns['sync'].invoke(*args.to_a)
-            next if (n = env('REPO_STAGE')) == '1'
+            desc.call('all[{0}]')
+            task 'all' do |_, args|
+              stage ||= 'all'
+              ns['sync'].invoke(*args.to_a)
+              next if (n = env('REPO_STAGE', **envargs).to_i).anybits?(1)
 
-            select do |proj|
-              next unless proj.enabled?(proj.workspace.baseref) && proj.global
+              if (val = env('REPO_SERIES', **envargs))
+                split_escape(val) do |meth|
+                  meth, sync = meth.split(':', 2)
+                  repo_workspace(name).each do |proj|
+                    repo_call(proj, meth, sync: (sync != 'parallel' unless sync == 'detect'))
+                  end
+                end
+              else
+                repo_workspace(name).map do |proj|
+                  proj.depend(sync: true) if proj.depend?
+                  next [] if n.anybits?(2)
+
+                  run, script, doc, lint, test = proj.scriptdata(:global, name: name)
+                                                     .fetch_values(:run, :script, :doc, :lint, :test)
+                  [proj, proj.build? && (script || run), doc && proj.doc?, lint && proj.lint?, test && proj.test?]
+                end
+                .select do |proj, run, doc, lint, test|
+                  next unless proj
+
+                  proj.doc(sync: true) if doc
+                  proj.build(sync: true) if run
+                  next if n.anybits?(4)
+
+                  repo_call proj, 'copy' if run && proj.copy? && (proj.dev? || n.anybits?(512))
+                  next if n.anybits?(8)
 
-              proj.depend(sync: true) if proj.depend?
-              next if n == '2'
+                  proj.lint(sync: true) if lint
+                  next if n.anybits?(16)
 
-              proj.build?
+                  test
+                end
+                .each { |proj| proj.test(sync: true) }
+              end
             end
-            .each do |proj|
-              proj.build(sync: true)
-              next if n == '3'
-              next unless proj.copy? && (proj.dev? || n == '4')
 
-              if (ws = proj.workspace).task_defined?(target = task_join(proj.name, 'copy'))
-                task_invoke(target, **ws.invokeargs)
-              else
-                proj.copy
+            desc.call("init[manifest?=#{target},groups?,{0}]", target)
+            task 'init' do |_, args|
+              args = args.to_a
+              u = env('REPO_GIT', **envargs) || data[:extras][:url]
+              check = -> { args.first && !opts.include?(args.first) }
+              if check.call
+                m = args.shift
+                g = args.shift if check.call
               end
+              env('REPO_GROUPS', **envargs) do |val|
+                g = case val
+                    when '0', 'false'
+                      nil
+                    else
+                      val
+                    end
+              end
+              stage = 'init'
+              opts = repo_opts "-u #{u}", "-m #{m || target}.xml"
+              opts << "-g #{g}" if g
+              opts << '--submodules' if repo_submodules?(args.include?('submodules'), **envargs)
+              repo_run 'init', opts
+              next if env('REPO_STAGE', equals: '0', **envargs)
+
+              ns['all'].invoke(*args)
             end
-          end
 
-          desc.call("init[manifest?=#{target},groups?,{0}]", target)
-          task 'init' do |_, args|
-            args = args.to_a
-            u = env('REPO_GIT') || manifest_url
-            m = args.first && !opts.include?(args.first) ? args.shift : target
-            g = (args.shift if args.first && !opts.include?(args.first))
-            g = case (val = env('REPO_GROUPS'))
-                when '', NilClass
-                  g
-                when '0', 'false'
-                  nil
-                else
-                  val
+            desc.call('sync[{0}]')
+            task 'sync' do |t, args|
+              opts = if stage == 'init'
+                       []
+                     else
+                       raise_error 'repo not initialized' unless branch
+                       repo_opts
+                     end
+              args.to_a.each do |val|
+                case val
+                when /^force(-checkout)?$/
+                  opts << '--force-checkout'
+                when 'rebase', 'detach'
+                  opts << "--#{val}"
+                when /^(fetch-)?submodules$/
+                  opts << '--fetch-submodules' if repo_submodules?(true, **envargs)
+                when /^(fail-)?fail$/
+                  opts << '--fail-fast'
+                when /^no-(manifest-)?update$/
+                  opts << '--no-manifest-update'
+                when /^(auto-)?gc$/
+                  opts << '--auto-gc'
                 end
-            stage = 'init'
-            opts = repo_opts "-u #{u}", "-m #{m}.xml"
-            opts << "-g #{g}" if g
-            opts << '--submodules' if repo_submodules?(args.include?('submodules'))
-            repo_run "#{repo_bin} init #{opts.uniq.join(' ')}"
-            next if env('REPO_STAGE', equals: '0')
-
-            ns['all'].invoke(*args)
-          end
-
-          desc.call('sync[{0}]')
-          task 'sync' do |t, args|
-            opts = if stage == 'init'
-                     []
-                   else
-                     raise_error 'repo not initialized' unless branch
-                     repo_opts
-                   end
-            args.to_a.each do |val|
-              case val
-              when 'force'
-                opts << '--force-checkout'
-              when 'rebase', 'detach'
-                opts << "--#{val}"
-              when 'submodules'
-                opts << '--fetch-submodules' if repo_submodules?(true)
-              when 'fail'
-                opts << '--fail-fast'
-              when 'no-update'
-                opts << '--no-manifest-update'
-              when 'gc'
-                opts << '--auto-gc'
+              end
+              opts << "-j#{ENV.fetch('REPO_JOBS', Rake::CpuCounter.count)}" unless opts.any?(/^--?j(obs)?$/)
+              opts << '--fetch-submodules' if repo_submodules?(**envargs)
+              begin
+                repo_run('sync', opts, exception: opts.include?('--fail-fast'), options: stage != 'init')
+              rescue Errno::ENOENT => e
+                emphasize(e, title: root)
+                raise
+              rescue => e
+                emphasize(e, title: "rake stash #{t.name}")
+                raise
               end
             end
-            opts << "-j#{ENV.fetch('REPO_JOBS', Rake::CpuCounter.count)}" unless opts.any?(/^--?j(?:obs)?/)
-            opts << '--fetch-submodules' if repo_submodules?
-            begin
-              repo_run("#{repo_bin} sync #{opts.uniq.join(' ')}", exception: opts.include?('--fail-fast'))
-            rescue Errno::ENOENT => e
-              emphasize(e, title: root)
-              raise
-            rescue StandardError => e
-              emphasize(e, title: "rake stash #{t.name}")
-              raise
-            end
-          end
 
-          series.sync.push(
-            task_join(path, 'all'),
-            task_join(path, 'init'),
-            task_join(path, 'sync')
-          )
+            series.sync.push(
+              task_join(path, 'all'),
+              task_join(path, 'init'),
+              task_join(path, 'sync')
+            )
+          end
         end
+        self.closed = 'repo:end'
       end
 
       def repo_manifest(path = root)
@@ -244,12 +269,16 @@ module Squared
                          else
                            Common::Prompt.confirm(
                              "#{log_title(:warn)} \"#{path}\" is not empty. Continue with installation?", 'N',
-                             force: true, timeout: env('REPO_TIMEOUT').to_i.yield_self { |n| n > 0 ? n : 15 }
+                             force: true, timeout: env('REPO_TIMEOUT') { |n| n if (n = n.to_i) > 0 } || 15
                            )
                          end
       end
 
-      def repo_run(cmd, exception: false)
+      def repo_run(cmd, opts = [], exception: false, options: true, **kwargs)
+        cmd = [repo_bin, cmd]
+        cmd << opts.uniq.join(' ') unless opts.empty?
+        env('REPO_OPTIONS', **kwargs) { |val| cmd << val } if options
+        cmd = cmd.join(' ')
         puts log_message(cmd, subject: main, hint: root) if verbose
         Common::System.shell(cmd, chdir: root, exception: exception)
       end
@@ -257,35 +286,71 @@ module Squared
       def repo_bin
         return Common::Shell.shell_bin('repo') unless @repo_bin
 
-        @repo_bin.join('repo').tap do |bin|
-          next if bin.file?
+        bin = @repo_bin.join('repo')
+        return bin if bin.file?
 
-          require 'open-uri'
-          puts log_message('Installing repo...', subject: main, hint: @repo_bin) if verbose
-          URI.open(REPO_URL) do |url|
-            @repo_bin.mkpath
-            File.open(bin, 'wb') do |f|
-              f.write(url.read)
-              f.chmod(0o755)
-            end
+        require 'open-uri'
+        puts log_message('Installing repo...', subject: main, hint: @repo_bin) if verbose
+        URI.open(REPO_URL) do |url|
+          @repo_bin.mkpath
+          File.open(bin, 'wb') do |f|
+            f.write(url.read)
+            f.chmod(0o755)
           end
         end
+        bin
       end
 
-      def repo_opts(*args)
-        return args unless (n = ARGV.index('--'))
+      def repo_workspace(name)
+        g, r = @global[name].fetch_values(:group, :ref)
+        g = g.keys
+        r = r.keys
+        pass = g.empty? && r.empty?
+        select do |proj|
+          next unless proj.enabled?(baseref)
 
-        ARGV[n.succ..-1].concat(args)
+          proj.global_set(name)
+          i = -1
+          n = repo_scriptdata(proj, name).reduce(0) do |a, b|
+            i += 1
+            next a unless b
+
+            a + (1 << i)
+          end
+          proj.global(n) && (pass || g.include?(proj.group) || r.any? { |val| proj.ref?(val) })
+        end
+      end
+
+      def repo_scriptdata(proj, name)
+        proj.scriptdata(:global, name: name).fetch_values(:run, :script, :doc, :test)
+      end
+
+      def repo_call(proj, meth, sync: nil)
+        name = task_join proj.name, meth
+        detect = proj.workspace.task_defined?(name)
+        if proj.has?(meth) && (!detect || !sync.nil?)
+          if sync.nil?
+            proj.__send__(meth)
+          else
+            proj.__send__(meth, sync: sync)
+          end
+        elsif detect
+          task_invoke(name, **proj.workspace.invokeargs)
+        end
+      rescue => e
+        raise if exception
+
+        warn log_warn(e, pass: true) if warning
       end
 
-      def repo?
-        return false unless manifest_url && !windows?
+      def repo_opts(*args)
+        return args unless (n = ARGV.index('--'))
 
-        repo_install? || @repo_override == true
+        ARGV[n.succ..-1].concat(args)
       end
 
-      def repo_submodules?(val = false)
-        case (s = env('REPO_SUBMODULES'))
+      def repo_submodules?(val = false, **kwargs)
+        case (s = env('REPO_SUBMODULES', **kwargs))
         when '0', 'false'
           false
         else