squared 0.2.10 → 0.3.0

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

@@ -6,28 +6,36 @@ module Squared
       class Ruby < Git
         GEMFILE = %w[Gemfile Gemfile.lock gem.deps.rb Isolate].freeze
         DIR_RUBY = (GEMFILE + Rake::Application::DEFAULT_RAKEFILES + ['README.rdoc']).freeze
-        FOR_INSTALL = %w[full-index quiet retry gemfile=s j=i jobs=i retry=i].freeze
-        OPT_INSTALL = %w[binstubs frozen system no-cache no-prune path=s binstubs=? standalone=? target-rbconfig=s
-                         trust-policy=s with=s without=s].freeze
-        OPT_UPDATE = %w[conservative local pre redownload ruby strict bundler=? g=s group=s source=s].freeze
-        OPT_OUTDATED = %w[filter-major filter-minor filter-patch groups local parseable pre only-explicit strict
-                          update-strict g=s group=s source=s].freeze
+        OPT_BUNDLE = {
+          common: %w[no-color V verbose retry=i].freeze,
+          install: %w[frozen no-cache no-prune system path=p binstubs=p? standalone=q? target-rbconfig=p trust-policy=b
+                      with=q without=q].freeze,
+          install_base: %w[full-index quiet retry gemfile=p j|jobs=i].freeze,
+          update: %w[conservative local pre redownload ruby strict bundler=e? g|group=q source=e].freeze,
+          outdated: %w[filter-major filter-minor filter-patch groups local parseable pre only-explicit strict
+                       update-strict g|group=q source=e].freeze,
+          exec: %w[gemfile=p].freeze,
+          check: %w[dry-run gemfile=p].freeze
+        }.freeze
         OPT_GEM = {
-          COMMON: %w[V backtrace debug q quiet norc silent verbose no-verbose config-file=s].freeze,
-          INSTALL: ['version=s'].freeze,
-          UPDATE: ['system=?'].freeze,
-          OUTDATED: %w[b both clear-sources l local no-http-proxy r remote B bulk-threshold=i p=s http-proxy=?
-                       platform=s source=s].freeze,
-          PRISTINE: %w[all env-shebang no-env-shebang extensions no-extensions only-missing-extensions only-executables
-                       only-plugins n=s bindir=s i=s install-dir=s skip=s v=s version=s].freeze,
-          NO_GENERAL: %w[env-shebang force format-executable http-proxy lock minimal-deps post-install-message
-                         prerelease suggestions user-install wrappers].freeze,
-          GENERAL: %w[f g w b both clear-sources conservative document=? default development development-all E explain
-                      ignore-dependencies l local N no-document r remote vendor n=s bindir=s build-root=s
-                      bulk-threshold=i document=s g=s file=? p=s http-proxy=s i=s install-dir=s platform=s s=s source=s
-                      target-rbconfig=? P=s trust-policy=s without=s].freeze
+          common: %w[backtrace debug q|quiet no-verbose norc silent V|verbose config-file=p].freeze,
+          install: %w[version=e].freeze,
+          update: %w[system=e?].freeze,
+          outdated: %w[b|both clear-sources l|local no-http-proxy r|remote B|bulk-threshold=i p|http-proxy=q?
+                       platform=q source=q].freeze,
+          push: %w[no-http-proxy attestation=p host=q key=e otp=e p|http-proxy=q?].freeze,
+          build: %w[force strict o|output=p platform=q].freeze,
+          exec: %w[conservative prerelease no-prerelease g|gem=s version=e].freeze,
+          pristine: %w[all env-shebang extensions no-env-shebang no-extensions only-executables only-missing-extensions
+                       only-plugins n|bindir=p i|install-dir=p skip=e v|version=e].freeze,
+          shared: %w[f b|both clear-sources conservative default development development-all E|explain
+                     ignore-dependencies l|local N|no-document r|remote w|vendor n|bindir=p build-root=p
+                     bulk-threshold=i document=b? g|file=p? p|http-proxy=q i|install-dir=p platform=q s|source=q
+                     target-rbconfig=p? P|trust-policy=b without=e].freeze,
+          shared_no: %w[env-shebang force format-executable http-proxy lock minimal-deps post-install-message
+                        prerelease suggestions user-install wrappers].freeze
         }.freeze
-        private_constant :GEMFILE, :DIR_RUBY, :FOR_INSTALL, :OPT_INSTALL, :OPT_UPDATE, :OPT_OUTDATED, :OPT_GEM
+        private_constant :GEMFILE, :DIR_RUBY, :OPT_BUNDLE, :OPT_GEM
 
         class << self
           def populate(*); end
@@ -52,9 +60,10 @@ module Squared
           'install' => %i[redownload local prefer-local].freeze,
           'update' => %i[patch minor major all].freeze,
           'outdated' => %i[patch minor major].freeze,
-          'gem' => %i[install user-install update outdated pristine].freeze,
+          'gem' => %i[install user-install update pristine outdated push build exec].freeze,
           'exec' => nil,
           'config' => nil,
+          'check' => nil,
           'rake' => nil
         }.freeze
 
@@ -101,11 +110,13 @@ module Squared
 
               if flags.nil?
                 case action
-                when 'exec', 'config'
-                  format_desc action, nil, 'command+'
+                when 'config', 'exec', 'check'
+                  format_desc(action, nil, case action
+                                           when 'exec', 'check'
+                                             OPT_BUNDLE[action.to_sym]
+                                           end, after: action == 'check' ? nil : 'command+')
                   task action do |_, args|
-                    args = param_guard('bundle', action, args: args.to_a)
-                    bundle(action, *args)
+                    bundle action, args.to_a
                   end
                 when 'rake'
                   next unless rakefile
@@ -126,7 +137,7 @@ module Squared
                         log.warn "rake task #{n} of #{list.size} (out of range)"
                         next
                       end
-                      rake(args.extras.empty? ? cmd : "#{cmd}#{shell_escape("[#{args.extras.join(',')}]")}")
+                      rake(args.extras.empty? ? cmd : cmd + shell_escape("[#{args.extras.join(',')}]"))
                     else
                       rake(*args.to_a)
                     end
@@ -136,33 +147,23 @@ module Squared
                 namespace action do
                   flags.each do |flag|
                     case action
-                    when 'install'
-                      format_desc(action, flag, FOR_INSTALL + OPT_INSTALL) if @@task_desc
-                      task flag do |_, args|
-                        depend(flag, opts: args.to_a)
-                      end
-                    when 'update', 'outdated'
-                      if @@task_desc
-                        format_desc(action, flag, action == 'update' ? FOR_INSTALL + OPT_UPDATE : OPT_OUTDATED)
-                      end
+                    when 'install', 'update', 'outdated'
+                      format_desc action, flag, 'opts*'
                       task flag do |_, args|
-                        __send__(action, flag, opts: args.to_a)
+                        __send__ action, flag, args.to_a
                       end
                     when 'gem'
                       case flag
-                      when :outdated
-                        format_desc action, flag, gemoption(flag) if @@task_desc
+                      when :outdated, :build, :push, :exec
+                        format_desc action, flag, 'opts*'
                         task flag do |_, args|
-                          gemx(flag, opts: args.to_a)
+                          gemx flag, args.to_a
                         end
                       else
-                        if @@task_desc
-                          format_desc(action, flag, gemoption(flag),
-                                      after: "name+#{flag == :pristine ? '|name?@version' : ''}")
-                        end
-                        task flag, [:name] do |_, args|
+                        format_desc action, flag, "opts*,name+#{flag == :pristine ? '|name?@version' : ''}"
+                        task flag do |_, args|
                           opts = param_guard(action, flag, args: args.to_a)
-                          gemx(flag, opts: opts)
+                          gemx flag, opts
                         end
                       end
                     end
@@ -173,34 +174,25 @@ module Squared
           end
         end
 
-        def depend(flag = nil, opts: [], sync: invoked_sync?('depend', flag))
-          if @depend && !flag
+        def depend(*, sync: invoked_sync?('depend'), **)
+          if @depend
             super
           elsif outdated?
             cmd = bundle_session 'install'
-            if flag
-              cmd << "--#{flag}"
-              append_bundle opts, FOR_INSTALL + OPT_INSTALL
-              from = :install
-            else
-              if (n = option('jobs')).to_i > 0
-                cmd << "-j#{n}"
-              end
-              from = :depend
+            if (n = option('jobs')).to_i > 0
+              cmd << "-j#{n}"
             end
-            run_rb(from: from, sync: sync)
+            run_rb(from: :depend, sync: sync)
           end
         end
 
-        def copy(from: 'lib', into: @gemdir, override: false, **kwargs)
-          glob = kwargs[:include]
-          pass = kwargs[:exclude]
+        def copy(from: 'lib', include: nil, exclude: nil, into: @gemdir, override: false)
           if @copy && !override
             return super if runnable?(@copy)
 
             from = @copy[:from] if @copy.key?(:from)
             glob = @copy[:include] if @copy.key?(:include)
-            pass = @copy[:exclude] if @copy.key?(:exclude)
+            exclude = @copy[:exclude] if @copy.key?(:exclude)
             into = @copy[:into] if @copy.key?(:into)
           end
           return unless into
@@ -212,10 +204,10 @@ module Squared
           as_a(from).each_with_index do |val, i|
             a = basepath(val)
             b = dest.join(val)
-            c = glob[i] || glob.first
+            c = glob[i] || glob[0]
             log.info "cp #{a.join(c)} #{b}"
             begin
-              copy_dir(a, b, c, pass: pass, verbose: verbose)
+              copy_dir(a, b, c, pass: exclude, verbose: verbose)
             rescue StandardError => e
               log.error e
               ret = on(:error, :copy, e)
@@ -225,11 +217,11 @@ module Squared
           on :last, :copy
         end
 
-        def outdated(flag = nil, opts: [], sync: invoked_sync?('outdated', flag))
+        def outdated(flag = nil, opts = [], sync: invoked_sync?('outdated', flag))
           cmd = bundle_output 'outdated'
           if flag
             cmd << "--#{flag}"
-            append_bundle(opts, OPT_OUTDATED, target: cmd)
+            append_bundle(opts, OPT_BUNDLE[:outdated] + OPT_BUNDLE[:common], target: cmd)
           end
           log.info cmd.to_s
           on :first, :outdated
@@ -261,10 +253,10 @@ module Squared
                     semmajor?(cur, lat) ? major_set.() : minor_set.()
                   else
                     data.each do |val|
-                      break unless (req = /(>=?|=|~>|!=|<=?) (#{Regexp.escape(val.join)})/.match(line))
+                      break unless line =~ /(>=?|=|~>|!=|<=?) (#{Regexp.escape(val.join)})/
 
                       v = semver(val).join
-                      case req[1]
+                      case $1
                       when '>', '>='
                         semmajor?(cur, lat) ? major_set.() : minor_set.()
                       when '<', '<='
@@ -325,8 +317,8 @@ module Squared
             end
             if found > 0
               begin
-                if major == 0 && (data = /\b(?:source\s+(["'])(.+?)\1|remote:\s+(\S+))/.match(dependfile.read))
-                  status = (data[2] || data[3]).chomp('/')
+                if major == 0 && dependfile.read =~ /\b(?:source\s+(["'])(.+?)\1|remote:\s+(\S+))/
+                  status = ($2 || $3).chomp('/')
                   right = true
                 end
               rescue StandardError => e
@@ -342,49 +334,56 @@ module Squared
           on :last, :outdated
         end
 
-        def update(flag, opts: [])
+        def install(flag, opts = [])
+          bundle_session 'install', "--#{flag}"
+          append_bundle opts, OPT_BUNDLE[:install_base] + OPT_BUNDLE[:install] + OPT_BUNDLE[:common]
+          run_rb(from: :install)
+        end
+
+        def update(flag, opts = [])
           bundle_session 'update', "--#{flag}"
-          append_bundle(opts, FOR_INSTALL + OPT_UPDATE, append: flag != :all)
+          append_bundle opts, OPT_BUNDLE[:install_base] + OPT_BUNDLE[:update] + OPT_BUNDLE[:common]
           run_rb(from: :update)
         end
 
-        def gemx(flag, opts: [])
+        def gemx(flag, opts = [])
           cmd = gem_session
           case flag
           when :outdated
-            cmd << "-C #{shell_quote(path)}" if (pass = Gem::VERSION >= '3.4.2')
+            cmd << pwd if (pwd = gempwd)
             cmd << flag
+          when :push
+            cmd << flag << project
           when :'user-install'
-            cmd << 'install' << "--#{flag}"
+            cmd << 'install' << '--user-install'
           else
             cmd << flag
           end
-          no = flag == :pristine || flag == :outdated ? [] : OPT_GEM[:NO_GENERAL]
-          opts, pat = option_partition(opts, gemoption(flag), no: no, first: flag != :outdated)
+          list = OPT_GEM[flag == :'user-install' ? :install : flag] + OPT_GEM[:common]
+          case flag
+          when :install, :'user-install', :update
+            list += OPT_GEM[:shared]
+            no = OPT_GEM[:shared_no]
+          end
+          opts, pat = option_sanitize(opts, list, no: no, first: true)
           out = []
           opts.each do |opt|
             if opt =~ pat
               case $1
-              when 'build-root', 'config-file', 'target-rbconfig',
-                   'n', 'bindir', 'g', 'file', 'i', 'install-dir'
-                cmd << quote_option($1, basepath($2))
-              when 'p', 'http-proxy', 's', 'source'
-                cmd << quote_option($1, $2)
-              when 'bulk-threshold'
-                cmd << basic_option($1, $2) if $2.to_i > 0
-              else
-                cmd << shell_option($1, $2)
+              when 'g', 'gem'
+                cmd << (flag == :exec ? shell_option($1, $2) : quote_option($1, basepath($2)))
               end
             else
               out << opt
             end
           end
           from = :"gem:#{flag == :'user-install' ? 'install' : flag}"
-          if flag == :outdated
+          case flag
+          when :outdated
             log.info cmd.to_s
             on :first, from
             print_item format_banner(cmd.to_s)
-            pwd_set(pass: pass, from: from) do
+            pwd_set(pass: !pwd.nil?, from: from) do
               items = [[%w[Gem Current Latest], nil]]
               IO.popen(cmd.done).each do |line|
                 if (data = line.match(/^(\S+) \((\S+) < ([^)]+)\)$/))
@@ -456,41 +455,61 @@ module Squared
               end
             end
             on :last, from
+            return
+          when :build, :push
+            if !out.empty?
+              if flag == :build && out.size == 1
+                cmd << basepath(out.first)
+              else
+                raise_error('gem', flag, out.join(', '), hint: 'unrecognized option')
+              end
+            elsif flag == :build
+              cmd << "#{project}.gemspec"
+            end
+          when :exec
+            raise_error('gem', flag, hint: 'no command given') if out.empty?
+            cmd << out.join(' ')
           else
-            if out.empty? && !cmd.find { |val| val =~ /^--system(?:=|$)/ }
+            if out.empty? && cmd.none? { |val| val =~ /^--system(?:=|$)/ }
               raise_error('gem', flag, hint: 'no gemname given')
-            else
-              if flag == :pristine
-                if cmd.include?('--all')
-                  append_repeat 'skip', out
-                  out.clear
-                elsif (n = out.first =~ /@/)
-                  name = out.first
-                  if n == 0
-                    cmd << shell_escape(project)
-                    version = name[1..-1]
-                  else
-                    cmd << shell_escape(name[0..n - 1])
-                    version = name[n + 1..-1]
-                  end
-                  cmd << shell_option('version', version)
-                  out.clear
+            end
+            if flag == :pristine
+              if session_arg?('all')
+                append_repeat 'skip', out
+                out.clear
+              elsif (n = out.first =~ /@/)
+                name = out.first
+                if n == 0
+                  cmd << project
+                  version = name[1..-1]
+                else
+                  cmd << shell_escape(name[0, n])
+                  version = name[n + 1..-1]
                 end
+                cmd << shell_option('version', version)
+                out.clear
               end
-              append_value out
             end
-            run_rb(from: from)
+            append_value(out, escape: true)
           end
+          run_rb(from: from)
         end
 
-        def bundle(cmd, *args)
+        def bundle(flag, *args)
           args = args.flatten
-          run_s(bundle_session(cmd, *args), from: :bundle)
+          cmd = bundle_session flag
+          case flag
+          when 'exec', 'check'
+            args = option_sanitize(args, OPT_BUNDLE[flag.to_sym] + OPT_BUNDLE[:common]).first
+          end
+          raise_error('bundle', flag, hint: 'no command given') unless !args.empty? || flag == 'check'
+          cmd.merge!(args)
+          run(from: :"bundle:#{flag}")
         end
 
         def rake(*cmd)
           if cmd.empty?
-            run_s(rake_output(rakeapp), from: :rake, chdir: workspace.pwd, banner: false)
+            run_s(rake_output(rakeapp), from: :rake, chdir: workspace.pwd)
           else
             cmd = cmd.flatten.map { |val| rake_output(rakeapp, val) }
             run_s(cmd, from: :rake, chdir: workspace.pwd, banner: false)
@@ -511,34 +530,43 @@ module Squared
           end
           return false unless @autodetect
 
-          set = lambda do |val|
+          set = lambda do |val, path|
             log.warn "using version #{val} (given #{@version})" if @version && @version != val
             @version = val
+            @gemdir = Pathname.new(path.strip).join(gempath)
           end
           if @version
-            out = pwd_set { `#{gem_output('list', '--local', '-d', shell_escape(project, quote: true))}` }
-            if (data = /#{Regexp.escape(project)} \(([^)]+)\)/.match(out))
-              ver = data[1].split(/\s*,\s*/)
-              ver.unshift(@version).uniq!
-              ver.each do |val|
-                next unless (data = /\(#{Regexp.escape(val)}(?:,[^)]+|\b)\):([^\n]+)/.match(out))
-
-                set.(val)
-                break
+            pwd = gempwd
+            pwd_set(pass: !pwd.nil?) do
+              out = `#{gem_output(pwd, 'list', '--local', '-d', project)}`
+              if out =~ /#{Regexp.escape(project)} \(([^)]+)\)/
+                ver = $1.split(/\s*,\s*/)
+                ver.unshift(@version).uniq!
+                ver.each do |val|
+                  next unless out =~ /\(#{Regexp.escape(val)}(?:,[^)]+|\b)\):([^\n]+)/
+
+                  set.(val, $1)
+                  break
+                end
               end
             end
           end
-          unless data || RUBY_VERSION < '2.6'
-            target = RUBY_VERSION.start_with?('2.6') ? RubyVM : $LOAD_PATH
-            if (path = target.resolve_feature_path(project)&.last)
-              gems = ['', 'gems', "#{project}-([^#{File::SEPARATOR}]+)", ''].join(File::SEPARATOR)
-              if (ver = Regexp.new(gems).match(path)) && (data = /\A(.+)#{gempath(ver[1])}/.match(path))
-                set.(ver[1])
+          unless @gemdir
+            parse = lambda do |path|
+              next unless path
+
+              lib = Regexp.new(['', 'gems', "#{project}-([^#{File::SEPARATOR}]+)", ''].join(File::SEPARATOR))
+              if (ver = path[lib, 1]) && (val = path[/\A(.+)#{gempath(ver[1])}/, 1])
+                set.(ver, val)
               end
             end
+            if RUBY_VERSION >= '2.6'
+              target = RUBY_VERSION.start_with?('2.6') ? RubyVM : $LOAD_PATH
+              parse.(target.resolve_feature_path(project)&.last)
+            end
+            pwd_set { parse.(`#{bundle_output('show', project)}`) } unless @gemdir
           end
-          raise_error('failed to parse', hint: @version || 'path') unless data
-          @gemdir = Pathname.new(data[1].strip).join(gempath)
+          raise_error('failed to parse', hint: @version || 'path') unless @gemdir
         rescue StandardError => e
           log.error e
           @version = nil
@@ -558,30 +586,9 @@ module Squared
           run(banner: !@session.include?('--quiet'), **kwargs)
         end
 
-        def append_bundle(opts, list, target: @session, append: false)
-          opts, pat = option_partition(opts, list, target: target)
-          out = []
-          opts.each do |opt|
-            if opt =~ pat
-              case $1
-              when 'path', 'gemfile', 'binstubs', 'target-rbconfig'
-                target << quote_option($1, basepath($2))
-              when 'standalone', 'with', 'without', 'g', 'group'
-                target << quote_option($1, $2)
-              when 'retry', 'j', 'jobs'
-                target << basic_option($1, $2) if $2.to_i > 0
-              else
-                target << shell_option($1, $2)
-              end
-            else
-              out << opt
-            end
-          end
-          if append
-            append_value(out, target: target, escape: true)
-          else
-            option_clear(out, target: target)
-          end
+        def append_bundle(opts, list, target: @session)
+          out = option_sanitize(opts, list, target: target).first
+          option_clear(out, target: target)
         end
 
         def gem_session(*cmd, **kwargs)
@@ -616,12 +623,12 @@ module Squared
           return @rakelist if @rakelist
 
           ret = []
-          pass = Rake::VERSION >= '13.0.4'
-          pwd_set(pass: pass) do
-            IO.popen(rake_output(pass ? "-C #{shell_quote(path)}" : nil, '-AT').to_s).each do |line|
-              next unless (data = /^rake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/.match(line))
+          pwd = rakepwd
+          pwd_set(pass: !pwd.nil?) do
+            IO.popen(rake_output(pwd, '-AT').to_s).each do |line|
+              next unless line =~ /^rake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/
 
-              ret << [data[1], data[2]]
+              ret << [$1, $2]
             end
           end
           @rakelist = ret
@@ -636,26 +643,29 @@ module Squared
         end
 
         def rakefile
-          file = Rake::Application::DEFAULT_RAKEFILES.find { |val| basepath(val).exist? }
-          basepath(file) if file
+          return unless (file = Rake::Application::DEFAULT_RAKEFILES.find { |val| basepath(val).exist? })
+
+          basepath(file)
         end
 
         def rakeapp
-          quote_option 'f', rakefile
+          quote_option 'rakefile', Rake.application.rakefile
         end
 
-        def gempath(val = @version)
-          File.join('gems', "#{project}-#{val}")
+        def rakepwd
+          return unless Rake::VERSION >= '13.0.4'
+
+          quote_option('C', path)
         end
 
-        def gemoption(flag)
-          target = flag == :'user-install' ? :INSTALL : flag.upcase
-          OPT_GEM[:COMMON] + OPT_GEM[target] + case flag
-                                               when :pristine, :outdated
-                                                 []
-                                               else
-                                                 OPT_GEM[:GENERAL] + OPT_GEM[:NO_GENERAL]
-                                               end
+        def gempwd
+          return unless Gem::VERSION >= '3.4.2'
+
+          quote_option('C', path)
+        end
+
+        def gempath(val = @version)
+          File.join('gems', "#{project}-#{val}")
         end
       end
 

data/lib/squared/workspace/repo.rb

@@ -3,6 +3,8 @@
 module Squared
   module Workspace
     module Repo
+      include Common::Format
+
       class << self
         def read_manifest(path)
           require 'rexml/document'
@@ -15,7 +17,8 @@ module Squared
 
       attr_reader :manifest_url, :manifest
 
-      def repo(url, manifest = 'latest', run: nil, script: nil, dev: nil, prod: nil, ref: @ref, group: @group)
+      def repo(url, manifest = 'latest', 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
@@ -72,6 +75,7 @@ module Squared
             else
               data[:script] = script
             end
+            data[:args] = (val = env('REPO_SCRIPT')) ? shell_split(val, join: true) : args
           elsif (val = env('REPO_BUILD'))
             data[:run] = val
             data[:env] = true
@@ -79,8 +83,8 @@ module Squared
             data[:run] = run
           end
           data[:global] = true
-          data[:dev] = env_match('REPO_DEV', dev, suffix: @envname)
-          data[:prod] = env_match('REPO_PROD', prod, suffix: @envname)
+          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
@@ -90,11 +94,12 @@ module Squared
             found = true
           end
           script_set(data, group: group, ref: ref) unless found
-          @warning = env_match('REPO_WARN', @warning && !root?(@root, pass: ['.repo']), suffix: @envname) != false
+          @warning = env_match('REPO_WARN', @warning && !root?(@root, pass: ['.repo'])) != false
           @extensions << :__repo__
         elsif script || run
           if script
             data[:script] = script
+            data[:args] = args
           else
             data[:run] = run
           end

data/lib/squared/workspace/series.rb

@@ -85,7 +85,7 @@ module Squared
         (TASK_BASE + TASK_KEYS).each { |key| @data[key] = [] }
       end
 
-      def populate(proj)
+      def populate(proj, **)
         group, parent, id = @session.values
         ws = proj.workspace
         @data.each do |key, items|
@@ -97,7 +97,7 @@ module Squared
           else
             items.concat(tasks)
           end
-          if tasks.size > 1 && (data = batch_get(key)) && data.keys.any? { |ref| proj.ref?(ref) }
+          if tasks.size > 1 && batch?(proj, key) && !ws.task_exclude?(key, proj)
             ws.task_desc(t = ws.task_join(proj.name, key))
             task t => tasks
           end
@@ -113,9 +113,9 @@ module Squared
         @data.merge!(@session[:parent]) if @session[:id].uniq.size > 1
         @data.merge!(@session[:group])
         @data.each do |key, items|
-          next if items.empty?
+          next if items.empty? || @workspace.task_exclude?(t = name_get(key))
 
-          key = task_name(t = name_get(key))
+          key = task_name(t)
           val = format_desc(key, out: true)
           if items.size > 1
             @multiple << key
@@ -181,6 +181,12 @@ module Squared
         ret
       end
 
+      def batch?(obj, key)
+        return false unless (data = batch_get(key))
+
+        data.keys.any? { |ref| obj.ref?(ref) }
+      end
+
       def multiple?(val = nil)
         already_invoked?(multiple, val)
       end

data/squared.gemspec

@@ -27,5 +27,4 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rake"
   spec.add_dependency "logger"
   spec.add_dependency "rexml"
-  spec.add_dependency "readline"
 end