squared 0.1.8 → 0.2.0

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

@@ -4,44 +4,61 @@ module Squared
   module Workspace
     module Project
       class Ruby < Git
-        VAR_SET = %i[version autodetect].freeze
         GEMFILE = %w[Gemfile Gemfile.lock gem.deps.rb Isolate].freeze
-        RUBY_DIR = (GEMFILE + Rake::Application::DEFAULT_RAKEFILES + ['README.rdoc']).freeze
-        OPT_INSTALL = %w[system frozen no-cache no-prune].freeze
-        OPT_UPDATE = %w[all redownload conservative local strict group=s].freeze
-        OPT_OUTDATED = %w[pre only-explicit local strict group=s].freeze
-        private_constant :VAR_SET, :GEMFILE, :RUBY_DIR, :OPT_INSTALL, :OPT_UPDATE, :OPT_OUTDATED
+        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_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
+        }.freeze
+        private_constant :GEMFILE, :DIR_RUBY, :FOR_INSTALL, :OPT_INSTALL, :OPT_UPDATE, :OPT_OUTDATED, :OPT_GEM
 
         class << self
           def populate(*); end
           def batchargs(*); end
 
           def tasks
-            %i[outdated].freeze
+            [:outdated].freeze
           end
 
           def bannerargs
-            %i[dependfile].freeze
+            [:dependfile].freeze
           end
 
           def config?(val)
             return false unless (val = as_path(val))
 
-            RUBY_DIR.any? { |file| val.join(file).exist? }
+            DIR_RUBY.any? { |file| val.join(file).exist? }
           end
         end
 
         @@tasks[ref] = {
-          install: %i[redownload local prefer-local gem with without].freeze,
-          update: %i[all patch minor major].freeze,
-          outdated: %i[patch minor major].freeze,
-          pristine: %i[gem all version].freeze,
-          exec: nil,
-          config: nil,
-          rake: nil
+          '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,
+          'exec' => nil,
+          'config' => nil,
+          'rake' => nil
         }.freeze
 
-        def initialize(*, version: nil, autodetect: false, **kwargs)
+        def initialize(*, autodetect: false, **kwargs)
           super
           if @pass.include?(Ruby.ref)
             initialize_ref(Ruby.ref)
@@ -50,7 +67,6 @@ module Squared
             initialize_build(Ruby.ref, **kwargs)
             initialize_env(**kwargs)
           end
-          @version = env('BUILD', version, suffix: 'VERSION')
           @autodetect = autodetect
           @dependindex = GEMFILE.index { |file| basepath(file).exist? }
           @dependfile = basepath(GEMFILE[@dependindex || 0])
@@ -60,9 +76,10 @@ module Squared
             File.foreach(file) do |line|
               next unless line =~ %r{\brequire\s+(["'])bundler/gem_tasks\1}
 
-              @output[0] = 'bundle exec rake build'
-              @copy = 'bundle exec rake install'
-              @clean = 'bundle exec rake clean' if @clean.nil?
+              cmd = bundle_output('exec', 'rake').to_s
+              @output[0] = "#{cmd} build"
+              @copy = "#{cmd} install"
+              @clean = "#{cmd} clean" if @clean.nil?
               break
             end
           rescue StandardError => e
@@ -74,23 +91,26 @@ module Squared
           Ruby.ref
         end
 
-        def populate(*)
+        def populate(*, **)
           super
           return unless outdated? && ref?(Ruby.ref)
 
           namespace name do
             @@tasks[Ruby.ref].each do |action, flags|
+              next if @pass.include?(action)
+
               if flags.nil?
                 case action
-                when :exec, :config
-                  desc format_desc(action, nil, 'command+')
-                  task action, [:command] do |_, args|
-                    bundle(action, args.to_a)
+                when 'exec', 'config'
+                  format_desc action, nil, 'command+'
+                  task action do |_, args|
+                    args = param_guard('bundle', action, args: args.to_a)
+                    bundle(action, *args)
                   end
-                when :rake
+                when 'rake'
                   next unless rakefile
 
-                  desc format_desc(action, nil, 'command*|^index,args*|#,pattern*')
+                  format_desc action, nil, 'command*|^index,args*|#,pattern*'
                   task action, [:command] do |_, args|
                     if args.command == '#'
                       format_list(read_rakefile, 'rake[^N]', 'tasks', grep: args.extras, from: rakefile.to_s,
@@ -116,49 +136,33 @@ module Squared
                 namespace action do
                   flags.each do |flag|
                     case action
-                    when :install
-                      case flag
-                      when :gem
-                        desc format_desc(action, flag, 'name+')
-                        task flag, [:name] do |_, args|
-                          opts = guard_params(action, flag, args: args.to_a)
-                          depend(flag, opts: opts)
-                        end
-                      when :with, :without
-                        desc format_desc(action, flag, 'group+')
-                        task flag, [:group] do |_, args|
-                          opts = guard_params(action, flag, args: args.to_a)
-                          depend(flag, opts: opts)
-                        end
-                      else
-                        desc format_desc(action, flag, OPT_INSTALL)
-                        task flag, [:opts] do |_, args|
-                          depend(flag, opts: args.to_a)
-                        end
+                    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 :update, :outdated
-                      desc format_desc(action, flag, action == :update ? OPT_UPDATE : OPT_OUTDATED)
-                      task flag, [:opts] do |_, args|
+                      task flag do |_, args|
                         __send__(action, flag, opts: args.to_a)
                       end
-                    when :pristine
+                    when 'gem'
                       case flag
-                      when :gem
-                        desc format_desc(action, flag, 'name+')
-                        task flag, [:name] do |_, args|
-                          opts = guard_params(action, flag, args: args.to_a)
-                          pristine(flag, opts: opts)
+                      when :outdated
+                        format_desc action, flag, gemoption(flag) if @@task_desc
+                        task flag do |_, args|
+                          gemx(flag, opts: args.to_a)
                         end
-                      when :all
-                        desc format_desc(action, flag, 'skip*')
-                        task flag, [:skip] do |_, args|
-                          pristine(flag, opts: args.to_a)
+                      else
+                        if @@task_desc
+                          format_desc(action, flag, gemoption(flag),
+                                      after: "name+#{flag == :pristine ? '|name?@version' : ''}")
                         end
-                      when :version
-                        desc format_desc(action, flag, 'version?')
-                        task flag, [:version] do |_, args|
-                          version = guard_params(action, flag, args: args, key: :version)
-                          pristine(flag, version: version)
+                        task flag, [:name] do |_, args|
+                          opts = param_guard(action, flag, args: args.to_a)
+                          gemx(flag, opts: opts)
                         end
                       end
                     end
@@ -173,79 +177,69 @@ module Squared
           if @depend && !flag
             super
           elsif outdated?
-            case flag
-            when :gem
-              gem_session 'install'
-              append_value opts
-            when :with, :without
-              bundle_session 'install'
-              append_repeat flag, opts
-            when :redownload, :local, :'prefer-local'
-              cmd = bundle_session 'install', "--#{flag}"
-              if (val = option('trust-policy', ignore: false))
-                cmd << shell_option('trust-policy', case val
-                                                    when '0'
-                                                      'NoSecurity'
-                                                    when '1'
-                                                      'AlmostNoSecurity'
-                                                    when '2'
-                                                      'LowSecurity'
-                                                    when '3'
-                                                      'MediumSecurity'
-                                                    when '4'
-                                                      'HighSecurity'
-                                                    else
-                                                      val
-                                                    end, escape: false)
-              end
-              append_bundle opts, OPT_INSTALL
+            cmd = bundle_session 'install'
+            if flag
+              cmd << "--#{flag}"
+              append_bundle opts, FOR_INSTALL + OPT_INSTALL
+              from = :install
             else
-              bundle_session 'install'
-              append_bundle
+              if (n = option('jobs')).to_i > 0
+                cmd << "-j#{n}"
+              end
+              from = :depend
             end
-            run_rb(sync: sync)
+            run_rb(from: from, 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
 
+          on :first, :copy
           dest = Pathname.new(into).realpath
-          print_item unless @output[0] || task_invoked?(/\Acopy(?::#{Ruby.ref}|\z)/)
+          print_item unless @output[0] || task_invoked?(/^copy(?::#{Ruby.ref}|$)/)
           glob = as_a(glob || '**/*')
           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}"
-            copy_d(a, b, glob: c, pass: pass, verbose: verbose)
+            begin
+              copy_dir(a, b, c, pass: exclude, verbose: verbose)
+            rescue StandardError => e
+              log.error e
+              ret = on(:error, :copy, e)
+              raise if exception && ret != true
+            end
           end
+          on :last, :copy
         end
 
-        def outdated(rev = nil, opts: [], sync: invoked_sync?('outdated', rev))
-          cmd = bundle_session 'outdated', rev && "--#{rev}"
-          append_bundle opts, OPT_OUTDATED
-          cmd = session_done(cmd)
-          log.info cmd
-          banner = format_banner(cmd)
+        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)
+          end
+          log.info cmd.to_s
+          on :first, :outdated
+          banner = format_banner(cmd.to_s)
           print_item banner if sync
-          start = 0
-          found = 0
-          major = 0
-          pwd_set do
+          pwd_set(from: :outdated) do
+            start = 0
+            found = 0
+            major = 0
             buffer = []
             out = ->(val) { sync ? puts(val) : buffer << val }
-            IO.popen("#{cmd} --no-color").each do |line|
+            IO.popen(cmd.temp('--no-color')).each do |line|
               if start > 0
                 unless stdin?
                   data = line.scan(SEM_VER)
@@ -297,26 +291,31 @@ module Squared
                     end
                   end
                   unless styles.empty?
-                    case styles[0]
+                    case styles.first
                     when :green
-                      line = sub_style(line, pat: /^(\S+)(.+)$/, styles: theme[styles[1] == :bold ? :major : :active])
+                      line = sub_style(line, pat: /^(\S+)(.+)$/, styles: theme[styles.last == :bold ? :major : :active])
                       found += 1
                     when :yellow
                       found += 1
                     end
-                    styles = styles.compact.map { |s| color(s) }.flatten
-                    line = sub_style(line, pat: /^((?:\S+\s+){2})(#{Regexp.escape(l)})(.*)$/, index: 2, styles: styles)
+                    if theme[:current]
+                      line = sub_style(line, styles: theme[:current], pat: /^(.+)(#{Regexp.escape(c)})(.+)$/,
+                                             index: 2)
+                    end
+                    line = sub_style(line, *colormap(styles), pat: /^((?:\S+\s+){2})(#{Regexp.escape(l)})(.*)$/,
+                                                              index: 2)
                   end
                 end
                 out.("#{start.to_s.rjust(2)}. #{line}")
-                start += 1
               elsif line =~ /^Gem /
                 unless stdin?
                   sub = { pat: /^(.+)(?<!\dm)(Gem|Latest)(.+)$/, styles: theme[:header], index: 2 }
                   out.(print_footer(" #  #{line.chomp}", reverse: true, sub: [sub, sub]))
                 end
-                start += 1
+              else
+                next
               end
+              start += 1
             end
             unless sync
               print_item banner
@@ -338,39 +337,159 @@ module Squared
               puts 'No updates were found'
             end
           end
+          on :last, :outdated
         end
 
         def update(flag, opts: [])
           bundle_session 'update', "--#{flag}"
-          append_bundle opts, OPT_UPDATE
-          run_rb
+          append_bundle opts, FOR_INSTALL + OPT_UPDATE
+          run_rb(from: :update)
         end
 
-        def pristine(flag, version: nil, opts: [])
-          cmd = gem_session 'pristine'
+        def gemx(flag, opts: [])
+          cmd = gem_session
           case flag
-          when :gem
-            append_value opts
-          when :all
-            cmd << '--all'
-            append_repeat 'skip', opts
-          when :version
-            cmd << project << shell_option('version', version)
+          when :outdated
+            cmd << "-C #{shell_quote(path)}" if (pass = Gem::VERSION >= '3.4.2')
+            cmd << flag
+          when :'user-install'
+            cmd << 'install' << "--#{flag}"
+          else
+            cmd << flag
+          end
+          no = flag == :pristine || flag == :outdated ? [] : OPT_GEM[:NO_GENERAL]
+          opts, pat = option_partition(opts, gemoption(flag), 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 << shell_quote($1, $2)
+              when 'bulk-threshold'
+                cmd << basic_option($1, $2) if $2.to_i > 0
+              else
+                cmd << shell_option($1, $2)
+              end
+            else
+              out << opt
+            end
+          end
+          from = :"gem:#{flag == :'user-install' ? 'install' : flag}"
+          if flag == :outdated
+            log.info cmd.to_s
+            on :first, from
+            print_item format_banner(cmd.to_s)
+            pwd_set(pass: pass, from: from) do
+              items = [[%w[Gem Current Latest], nil]]
+              IO.popen(cmd.done).each do |line|
+                if (data = line.match(/^(\S+) \((\S+) < ([^)]+)\)$/))
+                  cur = semscan(data[2])
+                  lat = semscan(data[3])
+                  items << [data.to_a.drop(1), if semmajor?(cur, lat)
+                                                 %i[green bold]
+                                               else
+                                                 cur[2] == lat[2] ? [:yellow] : [:green]
+                                               end]
+                else
+                  puts line
+                end
+              end
+              if items.size == 1
+                puts 'No updates were found'
+              else
+                pad = [items.size.to_s.size + 1, 3].max
+                d = 0
+                e = 0
+                f = 0
+                items.each do |item|
+                  a, b, c = item.first
+                  d = a.size if a.size > d
+                  e = b.size if b.size > e
+                  f = c.size if c.size > f
+                end
+                major = 0
+                minor = 0
+                patch = 0
+                items.each_with_index do |item, i|
+                  next if i == 0 && stdin?
+
+                  a, b, c = item.first
+                  if i == 0
+                    line = "#{' #'.ljust(pad)} #{a.ljust(d)}    #{b.rjust(e)}  #{c.rjust(f)}"
+                    n = line.size
+                    2.times do
+                      line = sub_style(line, pat: /^(.+)(?<!\dm)(#{a}|#{c})(.*)$/, styles: theme[:header], index: 2)
+                    end
+                    puts line
+                    puts '-' * n
+                  else
+                    styles = item.last
+                    a = a.ljust(d)
+                    if styles.first == :green
+                      a = sub_style(a, styles: if styles.size == 2
+                                                 major += 1
+                                                 theme[:major]
+                                               else
+                                                 minor += 1
+                                                 theme[:active]
+                                               end)
+                    else
+                      patch += 1
+                    end
+                    b = b.rjust(e)
+                    b = sub_style(b, styles: theme[:current]) if theme[:current]
+                    c = sub_style(c.rjust(f), *colormap(styles))
+                    puts "#{"#{i}.".rjust(pad)} #{a}    #{b}  #{c}"
+                  end
+                end
+                unless stdin?
+                  status = print_footer("major #{major} / minor #{minor} / patch #{patch}", right: true).split("\n")
+                  status[1] = sub_style(status[1], pat: /^( +major )(\d+)(.+)$/, styles: theme[:major], index: 2)
+                  status[1] = sub_style(status[1], pat: /^(.+)(minor )(\d+)(.+)$/, styles: theme[:active], index: 3)
+                  puts status
+                end
+              end
+            end
+            on :last, from
+          else
+            if out.empty? && !cmd.find { |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
+              end
+              append_value out
+            end
+            run_rb(from: from)
           end
-          run_rb
         end
 
-        def bundle(flag, cmd)
-          guard_params('bundle', flag, args: cmd)
-          run_s "bundle #{flag} #{cmd.join(' ')}"
+        def bundle(cmd, *args)
+          run_s(bundle_session(cmd, *args), from: :bundle)
         end
 
         def rake(*cmd)
-          file = shell_option('rakefile', rakefile, quote: true, escape: false)
           if cmd.empty?
-            run_s("rake #{file}", chdir: workspace.pwd)
+            run_s(rake_output(rakeapp), from: :rake, chdir: workspace.pwd)
           else
-            run_s(*cmd.map { |val| "rake #{file} #{val}" }, chdir: workspace.pwd, banner: false)
+            run_s(*cmd.map { |val| rake_output(rakeapp, val) }, from: :rake, chdir: workspace.pwd, banner: false)
           end
         end
 
@@ -382,25 +501,37 @@ module Squared
           return true if super || (@copy.is_a?(Hash) && copy.fetch(:into, nil))
           return gemdir? if @gemdir
 
-          if @version && (val = ENV['GEM_HOME'])
-            @gemdir = Pathname.new(val).join(gempath)
+          if @version && (home = ENV['GEM_HOME'])
+            @gemdir = Pathname.new(home).join(gempath)
             return true if gemdir?
           end
           return false unless @autodetect
 
-          unsafe = ->(hint) { raise_error('failed to parse', hint: hint) }
-          out = pwd_set { `gem list --local -d #{project}` }
-          unsafe.('version') unless (data = /#{Regexp.escape(project)} \(([^)]+)\)/.match(out))
-          ver = data[1].split(/\s*,\s*/)
-          ver.unshift(@version).uniq! if @version
-          ver.each do |v|
-            next unless (data = /\(#{Regexp.escape(v)}(?:,[^)]+|\b)\):([^\n]+)/.match(out))
-
-            log.warn "using version #{v} (given #{@version})" if @version && @version != v
-            @version = v
-            break
+          set = lambda do |val|
+            log.warn "using version #{val} (given #{@version})" if @version && @version != val
+            @version = val
+          end
+          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! if @version
+            ver.each do |val|
+              next unless (data = /\(#{Regexp.escape(val)}(?:,[^)]+|\b)\):([^\n]+)/.match(out))
+
+              set.(val)
+              break
+            end
           end
-          unsafe.('path') unless data
+          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}/.match(path))
+                set.(ver[1])
+              end
+            end
+          end
+          raise_error('failed to parse', hint: @version || 'path') unless data
           @gemdir = Pathname.new(data[1].strip).join(gempath)
         rescue StandardError => e
           log.error e
@@ -417,38 +548,58 @@ module Squared
 
         private
 
-        def run_rb(sync: true)
-          run(sync: sync, banner: !@session.include?('--quiet'))
+        def run_rb(**kwargs)
+          run(banner: !@session.include?('--quiet'), **kwargs)
         end
 
-        def append_bundle(opts = nil, list = nil)
-          if (val = option('jobs')).to_i > 0
-            @session << "-j#{val}"
-          end
-          return unless opts && list
-
+        def append_bundle(opts, list, target: @session)
+          opts, pat = option_partition(opts, list, target: target)
+          out = []
           opts.each do |opt|
-            if list.include?(opt)
-              @session << "--#{opt}"
-            elsif opt.match(/^g(?:roup)?=(.+)$/)
-              @session << shell_option('group', $1)
+            if opt =~ pat
+              case $1
+              when 'path', 'gemfile', 'binstubs', 'target-rbconfig'
+                target << quote_option($1, basepath($2))
+              when 'standalone', 'with', 'without', 'g', 'group'
+                target << shell_quote($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
+          option_clear(out, target: target)
         end
 
-        def gem_session(*cmd)
-          ret = session('gem', *cmd)
-          if (val = option('config-file', ignore: false))
-            ret << shell_option('config-file', basepath(val), quote: true)
-          end
-          ret << '--norc' if option('norc')
+        def gem_session(*cmd, **kwargs)
+          ret = session('gem', *cmd, **kwargs)
+          ret << '--no-verbose' unless verbose
           ret
         end
 
-        def bundle_session(*cmd)
-          session('bundle', *cmd)
-          append_nocolor option('no-color')
-          @session
+        def bundle_session(*cmd, **kwargs)
+          ret = session('bundle', *cmd, **kwargs)
+          append_nocolor(target: ret)
+          ret
+        end
+
+        def rake_session(*cmd, **kwargs)
+          session('rake', *cmd, **kwargs)
+        end
+
+        def gem_output(*cmd, **kwargs)
+          session_output('gem', *cmd, **kwargs)
+        end
+
+        def bundle_output(*cmd, **kwargs)
+          session_output('bundle', *cmd, **kwargs)
+        end
+
+        def rake_output(*cmd, **kwargs)
+          session_output('rake', *cmd, **kwargs)
         end
 
         def read_rakefile
@@ -457,8 +608,8 @@ module Squared
           ret = []
           pass = Rake::VERSION >= '13.0.4'
           pwd_set(pass: pass) do
-            IO.popen("rake#{pass ? " -C #{shell_quote(path)}" : ''} -AT").each do |line|
-              next unless (data = /\Arake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/.match(line))
+            IO.popen(rake_output(pass ? "-C #{shell_quote(path)}" : nil, '-AT').to_s).each do |line|
+              next unless (data = /^rake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/.match(line))
 
               ret << [data[1], data[2]]
             end
@@ -471,8 +622,7 @@ module Squared
         end
 
         def variables
-          ret = super + VAR_SET
-          ret.freeze
+          (super + %i[version autodetect]).freeze
         end
 
         def rakefile
@@ -480,9 +630,23 @@ module Squared
           basepath(file) if file
         end
 
+        def rakeapp
+          quote_option 'rakefile', Rake.application.rakefile
+        end
+
         def gempath
           File.join('gems', "#{project}-#{@version}")
         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
+        end
       end
 
       Application.implement Ruby