squared 0.4.37 → 0.5.0

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

@@ -4,16 +4,17 @@ module Squared
   module Workspace
     module Project
       class Ruby < Git
-        GEMFILE = %w[Gemfile Gemfile.lock gem.deps.rb gems.rb Isolate].freeze
+        GEMFILE = %w[Gemfile Gemfile.lock gem.deps.rb Isolate].freeze
         DIR_RUBY = (GEMFILE + Rake::Application::DEFAULT_RAKEFILES + ['README.rdoc']).freeze
         OPT_RUBY = {
-          ruby: %w[0=im? a c C=pm e=q E=bm F=qm i=bm? I=pm l n p r=bm s S w W=bm? x=pm? d|debug jit rjit verbose
-                   y|yydebug backtrace-limit=i crash-report=q disable=q dump=q enable=q encoding=b external-encoding=b
+          ruby: %w[0=im? a c e=q E=bm F=qm i=bm? I=pm l n p r=bm s S w W=bm? x=pm? d|debug jit rjit v|verbose y|yydebug
+                   backtrace-limit=i crash-report=q disable=q dump=q enable=q encoding=b external-encoding=b
                    internal-encoding=b parser=b].freeze,
-          rake: %w[A|all B|build-all comments n|dry-run m|multitask P|prereqs q|quiet X|no-deprecation-warnings
-                   N|no-search G|no-system nosearch nosystem rules s|silent g|system v|verbose backtrace=b?
-                   D|describe=q? e|execute=q E|execute-continue=q p|execute-print=q job-stats=b? j|jobs=i? I|libdir=p
-                   R|rakelib=p rakelibdir=p r|require=b suppress-backtrace=q T|tasks=q? t|trace=b? W|where=q?].freeze,
+          rake: %w[A|all B|build-all comments n|dry-run p|execute-print=q m|multitask P|prereqs q|quiet
+                   X|no-deprecation-warnings N|no-search G|no-system nosearch nosystem rules s|silent g|system
+                   v|verbose backtrace=b? D|describe=q? e|execute=q E|execute-continue=q job-stats=b? j|jobs=i?
+                   I|libdir=p R|rakelib=p rakelibdir=p r|require=b suppress-backtrace=q T|tasks=q? t|trace=b?
+                   W|where=q?].freeze,
           irb: %w[d f U w E=b I=p r=b W=im? autocomplete colorize echo echo-on-assignment extra-doc-dir inf-ruby-mode
                   inspect multiline no-pager noautocomplete nocolorize noecho noecho-on-assignment noinspect
                   nomultiline noprompt noscript nosingleline noverbose regexp-completor sample-book-mode script
@@ -21,41 +22,38 @@ module Squared
                   back-trace-limit=i context-mode=i prompt=b prompt-mode=b].freeze
         }.freeze
         OPT_BUNDLE = {
-          common: %w[no-color V|verbose r|retry=i].freeze,
+          common: %w[no-color V|verbose retry=i].freeze,
           install: %w[frozen no-cache no-prune system binstubs=p? path=p standalone=q? target-rbconfig=p trust-policy=b
                       with=q without=q].freeze,
-          install_base: %w[force full-index local quiet redownload gemfile=p j|jobs=i].freeze,
-          update: %w[all conservative local major minor patch pre ruby strict bundler=b? g|group=q source=b].freeze,
-          outdated: %w[filter-major filter-minor filter-patch filter-strict groups local parseable porcelain pre
-                       only-explicit strict update-strict group=q source=b].freeze,
+          install_base: %w[full-index quiet retry gemfile=p j|jobs=i].freeze,
+          update: %w[conservative local pre redownload ruby strict bundler=b? g|group=q source=b].freeze,
+          outdated: %w[filter-major filter-minor filter-patch groups local parseable pre only-explicit strict
+                       update-strict g|group=q source=b].freeze,
           exec: %w[gemfile=p].freeze,
-          cache: %w[all all-platforms frozen no-all no-install no-prune quiet cache-path=p gemfile=p path=p].freeze,
-          check: %w[dry-run gemfile=p path=p].freeze
+          cache: %w[all-platforms frozen no-install no-prune quiet cache-path=p gemfile=p path=p].freeze,
+          check: %w[dry-run gemfile=p].freeze
         }.freeze
         OPT_GEM = {
           common: %w[backtrace debug q|quiet no-verbose norc silent V|verbose config-file=p].freeze,
-          install: %w[version=q].freeze,
-          install_base: %w[E f w b|both clear-sources conservative default development development-all explain
-                           ignore-dependencies l|local N|no-document r|remote vendor n|bindir=p build-root=p
-                           B|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=q].freeze,
+          install: %w[version=b].freeze,
+          install_base: %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=b].freeze,
           update: %w[system=b?].freeze,
-          uninstall: %w[a D I x vendor n|bindir=p i|install-dir=p platform=b v|version=q].freeze,
-          outdated: %w[b|both clear-sources l|local r|remote B|bulk-threshold=i p|http-proxy=q? platform=q
+          uninstall: %w[a D I x vendor n|bindir=p i|install-dir=p platform=b v|version=b].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[attestation=p host=q p|http-proxy=q? k|key=b otp=b].freeze,
-          build: %w[C=p force strict o|output=p platform=q].freeze,
-          exec: %w[conservative g|gem=b v|version=q].freeze,
-          pristine: %w[E all only-executables only-missing-extensions only-plugins n|bindir=p i|install-dir=p skip=b
-                       v|version=q].freeze,
+          push: %w[no-http-proxy attestation=p host=q p|http-proxy=q? key=b otp=b].freeze,
+          build: %w[force strict o|output=p platform=q].freeze,
+          exec: %w[conservative no-prerelease prerelease g|gem=v version=b].freeze,
+          pristine: %w[all only-executables only-missing-extensions only-plugins n|bindir=p i|install-dir=p skip=b
+                       v|version=b].freeze,
           no: {
             install: %w[env-shebang force format-executable http-proxy lock minimal-deps post-install-message prerelease
                         suggestions user-install wrappers].freeze,
             uninstall: %w[abort-on-dependent all check-development executables force format-executable
                           ignore-dependencies user-install].freeze,
-            outdated: %w[http-proxy].freeze,
-            push: %w[http-proxy].freeze,
-            exec: %w[prerelease].freeze,
             pristine: %w[env-shebang extensions].freeze
           }.freeze
         }.freeze
@@ -69,7 +67,7 @@ module Squared
           end
 
           def bannerargs
-            %i[dependfile gemname gemdir].freeze
+            [:dependfile].freeze
           end
 
           def config?(val)
@@ -83,7 +81,7 @@ 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 uninstall update pristine outdated build push exec].freeze,
+          'gem' => %i[install uninstall update pristine outdated push build exec].freeze,
           'ruby' => %i[file script version].freeze,
           'exec' => nil,
           'cache' => nil,
@@ -93,9 +91,7 @@ module Squared
           'irb' => nil
         })
 
-        attr_reader :gemdir
-
-        def initialize(*, autodetect: false, gemspec: nil, **kwargs)
+        def initialize(*, autodetect: false, **kwargs)
           super
           if @pass.include?(Ruby.ref)
             initialize_ref Ruby.ref
@@ -106,15 +102,11 @@ module Squared
           end
           dependfile_set GEMFILE
           @autodetect = autodetect
-          @gemfile = if gemspec == false
-                       false
-                     elsif gemspec
-                       basepath(gemspec.include?('.') ? gemspec : "#{gemspec}.gemspec")
-                     end
-          return if !@output[0].nil? || !@copy.nil? || version || @autodetect || !rakefile
+          @rakelist = nil
+          return if !@output[0].nil? || !@copy.nil? || @version || @autodetect || (file = rakefile).nil?
 
           begin
-            File.foreach(rakefile) do |line|
+            File.foreach(file) do |line|
               next unless line.match?(%r{\brequire\s+(["'])bundler/gem_tasks\1})
 
               cmd = bundle_output('exec rake').to_s
@@ -128,73 +120,60 @@ module Squared
           end
         end
 
-        def gemdir=(val)
-          @gemdir = if val.is_a?(Pathname)
-                      val
-                    else
-                      Pathname.new(val).realdirpath rescue nil
-                    end
-        end
-
         def ref
           Ruby.ref
         end
 
         def populate(*, **)
           super
-          return unless (outdated? && ref?(Ruby.ref)) || @only
+          return unless outdated? && ref?(Ruby.ref)
 
           namespace name do
             Ruby.subtasks do |action, flags|
-              next if task_pass?(action)
+              next if @pass.include?(action)
 
               if flags.nil?
                 case action
                 when 'rake'
                   next unless rakefile
 
-                  format_desc action, nil, "task+,opts*|#{indexchar}index+|#,pattern*"
+                  format_desc action, nil, 'tasks*,opts*|^index|#,pattern*'
                   task action, [:command] do |_, args|
                     if args.command == '#'
-                      format_list(raketasks, "rake[#{indexchar}N]", 'tasks', grep: args.extras, from: rakefile,
-                                                                             each: ->(val) { val[0] + val[1].to_s })
-                    else
-                      args, opts = args.to_a.partition { |val| indexitem(val) }
-                      if args.empty?
-                        rake(opts: opts)
+                      format_list(read_rakefile, 'rake[^N]', 'tasks', grep: args.extras, from: rakefile.to_s,
+                                                                      each: ->(val) { val[0] + val[1].to_s })
+                    elsif (n, opts = indexitem(args.command))
+                      list = read_rakefile
+                      if (item = list[n - 1])
+                        cmd = opts ? "#{opts} #{item.first}" : item.first
+                      elsif exception
+                        indexerror n, list
                       else
-                        tasks = raketasks
-                        while (n, pre = indexitem(args.shift))
-                          if (item = tasks[n - 1])
-                            cmd = pre ? "#{pre} #{item.first}" : item.first
-                          elsif exception
-                            indexerror n, tasks
-                          else
-                            log.warn "rake task #{n} of #{tasks.size} (out of range)"
-                            next
-                          end
-                          if opts.empty?
-                            rake cmd
-                          else
-                            rake(cmd + shell_escape("[#{opts.join(',')}]"))
-                            opts.clear
-                          end
-                        end
+                        log.warn "rake task #{n} of #{list.size} (out of range)"
+                        next
                       end
+                      rake(args.extras.empty? ? cmd : cmd + shell_escape("[#{args.extras.join(',')}]"))
+                    else
+                      rake(opts: args.to_a)
                     end
                   end
                 when 'irb'
+                  next unless (spec = basepath("#{project}.gemspec") || basepath("#{name}.gemspec"))
+                  next unless basepath('lib').join("#{gemname = stripext(spec)}.rb").exist?
+
                   format_desc action, nil, 'opts*,args*|:'
                   task action do |_, args|
                     args = args.to_a
-                    name = gemlib.any? { |file| basepath(file).join("#{gemname}.rb").exist? } ? gemname : nil
-                    irb(name, args, args: (readline('Enter file [arguments]', force: false) if args.delete(':')))
+                    if args.last == ':'
+                      args.pop
+                      load = readline('Enter file and arguments', force: false)
+                    end
+                    irb(gemname, args, load: load)
                   end
                 else
-                  format_desc(action, nil, 'opts*', before: case action
-                                                            when 'cache', 'check' then nil
-                                                            else 'command+'
-                                                            end)
+                  format_desc(action, nil, OPT_BUNDLE[action.to_sym], after: case action
+                                                                             when 'cache', 'check' then nil
+                                                                             else 'command+' end)
                   task action do |_, args|
                     bundle(action, *args.to_a)
                   end
@@ -216,24 +195,20 @@ module Squared
                           case (filter = args.semver)
                           when 'major', 'minor', 'patch', 'interactive', 'i'
                             filter = 'interactive' if filter == 'i'
-                            args = args.extras
+                            args = args.to_a.drop(1)
                           else
                             filter = nil
                             args = args.to_a
                           end
                           gem!(flag, args, filter: filter)
                         end
-                      when :build, :push, :exec, :update
-                        format_desc(action, flag, 'opts*', after: case flag
-                                                                  when :exec then 'command,args*'
-                                                                  when :push then 'file?'
-                                                                  when :update then 'name*'
-                                                                  end)
+                      when :build, :push, :exec
+                        format_desc(action, flag, 'opts*', before: flag == :exec ? 'command,args*' : nil)
                         task flag do |_, args|
                           gem! flag, args.to_a
                         end
                       else
-                        format_desc(action, flag, 'opts*', after: flag == :pristine ? 'name*|name?@version' : 'name*')
+                        format_desc action, flag, "opts*,name+#{flag == :pristine ? '|name?@version' : ''}"
                         task flag do |_, args|
                           args = param_guard(action, flag, args: args.to_a)
                           gem! flag, args
@@ -245,26 +220,22 @@ module Squared
                         format_desc action, flag, 'path,opts*,args*'
                         task flag, [:rb] do |_, args|
                           file = args.rb
-                          opts = args.extras
-                          args = if file && !file.include?('*')
-                                   ENV['RUBY_ARGS']
-                                 else
-                                   a, b, c = choice_index('Select a file', Dir.glob(file || path.join('*.rb')),
-                                                          values: (file ? [] : ['Options']).push('Arguments'),
-                                                          series: true)
-                                   if file
-                                     file = a
-                                     b
-                                   else
-                                     file = a
-                                     opts.concat(OptionPartition.strip(b))
-                                     c
-                                   end
-                                 end
-                          ruby(flag, opts, file: file, args: args)
+                          args = args.to_a.drop(1)
+                          unless file && !file.include?('*')
+                            values = ['Arguments']
+                            values.prepend('Options') unless file
+                            file, opts, extra = choice_index('Select a file', Dir.glob(file || '*.rb', base: path),
+                                                             values: values, force: true, series: !args.include?('v'))
+                            if file
+                              extra = opts
+                            else
+                              args.concat(OptionPartition.strip(opts))
+                            end
+                          end
+                          ruby(flag, args, file: file, args: extra)
                         end
                       when :script
-                        format_desc action, flag, 'opts*'
+                        format_desc action, flag, 'opts*,args*'
                         task flag do |_, args|
                           command = ENV['RUBY_E'] || readline('Enter script', force: true, multiline: ['##', ';'])
                           ruby(flag, args.to_a, command: command)
@@ -297,9 +268,7 @@ module Squared
           end
         end
 
-        def copy(from: gemlib, into: gemdir, override: false, **kwargs)
-          return if @copy == false
-
+        def copy(from: 'lib', into: @gemdir, override: false, **kwargs)
           glob = kwargs[:include]
           pass = kwargs[:exclude]
           if @copy && !override
@@ -309,22 +278,26 @@ module Squared
             glob = @copy[:include] if @copy.key?(:include)
             pass = @copy[:exclude] if @copy.key?(:exclude)
             into = @copy[:into] if @copy.key?(:into)
+          elsif @copy == false
+            return
           end
           return unless into
 
           on :first, :copy
           dest = Pathname.new(into).realpath
           print_item unless @output[0] || task_invoked?(/^copy(?::#{Ruby.ref}|$)/)
-          glob = Array(glob || '**/*')
-          Array(from).each_with_index do |val, i|
-            a = basepath val
+          glob = as_a(glob || '**/*')
+          as_a(from).each_with_index do |val, i|
+            a = path + val
             b = dest + val
             c = glob[i] || glob.first
             log.info "cp #{a + c} #{b}"
             begin
-              copy_dir(a, b, c, pass: pass, verbose: verbosetype > 0)
+              copy_dir(a, b, c, pass: pass, verbose: verbose)
             rescue StandardError => e
-              on_error e, :copy
+              log.error e
+              ret = on(:error, :copy, e)
+              raise if exception && ret != true
             end
           end
           on :last, :copy
@@ -338,7 +311,7 @@ module Squared
           end
           log.info cmd.to_s
           on :first, :outdated
-          banner = format_banner(cmd.to_s)
+          banner = format_banner cmd.to_s
           print_item banner if sync
           pwd_set(from: :outdated) do
             start = 0
@@ -429,7 +402,7 @@ module Squared
             end
             if found > 0
               begin
-                if major == 0 && dependfile.read =~ /\b(?:source\s+(["'])(.+?)\1|remote:\s+(\S+))/
+                if major == 0 && dependfile.read =~ /\b(?:source\s+(["'])((?~\1))\1|remote:\s+(\S+))/
                   status = ($2 || $3).chomp('/')
                   right = true
                 end
@@ -448,23 +421,14 @@ module Squared
 
         def install(flag, opts = [])
           bundle_session 'install', "--#{flag}"
-          op = append_bundle opts, OPT_BUNDLE[:install_base] + OPT_BUNDLE[:install] + OPT_BUNDLE[:common]
-          if op.arg?('force')
-            op.delete('--force')
-            if flag != :redownload
-              op << '--redownload'
-            elsif (lock = basepath('Gemfile.lock')).exist?
-              config = basepath '.bundle', 'config'
-              lock.delete unless config.exist? && config.read.match?(/\bBUNDLE_FROZEN:\s+"true"/)
-            end
-          end
+          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, OPT_BUNDLE[:install_base] + OPT_BUNDLE[:update] + OPT_BUNDLE[:common],
-                        append: flag == :all ? nil : /\A[a-z-]+=/)
+                        append: flag == :all ? nil : /\A[a-z\-]+=/)
           run_rb(from: :update)
         end
 
@@ -472,26 +436,24 @@ module Squared
           case flag
           when :file, :script
             op = OptionPartition.new(opts, OPT_RUBY[:ruby], ruby_session, project: self, args: true)
-            if command
+            if file
+              op.extras.prepend(shell_quote(path + file))
+            elsif command
               op << quote_option('e', command, option: false)
-            elsif file
-              op.unshift(basepath(file))
-            end
-            unless op.arg?('e')
-              op.push(args) if args
-              op.append(delim: true, escape: false, quote: false) unless op.empty?
             end
+            op.extras << args if (args = ENV.fetch('RUBY_ARGS', args))
+            op.append(delim: true, escape: false, quote: false) unless op.empty?
           when :version
             pwd_set do
               out = []
               [
-                "#{ENV.fetch('RBENV_ROOT', '$HOME/.rbenv')}/bin/rbenv",
                 '$HOME/.rvm/bin/rvm',
-                "#{ENV.fetch('ASDF_DATA_DIR', '$HOME/.asdf')}/plugins/ruby/bin/install",
-                '/usr/bin/rbenv',
                 '/usr/local/rvm/bin/rvm',
                 '/usr/share/rvm/bin/rvm',
+                "#{ENV.fetch('RBENV_ROOT', '$HOME/.rbenv')}/bin/rbenv",
+                '/usr/bin/rbenv',
                 '/usr/local/share/chruby/chruby.sh',
+                "#{ENV.fetch('ASDF_DATA_DIR', '$HOME/.asdf')}/plugins/ruby/bin/install",
                 ''
               ].each do |val|
                 next unless val.empty? || File.exist?(val.sub('$HOME', Dir.home))
@@ -502,27 +464,25 @@ module Squared
                                  when 'rvm'
                                    `rvm current`[/^\S+/, 0]
                                  when 'rbenv'
-                                   name = `rbenv version-name`
-                                   (name =~ SEM_VER) == 0 ? "ruby #{name}" : name
+                                   `rbenv version-name`.yield_self do |name|
+                                     name.match?(SEM_VER) ? "ruby #{name}" : name
+                                   end
                                  when 'chruby.sh'
                                    chruby = session_output 'source', val
                                    `#{chruby.with('ruby --version')}`
                                  when 'install'
                                    ver = '.tool-versions'
-                                   exit 1 unless (cur = `asdf current ruby`[/ruby\s+\S+/, 0])
-                                   cur.sub(/\s+/, ' ')
+                                   `asdf current ruby`[/ruby\s+\S+/, 0].sub(/\s+/, ' ')
                                  else
                                    ver = nil
                                    `ruby --version`
                                  end)
-                break if workspace.windows?
-
                 unless val.empty?
                   out << trim.call(case cmd
                                    when 'chruby.sh'
                                      `#{chruby.with('chruby --version')}`.sub(':', '')
                                    when 'install'
-                                     "asdf #{`asdf version`.sub(/^v/, '')}"
+                                     "asdf #{`asdf version`.delete_prefix('v')}"
                                    else
                                      `#{cmd} --version`
                                    end)
@@ -557,14 +517,16 @@ module Squared
             end
             return
           end
-          run_rb(banner: false, from: :"ruby:#{flag}")
+          run_rb(banner: op.arg?('v'), from: :"ruby:#{flag}")
         end
 
         def gem!(flag, opts = [], filter: nil)
           cmd = gem_session
           case flag
           when :outdated
-            cmd << gempwd << flag
+            cmd << gempwd << 'outdated'
+          when :push
+            cmd << 'push' << project
           else
             cmd << flag
           end
@@ -573,10 +535,19 @@ module Squared
           case flag
           when :install, :update
             list.concat(OPT_GEM[:install_base])
+            first = ['=']
+          when :uninstall, :pristine
+            first = ['=']
           end
-          op = OptionPartition.new(opts, list, cmd, project: self, no: OPT_GEM[:no][flag])
+          cmd.merge(preopts)
+          op = OptionPartition.new(opts, list, cmd, project: self, no: OPT_GEM[:no][flag], first: first)
           op.each do |opt|
-            if !opt.match?(/\A[A-Za-z\d][A-Za-z\d_.-]*\z/) && %i[install uninstall update pristine].include?(flag)
+            if opt =~ op.values
+              case $1
+              when 'g', 'gem'
+                op << (flag == :exec ? shell_option($1, $2) : quote_option($1, path + $2))
+              end
+            elsif opt.include?('=') && !%i[outdated build push exec].include?(flag)
               op.errors << opt
             else
               op.found << opt
@@ -585,18 +556,17 @@ module Squared
           op.swap
           case flag
           when :outdated
+            log.info cmd.to_s
             op.clear
-            cmd = cmd.done
-            log.info cmd
             on :first, from
-            print_item format_banner(cmd)
+            print_item format_banner(cmd.to_s)
             major = 0
             minor = 0
             patch = 0
             update = []
-            pwd_set(pass: !gempwd.nil?, from: from) do
+            pwd_set(pass: !pwd.nil?, from: from) do
               items = [[%w[Gem Current Latest], nil]]
-              IO.popen(cmd).each do |line|
+              IO.popen(cmd.done).each do |line|
                 if line =~ /^(\S+) \((\S+) < ([^)]+)\)$/
                   cur = semscan $2
                   lat = semscan $3
@@ -671,8 +641,7 @@ module Squared
                       styles = %i[yellow]
                       pat = pat.last
                     end
-                    b = b.rjust(e)
-                    b = sub_style(b, *colormap(styles), pat: pat, index: 2)
+                    b = sub_style(b.rjust(e), *colormap(styles), pat: pat, index: 2)
                     h = sub_style(c.rjust(f), styles: latest.flatten.compact, pat: pat, index: 2)
                     j += 1
                     if queue
@@ -690,15 +659,15 @@ module Squared
             else
               unless update.empty?
                 cmd = gem_output 'update', '-f'
-                if (val = option('document', prefix: 'gem', ignore: false))
+                option('document', prefix: 'gem', ignore: false) do |val|
                   cmd << case val
                          when '0', 'false'
                            '--no-document'
                          else
-                           basic_option('document', val)
+                           basic_option 'document', val
                          end
                 end
-                if (val = option('user-install', prefix: 'gem', ignore: false))
+                option('user-install', prefix: 'gem', ignore: false) do |val|
                   cmd << case val
                          when '0', 'false'
                            '--no-user-install'
@@ -709,84 +678,58 @@ module Squared
                 cmd.merge(update)
                 run(cmd, banner: false, from: :'gem:update')
               end
-              print_status(major, minor, patch, from: :outdated)
+              unless stdin?
+                status = print_footer("major #{major} / minor #{minor} / patch #{patch}", right: true).split("\n")
+                status[1] = status[1]
+                            .yield_self do |s|
+                              sub_style(s, pat: /^( +major )(\d+)(.+)$/, styles: theme[:major], index: 2)
+                            end
+                            .yield_self do |s|
+                              sub_style(s, pat: /^(.+)(minor )(\d+)(.+)$/, styles: theme[:active], index: 3)
+                            end
+                puts status
+              end
             end
             on :last, from
             return
-          when :build
-            if op.empty?
-              raise_error('gemspec not found', hint: project) unless gemfile
-              op.add_path(gemfile)
-            else
-              op.add_path(op.shift)
-                .clear(pass: false)
-            end
-          when :push
-            if op.empty?
-              file = basepath(if (spec = gemspec)
-                                "#{spec.name}-#{spec.version}.gem"
-                              else
-                                gems = Dir.glob(basepath('*.gem')).map { |val| File.basename(val) }
-                                choice_index 'Select a file', gems
-                              end)
-            else
-              file = op.shift
-              raise_error("unknown args: #{op.join(', ')}", hint: flag) unless op.empty?
+          when :build, :push
+            if !op.empty?
+              if flag == :build && op.size == 1
+                op << shell_quote(path + op.first)
+              else
+                raise_error("unknown args: #{op.join(', ')}", hint: flag)
+              end
+            elsif flag == :build
+              spec = [path + "#{project}.gemspec", path + "#{name}.gemspec", *path.glob('*.gemspec')]
+              op << File.basename(spec) if (spec = spec.find { |file| File.exist?(file) })
             end
-            raise_error('gem not found', hint: file) unless op.exist?(file)
-            op.add_path(file)
-            run_rb(from: from, interactive: "Push #{sub_style(gemname, styles: theme[:active])}")
-            return
           when :exec
-            min = if op.arg?('g', 'gem')
-                    1
-                  elsif op.empty?
-                    op << basic_option('gem', gemname)
-                    1
-                  else
-                    op << op.shift
-                    0
-                  end
-            if (args = command_args(op.extras, min: min, force: min == 1 && op.empty?))
+            raise_error('missing command', hint: flag) if op.empty?
+            op << basic_option('gem', project) unless op.arg?('g', 'gem')
+            if (args = command_args(op.extras))
               op.push(args)
             end
-            op.append(quote: false)
-          when :update
-            unless op.arg?('system')
-              if op.empty?
-                op << gemname
-              else
-                op.append
-              end
-            end
-            op.clear(errors: true)
-          when :install, :uninstall, :pristine
-            raise_error('missing gemname', hint: flag) if op.empty?
-            if op.arg?('all')
-              if flag == :pristine
+            op.append(delim: true, quote: false)
+          else
+            raise_error('missing gemname', hint: flag) if op.empty? && !op.arg?('system')
+            if flag == :pristine
+              if op.arg?('all')
                 append_repeat 'skip', op.extras
-                op.reset
-              else
+                op.extras.clear
+              elsif (n = op.first.index('@'))
+                name = op.shift
+                if n == 0
+                  op << project
+                  ver = name[1..-1]
+                else
+                  op << shell_escape(name[0, n])
+                  ver = name[n + 1..-1]
+                end
+                op << shell_option('version', ver)
                 op.clear
               end
-            elsif (n = op.index { |val| val.match?(/(\A|[\w.-])@\d/) })
-              name = op.delete_at(n)
-              pre, ver = if (n = name.index('@')) == 0
-                           [gemname, name[1..-1]]
-                         else
-                           [name[0, n], name[(n + 1)..-1]]
-                         end
-              op.adjoin(pre, basic_option('version', ver))
-                .clear
-            elsif flag == :install
-              op.append_any
-            else
-              op.append
             end
-            op.clear(errors: true)
-            op << '--' << readline('Enter command [args]', force: true) if flag == :install && op.remove(':')
-          else
-            op.append
+            op.append.clear(errors: true)
           end
           run_rb(from: from)
         end
@@ -796,24 +739,26 @@ module Squared
           args = case flag
                  when 'exec', 'cache', 'check'
                    list = OPT_BUNDLE[flag.to_sym] + OPT_BUNDLE[:common]
-                   OptionPartition.new(args, list, cmd, project: self, args: flag == 'exec').extras
+                   OptionPartition.new(args, list, cmd, project: self, args: flag == :exec).extras
                  else
                    args.flatten
                  end
           case flag
           when 'exec', 'config'
-            cmd << readline('Enter arguments', force: true) if args.empty?
-          when 'cache', 'check'
+            if args.empty?
+              cmd << readline('Enter arguments', force: true)
+            else
+              args << command_args(args)
+              cmd.merge(args)
+            end
+          else
             option_clear args
-            args.clear
           end
-          cmd.merge(args)
           run(from: :"bundle:#{flag}")
         end
 
         def rake(*args, opts: [])
-          op = OptionPartition.new(opts, OPT_RUBY[:rake], [(quote_option('f', rakefile) if rakefile)].compact,
-                                   project: self)
+          op = OptionPartition.new(opts, OPT_RUBY[:rake], [quote_option('f', rakefile)], project: self)
           args.concat(op.extras)
           if args.empty?
             args << nil
@@ -825,14 +770,14 @@ module Squared
           run_s(args, banner: false, from: :rake)
         end
 
-        def irb(name = nil, opts = [], path: gemlib, args: nil)
+        def irb(name, opts = [], path: @path + 'lib', load: nil)
           op = OptionPartition.new(opts, OPT_RUBY[:irb], session('irb'), project: self, first: [/\.rb$/])
-          r = args ? [] : ['bundler/setup']
-          r << name if name
+          r = as_a name
+          r.prepend('bundler/setup') unless load
           r.each { |val| op << shell_option('r', val, merge: true) }
-          Array(path).each { |val| op << quote_option('I', val, merge: true) }
-          if args
-            op << '--' << args
+          as_a(path).each { |val| op << quote_option('I', val, merge: true) }
+          if load
+            op << '--' << load
             op.clear
           else
             op.append(delim: true)
@@ -840,85 +785,76 @@ module Squared
           run(banner: false)
         end
 
-        def gemspec
-          @gemspec = !gemfile.nil? && Gem::Specification.load(gemfile.to_s) rescue false if @gemspec.nil?
-          @gemspec || nil
-        end
-
-        def gemname
-          @gemname ||= ((spec = gemspec) ? spec.name : project)
-        end
-
         def depend?
           @depend != false && (!@depend.nil? || outdated?)
         end
 
         def copy?
-          return true if @copy.is_a?(Hash) ? copy[:into] : super
-          return gemdir? if gemdir
-          return false unless @autodetect
-
-          set = lambda do |val, path|
-            base = Pathname.new(path.strip)
-            return false unless base.join(gempath(val, 'specifications')).exist?
+          return true if super || (@copy.is_a?(Hash) && copy.fetch(:into, nil))
+          return gemdir? if @gemdir
 
-            log.warn "using version #{val} (given #{version})" if version && version != val
-            self.version = val
-            self.gemdir = base + gempath
-          end
-          if version
+          if @version
             begin
               case @autodetect
               when 'rvm'
-                self.gemdir = pwd_set { `rvm info homes` }[/^\s+gem:\s+"(.+)"$/, 1]
+                @gemdir = pwd_set { `rvm info homes` }[/^\s+gem:\s+"(.+)"$/, 1]
               when 'rbenv'
                 if pwd_set { `rbenv which ruby` } =~ %r{^(.+[\\/]versions[\\/](\d\.\d)\.[^\\/]+)[\\/]bin[\\/]ruby$}
-                  self.gemdir = File.join($1, 'lib/ruby/gems', "#{$2}.0")
+                  @gemdir = File.join($1, 'lib/ruby/gems', "#{$2}.0")
                 end
               when 'asdf'
-                val = pwd_set { `asdf where ruby`.chomp }
-                self.gemdir = File.join(val, 'lib/ruby/gems', "#{$1}.0") if val =~ /(\d\.\d)\.[^.]+$/
+                @gemdir = pwd_set { `asdf where ruby` }
+                @gemdir = @gemdir =~ /(\d\.\d)\.[^.]+$/ && File.join(@gemdir, 'lib/ruby/gems', "#{$1}.0")
               when /bundler?/
-                path = pwd_set { `bundle env` }[/^\s+Gem Path\s+(.+)$/, 1]
-                self.gemdir = path.split(File::PATH_SEPARATOR).find { |val| Dir.exist?(val) }
-              else
-                self.gemdir = ENV['GEM_HOME'] || ENV['GEM_ROOT']
+                @gemdir = pwd_set { `bundle env` }[/^\s+Gem Home\s+(.+)$/, 1]
               end
-              return true if gemdir?
             rescue StandardError => e
               log.debug e
+            else
+              @gemdir = Pathname.new(@gemdir) if @gemdir
             end
-            pwd_set(pass: !gempwd.nil?) do
-              out = `#{gem_output(gempwd, 'list --local -d', gemname)}`
-              if out =~ /#{Regexp.escape(gemname)}\s+\((.+)\)$/
-                split_escape($1)
-                  .unshift(@version)
+            return true if gemdir?
+          end
+          return false unless @autodetect
+
+          set = lambda do |val, path|
+            log.warn "using version #{val} (given #{@version})" if @version && @version != val
+            @version = val
+            @gemdir = Pathname.new(path.strip) + gempath
+          end
+          if @version
+            pwd = gempwd
+            pwd_set(pass: !pwd.nil?) do
+              out = `#{gem_output(pwd, 'list --local -d', project)}`
+              if out =~ /#{Regexp.escape(project)} \(([^)]+)\)/
+                $1.split(/\s*,\s*/)
+                  .prepend(@version)
                   .uniq
                   .each do |val|
-                    next unless out =~ /(?:\(#{Regexp.escape(val)}[^)]*\)|Installed at):\s+(.+)$/
+                    next unless out =~ /\(#{Regexp.escape(val)}(?:,[^)]+|\b)\):([^\n]+)/
 
-                    return gemdir? if set.call(val, $1)
+                    set.call(val, $1)
+                    break
                   end
               end
             end
-            self.gemdir = Pathname.new(Gem.dir) + gempath
-          else
+          end
+          unless @gemdir
             parse = lambda do |path|
               next unless path
 
-              lib = Regexp.new(['', 'gems', "#{gemname}-([^#{File::SEPARATOR}]+)", ''].join(File::SEPARATOR))
-              if (ver = path[lib, 1]) && (val = path[/\A(.+)#{Regexp.escape(gempath(ver))}/, 1])
+              lib = Regexp.new(['', 'gems', "#{project}-([^#{File::SEPARATOR}]+)", ''].join(File::SEPARATOR))
+              if (ver = path[lib, 1]) && (val = path[/\A(.+)#{gempath(ver[1])}/, 1])
                 set.call(ver, val)
               end
             end
             if RUBY_VERSION >= '2.6'
               target = RUBY_VERSION.start_with?('2.6') ? RubyVM : $LOAD_PATH
-              parse.call(target.resolve_feature_path(gemname)&.last)
-            end
-            if !gemdir && !pwd_set { parse.call(`#{bundle_output('show', gemname)}`) }
-              raise_error 'gems directory not found'
+              parse.call(target.resolve_feature_path(project)&.last)
             end
+            pwd_set { parse.call(`#{bundle_output('show', project)}`) } unless @gemdir
           end
+          raise_error('parse failed', hint: @version || 'path') unless @gemdir
         rescue StandardError => e
           log.error e
           @version = nil
@@ -929,13 +865,13 @@ module Squared
         end
 
         def outdated?
-          dependtype > 0 && !task_pass?('outdated')
+          dependtype > 0
         end
 
         private
 
         def run_rb(**kwargs)
-          run(banner: !@session&.include?('--quiet'), **kwargs)
+          run(banner: !@session.include?('--quiet'), **kwargs)
         end
 
         def append_bundle(opts, list, target: @session, append: nil)
@@ -955,7 +891,6 @@ module Squared
           else
             op.clear
           end
-          op
         end
 
         def ruby_session(*cmd, **kwargs)
@@ -963,11 +898,18 @@ module Squared
         end
 
         def gem_session(*cmd, **kwargs)
-          session('gem', *cmd, *preopts, **kwargs)
+          ret = session('gem', *cmd, **kwargs)
+          return ret if cmd.empty?
+
+          ret.merge(preopts)
         end
 
         def bundle_session(*cmd, **kwargs)
-          session('bundle', *cmd, *preopts, **kwargs).tap { append_nocolor }
+          ret = session('bundle', *cmd, **kwargs)
+          return ret if cmd.empty?
+
+          append_nocolor
+          ret.merge(preopts)
         end
 
         def rake_session(*cmd, **kwargs)
@@ -990,79 +932,54 @@ module Squared
           session_output('rake', *cmd, **kwargs)
         end
 
+        def read_rakefile
+          return @rakelist if @rakelist
+
+          ret = []
+          pwd = rakepwd
+          pwd_set(pass: !pwd.nil?) do
+            IO.popen(rake_output(pwd, '-AT').to_s).each do |line|
+              next unless line =~ /^rake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/
+
+              ret << [$1, $2]
+            end
+          end
+          @rakelist = ret
+        end
+
         def preopts
-          verbosetype > 1 ? ['--verbose'] : []
+          verbosetype > 1 && !session_arg?('quiet') ? ['--verbose'] : []
+        end
+
+        def gemdir?
+          !@gemdir.nil? && @gemdir.exist? && !@gemdir.empty?
         end
 
         def variables
-          (super + %i[autodetect]).freeze
+          (super + %i[version autodetect]).freeze
         end
 
         def rakefile
-          if @rakefile.nil?
-            file = Rake::Application::DEFAULT_RAKEFILES.find { |val| basepath(val).exist? }
-            @rakefile = !file.nil? && basepath(file)
-          end
-          @rakefile || nil
+          return unless (file = Rake::Application::DEFAULT_RAKEFILES.find { |val| basepath(val).exist? })
+
+          path + file
         end
 
         def rakepwd
-          return unless !pwd? && semgte?(Rake::VERSION, '13.0.4')
+          return unless Rake::VERSION >= '13.0.4'
 
           quote_option 'C', path
         end
 
-        def raketasks
-          @raketasks ||= [].tap do |ret|
-            opt = rakepwd
-            pwd_set(pass: !opt.nil?) do
-              IO.popen(rake_output(opt, '-AT').to_s).each do |line|
-                next unless line =~ /^rake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/
-
-                ret << [$1, $2]
-              end
-            end
-          end
-        end
-
         def gempwd
-          return unless !pwd? && semgte?(Gem::VERSION, '3.4.2')
+          return unless Gem::VERSION >= '3.4.2'
 
           quote_option 'C', path
         end
 
-        def gemfile
-          if @gemfile.nil?
-            @gemfile = [project, name].map! { |val| basepath("#{val}.gemspec") }
-                                      .concat(Dir.glob(basepath('*.gemspec')))
-                                      .find { |file| File.exist?(file) } || false
-          end
-          @gemfile || nil
+        def gempath(val = @version)
+          File.join('gems', "#{project}-#{val}")
         end
-
-        def gemlib
-          @gemlib ||= begin
-            lib = Set.new(['lib'])
-            if (spec = gemspec)
-              lib.merge(spec.require_paths || [])
-            end
-            lib.select { |file| basepath(file).exist? }
-          end
-        end
-
-        def gempath(val = version, dir = 'gems')
-          ret = File.join(dir, "#{gemname}-#{val}")
-          ret += '.gemspec' if dir == 'specifications'
-          ret
-        end
-
-        def gemdir?
-          return false unless gemdir
-
-          gemdir.exist? && !gemdir.empty?
-        end
-
-        alias read_rakefile raketasks
       end
 
       Application.implement Ruby