squared 0.4.6 → 0.4.8

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

@@ -7,6 +7,9 @@ module Squared
         GEMFILE = %w[Gemfile Gemfile.lock gem.deps.rb Isolate].freeze
         DIR_RUBY = (GEMFILE + Rake::Application::DEFAULT_RAKEFILES + ['README.rdoc']).freeze
         OPT_RUBY = {
+          ruby: %w[a c l n p s S w d|debug jit rjit v|verbose y|yydebug 0=im? backtrace-limit=i crash-report=q
+                   disable=q dump=q e=q enable=q encoding=b external-encoding=b Eex=m? F=qm i=m? internal-encoding=b
+                   I=pm parser=b r=bm W=bm? x=pm?].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 I|libdir=p job-stats=b?
@@ -33,20 +36,25 @@ module Squared
         OPT_GEM = {
           common: %w[backtrace debug q|quiet no-verbose norc silent V|verbose config-file=p].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=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[no-http-proxy attestation=p host=q key=b otp=b p|http-proxy=q?].freeze,
           build: %w[force strict o|output=p platform=q].freeze,
-          exec: %w[conservative prerelease no-prerelease g|gem=b version=b].freeze,
+          exec: %w[conservative prerelease no-prerelease g|gem=v version=b].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=b v|version=b].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=b].freeze,
-          shared_no: %w[env-shebang force format-executable http-proxy lock minimal-deps post-install-message
-                        prerelease suggestions user-install wrappers].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
+          }.freeze
         }.freeze
         private_constant :GEMFILE, :DIR_RUBY, :OPT_RUBY, :OPT_BUNDLE, :OPT_GEM
 
@@ -72,7 +80,8 @@ 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 pristine outdated push build exec].freeze,
+          'gem' => %i[install uninstall update pristine outdated push build exec].freeze,
+          'ruby' => %i[file script version].freeze,
           'exec' => nil,
           'cache' => nil,
           'config' => nil,
@@ -119,7 +128,7 @@ module Squared
           return unless outdated? && ref?(Ruby.ref)
 
           namespace name do
-            @@tasks[Ruby.ref].each do |action, flags|
+            Ruby.subtasks do |action, flags|
               next if @pass.include?(action)
 
               if flags.nil?
@@ -149,7 +158,7 @@ module Squared
                   end
                 when 'irb'
                   next unless (spec = basepath("#{project}.gemspec") || basepath("#{name}.gemspec"))
-                  next unless basepath('lib').join("#{gemname = File.basename(spec, File.extname(spec))}.rb").exist?
+                  next unless basepath('lib').join("#{gemname = stripext(spec)}.rb").exist?
 
                   format_desc action, nil, 'opts*,args*'
                   task action do |_, args|
@@ -177,16 +186,54 @@ module Squared
                       end
                     when 'gem'
                       case flag
-                      when :outdated, :build, :push, :exec
+                      when :outdated
+                        format_desc action, flag, 'major|minor|patch|(i)nteractive?,opts*'
+                        task flag, [:semver] do |_, args|
+                          case (filter = args.semver)
+                          when 'major', 'minor', 'patch', 'interactive', 'i'
+                            filter = 'interactive' if filter == 'i'
+                            args = args.to_a.drop(1)
+                          else
+                            filter = nil
+                            args = args.to_a
+                          end
+                          gem!(flag, args, filter: filter)
+                        end
+                      when :build, :push, :exec
                         format_desc(action, flag, 'opts*', before: flag == :exec ? 'command+' : nil)
                         task flag do |_, args|
-                          gemx flag, args.to_a
+                          gem! flag, args.to_a
                         end
                       else
                         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
+                          gem! flag, opts
+                        end
+                      end
+                    when 'ruby'
+                      case flag
+                      when :file
+                        format_desc action, flag, 'path,opts*,args*'
+                        task flag, [:rb] do |_, args|
+                          file = param_guard(action, flag, args: args, key: :rb)
+                          ruby(flag, args.to_a.drop(1), file: file)
+                        end
+                      when :script
+                        format_desc action, flag, 'command|RUBY_E,opts*,args*'
+                        task flag, [:e] do |_, args|
+                          if (command = ENV['RUBY_E'])
+                            opts = args.to_a
+                          else
+                            command = param_guard(action, flag, args: args, key: :e)
+                            opts = args.to_a.drop(1)
+                          end
+                          ruby(flag, opts, command: command)
+                        end
+                      when :version
+                        format_desc action, flag
+                        task flag do
+                          ruby flag
                         end
                       end
                     end
@@ -274,7 +321,7 @@ module Squared
                   end
                   minor_set = -> { styles[0] = cur[2] == lat[2] ? :yellow : :green }
                   if data.empty?
-                    semmajor?(cur, lat) ? major_set.() : minor_set.()
+                    semmajor?(cur, lat) ? major_set.call : minor_set.call
                   else
                     data.each do |val|
                       break unless line =~ /(>=?|=|~>|!=|<=?) (#{Regexp.escape(val.join)})/
@@ -282,11 +329,11 @@ module Squared
                       v = semver(val).join
                       case $1
                       when '>', '>='
-                        semmajor?(cur, lat) ? major_set.() : minor_set.()
+                        semmajor?(cur, lat) ? major_set.call : minor_set.call
                       when '<', '<='
                         if c <= v
                           if semmajor?(cur, lat)
-                            major_set.()
+                            major_set.call
                           else
                             styles[0] = :yellow
                           end
@@ -324,11 +371,11 @@ module Squared
                                                               index: 2)
                   end
                 end
-                out.("#{start.to_s.rjust(2)}. #{line}")
+                out.call("#{start.to_s.rjust(2)}. #{line}")
               elsif line.start_with?('Gem')
                 unless stdin?
                   sub = { pat: /^(.+)(?<!\dm)(Gem|Latest)(.+)$/, styles: theme[:header], index: 2 }
-                  out.(print_footer(" #  #{line.chomp}", reverse: true, sub: [sub, sub]))
+                  out.call(print_footer(" #  #{line.chomp}", reverse: true, sub: [sub, sub]))
                 end
               else
                 next
@@ -371,50 +418,143 @@ module Squared
           run_rb(from: :update)
         end
 
-        def gemx(flag, opts = [])
+        def ruby(flag, opts = [], file: nil, command: nil)
+          case flag
+          when :file, :script
+            op = OptionPartition.new(opts, OPT_RUBY[:ruby], ruby_session, project: self, args: true)
+            if file
+              op.extras.unshift(shell_quote(basepath(file)))
+            elsif command
+              op << quote_option('e', command, option: false)
+            end
+            if (args = ENV['RUBY_ARGS'])
+              op.extras << args
+            end
+            op.append(delim: true, escape: false, quote: false) unless op.empty?
+          when :version
+            pwd_set do
+              out = []
+              [
+                '$HOME/.rvm/bin/rvm',
+                '/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))
+
+                trim = ->(s) { s[/^\D+\d+\.\d+(?:\.\S+)?/, 0].sub(/^([a-z]+)-/i, '\1 ') }
+                ver = '.ruby-version'
+                out << trim.call(case (cmd = File.basename(val))
+                                 when 'rvm'
+                                   `rvm current`[/^\S+/, 0]
+                                 when 'rbenv'
+                                   name = `rbenv version-name`
+                                   name =~ SEM_VER ? "ruby #{name}" : name
+                                 when 'chruby.sh'
+                                   chruby = session_output 'source', val
+                                   `#{chruby.with('ruby --version')}`
+                                 when 'install'
+                                   ver = '.tool-versions'
+                                   `asdf current ruby`[/ruby\s+\S+/, 0].sub(/\s+/, ' ')
+                                 else
+                                   ver = nil
+                                   `ruby --version`
+                                 end)
+                unless val.empty?
+                  out << trim.call(case cmd
+                                   when 'chruby.sh'
+                                     `#{chruby.with('chruby --version')}`.sub(':', '')
+                                   when 'install'
+                                     "asdf #{`asdf version`.sub(/^v/, '')}"
+                                   else
+                                     `#{cmd} --version`
+                                   end)
+                end
+                begin
+                  out << ('which %s' % case cmd
+                                       when 'rbenv'
+                                         `rbenv which ruby`
+                                       when 'chruby.sh'
+                                         `#{chruby.with('which ruby')}`
+                                       when 'install'
+                                         `asdf which ruby`
+                                       else
+                                         `which ruby`
+                                       end)
+                rescue StandardError => e
+                  log.debug e
+                end
+                if ver
+                  path.ascend do |ent|
+                    next unless (ent = ent.join(ver)).exist?
+
+                    hint = File.read(ent).lines(chomp: true).reject(&:empty?).join(', ') rescue nil
+                    out << message("found #{ent}", hint: hint)
+                  end
+                end
+                break
+              end
+              out.map!(&:split)
+              pad = out.map(&:first).map!(&:size).max
+              puts(out.map! { |line| "#{line.first.rjust(pad)} #{line[1..-1].join(' ')}" })
+            end
+            return
+          end
+          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 << 'outdated'
           when :push
             cmd << 'push' << project
-          when :'user-install'
-            cmd << 'install' << '--user-install'
           else
             cmd << flag
           end
-          list = OPT_GEM[flag == :'user-install' ? :install : flag] + OPT_GEM[:common]
+          list = OPT_GEM[flag] + OPT_GEM[:common]
+          from = :"gem:#{flag}"
           case flag
-          when :install, :'user-install', :update
-            list += OPT_GEM[:shared]
-            no = OPT_GEM[:shared_no]
+          when :install, :update
+            list.concat(OPT_GEM[:install_base])
+            no = OPT_GEM[:no][:install]
+            first = true
+          when :uninstall
+            no = OPT_GEM[:no][:uninstall]
             first = true
           when :pristine
             first = true
           end
           cmd.merge(preopts)
-          opts, pat = option_sanitize(opts, list, no: no, first: first)
-          out = []
-          err = []
-          opts.each do |opt|
-            if opt =~ pat
+          op = OptionPartition.new(opts, list, cmd, project: self, no: no, first: first)
+          op.each do |opt|
+            if opt =~ op.values
               case $1
               when 'g', 'gem'
-                cmd << (flag == :exec ? shell_option($1, $2) : quote_option($1, basepath($2)))
+                op << (flag == :exec ? shell_option($1, $2) : quote_option($1, basepath($2)))
               end
-            elsif opt.match?(/^\w+=/) && !%i[outdated build push exec].include?(flag)
-              err << opt
+            elsif opt.include?('=') && !%i[outdated build push exec].include?(flag)
+              op.errors << opt
             else
-              out << opt
+              op.found << opt
             end
           end
-          from = :"gem:#{flag == :'user-install' ? 'install' : flag}"
+          op.swap
           case flag
           when :outdated
             log.info cmd.to_s
-            option_clear out
+            op.clear
             on :first, from
             print_item format_banner(cmd.to_s)
+            major = 0
+            minor = 0
+            patch = 0
+            update = []
             pwd_set(pass: !pwd.nil?, from: from) do
               items = [[%w[Gem Current Latest], nil]]
               IO.popen(cmd.done).each do |line|
@@ -422,9 +562,9 @@ module Squared
                   cur = semscan($2)
                   lat = semscan($3)
                   items << [$~.to_a.drop(1), if semmajor?(cur, lat)
-                                               %i[green bold]
+                                               1
                                              else
-                                               cur[2] == lat[2] ? [:yellow] : [:green]
+                                               cur[2] == lat[2] ? 3 : 2
                                              end]
                 else
                   puts line
@@ -443,9 +583,7 @@ module Squared
                   e = b.size if b.size > e
                   f = c.size if c.size > f
                 end
-                major = 0
-                minor = 0
-                patch = 0
+                j = 0
                 items.each_with_index do |item, i|
                   next if i == 0 && stdin?
 
@@ -459,69 +597,116 @@ module Squared
                     puts line
                     puts sub_style(ARG[:BORDER][1] * n, styles: borderstyle)
                   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)
+                    g = a.ljust(d)
+                    pat = [/\A([^.]+\.)([^.]+\..+)\z/, /\A([^.]+\.[^.]+\.)(.+)\z/]
+                    pre = b.start_with?('0.')
+                    latest = [theme[:current]]
+                    case item.last
+                    when 1
+                      case filter
+                      when 'major'
+                        update << a
+                      when 'minor', 'patch'
+                        next
+                      end
+                      g = sub_style(g, styles: theme[:major])
+                      major += 1
+                      styles = %i[green bold]
+                      pat = pre ? pat.first : nil
+                      latest << :bold
+                    when 2
+                      case filter
+                      when 'major', 'minor'
+                        update << a
+                      when 'patch'
+                        next
+                      end
+                      g = sub_style(g, styles: theme[:active])
+                      minor += 1
+                      styles = %i[green]
+                      pat = pre ? pat.last : pat.first
                     else
+                      case filter
+                      when 'major', 'minor', 'patch'
+                        update << a
+                      end
                       patch += 1
+                      styles = %i[yellow]
+                      pat = pat.last
                     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}"
+                    b = sub_style(b, *colormap(styles), pat: pat, index: 2)
+                    h = sub_style(c.rjust(f), styles: latest.flatten.compact, pat: pat, index: 2)
+                    j += 1
+                    puts "#{"#{j}.".rjust(pad)} #{g}    #{b}  #{h}"
+                    update << a if filter == 'interactive' && confirm_outdated(a, c, item.last)
                   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
+            unless update.empty?
+              cmd = gem_output 'update', '-f'
+              if (val = option('document', prefix: 'gem', ignore: false))
+                cmd << case val
+                       when '0', 'false'
+                         '--no-document'
+                       else
+                         basic_option('document', val)
+                       end
+              end
+              if (val = option('user-install', prefix: 'gem', ignore: false))
+                cmd << case val
+                       when '0', 'false'
+                         '--no-user-install'
+                       else
+                         '--user-install'
+                       end
+              end
+              cmd.merge(update)
+              run(cmd, banner: false, from: :'gem:update')
+            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
             on :last, from
             return
           when :build, :push
-            if !out.empty?
-              if flag == :build && out.size == 1
-                cmd << shell_quote(basepath(out.first))
+            if !op.empty?
+              if flag == :build && op.size == 1
+                op << shell_quote(basepath(op.first))
               else
-                raise_error("unknown args: #{out.join(', ')}", hint: flag)
+                raise_error("unknown args: #{op.join(', ')}", hint: flag)
               end
             elsif flag == :build
-              cmd << "#{project}.gemspec"
+              spec = [basepath("#{project}.gemspec"), basepath("#{name}.gemspec"), *Dir.glob(basepath('*.gemspec'))]
+              op << File.basename(spec) if (spec = spec.find { |file| File.exist?(file) })
             end
           when :exec
-            raise_error('no command given', hint: flag) if out.empty?
-            cmd << project << out.join(' ')
+            raise_error('missing command', hint: flag) if op.empty?
+            op << project << op.join(' ')
           else
-            raise_error('no gemname given', hint: flag) if out.empty? && !session_arg?('system')
+            raise_error('missing gemname', hint: flag) if op.empty? && !op.arg?('system')
             if flag == :pristine
-              if session_arg?('all')
-                append_repeat 'skip', out
-                out.clear
-              elsif (n = out.first.index('@'))
-                name = out.first
+              if op.arg?('all')
+                append_repeat 'skip', op.extras
+                op.clear
+              elsif (n = op.first.index('@'))
+                name = op.shift
                 if n == 0
-                  cmd << project
+                  op << project
                   ver = name[1..-1]
                 else
-                  cmd << shell_escape(name[0, n])
+                  op << shell_escape(name[0, n])
                   ver = name[n + 1..-1]
                 end
-                cmd << shell_option('version', ver)
-                out.clear
+                op << shell_option('version', ver)
+                op.clear
               end
             end
-            append_value(out, escape: true)
-            option_clear err
+            op.append.clear(errors: true)
           end
           run_rb(from: from)
         end
@@ -530,7 +715,8 @@ module Squared
           cmd = bundle_session flag
           args = case flag
                  when 'exec', 'cache', 'check'
-                   option_sanitize(args, OPT_BUNDLE[flag.to_sym] + OPT_BUNDLE[:common], args: flag == :exec).first
+                   list = OPT_BUNDLE[flag.to_sym] + OPT_BUNDLE[:common]
+                   OptionPartition.new(args, list, cmd, project: self, args: flag == :exec).extras
                  else
                    args.flatten
                  end
@@ -545,24 +731,23 @@ module Squared
         end
 
         def rake(*args, opts: [])
-          target = [quote_option('f', rakefile)]
-          args += option_sanitize(opts, OPT_RUBY[:rake], target: target).first
+          op = OptionPartition.new(opts, OPT_RUBY[:rake], [quote_option('f', rakefile)], project: self)
+          args.concat(op.extras)
           if args.empty?
             args << nil
           else
             args.flatten!
           end
-          cmd = rake_output(*target)
+          cmd = rake_output(*op.to_a)
           args.map! { |val| cmd.temp(val) }
           run_s(args, banner: false, from: :rake)
         end
 
         def irb(name, opts = [], path: basepath('lib'))
-          cmd = session 'irb'
-          args = option_sanitize(opts, OPT_RUBY[:irb], first: true).first
-          as_a(name).each { |val| cmd << shell_option('r', val) }
-          as_a(path).each { |val| cmd << quote_option('I', val) }
-          cmd.merge(args)
+          op = OptionPartition.new(opts, OPT_RUBY[:irb], session('irb'), project: self, first: true)
+          as_a(name).each { |val| op << shell_option('r', val) }
+          as_a(path).each { |val| op << quote_option('I', val) }
+          op.merge(op.extras)
           run(banner: false)
         end
 
@@ -595,7 +780,7 @@ module Squared
                 ver.each do |val|
                   next unless out =~ /\(#{Regexp.escape(val)}(?:,[^)]+|\b)\):([^\n]+)/
 
-                  set.(val, $1)
+                  set.call(val, $1)
                   break
                 end
               end
@@ -607,14 +792,14 @@ module Squared
 
               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)
+                set.call(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)
+              parse.call(target.resolve_feature_path(project)&.last)
             end
-            pwd_set { parse.(`#{bundle_output('show', project)}`) } unless @gemdir
+            pwd_set { parse.call(`#{bundle_output('show', project)}`) } unless @gemdir
           end
           raise_error('parse failed', hint: @version || 'path') unless @gemdir
         rescue StandardError => e
@@ -637,18 +822,28 @@ module Squared
         end
 
         def append_bundle(opts, list, target: @session, append: nil)
-          out = option_sanitize(opts, list, target: target).first
+          op = OptionPartition.new(opts, list, target, project: self)
           if append
             if append.is_a?(Regexp)
-              out, err = out.partition { |val| !val.match?(append) }
-              option_clear(err, target: target)
+              op.each do |opt|
+                if opt.match?(append)
+                  op.errors << opt
+                else
+                  op.found << opt
+                end
+              end
+              op.swap.clear(errors: true)
             end
-            append_value(out, target: target, escape: true)
+            op.append(escape: true)
           else
-            option_clear(out, target: target)
+            op.clear
           end
         end
 
+        def ruby_session(*cmd, **kwargs)
+          session('ruby', *preopts, *cmd, **kwargs)
+        end
+
         def gem_session(*cmd, **kwargs)
           ret = session('gem', *cmd, **kwargs)
           return ret if cmd.empty?
@@ -672,6 +867,10 @@ module Squared
           session_output('gem', *cmd, **kwargs)
         end
 
+        def ruby_output(*cmd, **kwargs)
+          session_output('ruby', *cmd, **kwargs)
+        end
+
         def bundle_output(*cmd, **kwargs)
           session_output('bundle', *cmd, **kwargs)
         end
@@ -696,7 +895,7 @@ module Squared
         end
 
         def preopts
-          verbosity > 0 && !session_arg?('quiet') ? ['--verbose'] : []
+          verbosetype > 1 && !session_arg?('quiet') ? ['--verbose'] : []
         end
 
         def gemdir?