squared 0.1.3 → 0.2.0

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

@@ -5,21 +5,29 @@ module Squared
     module Project
       class Python < Git
         REQUIREMENTS = %w[requirements.txt pyproject.toml setup.py].freeze
-        OPT_USER = %w[pre dry-run].freeze
-        OPT_FORCE = (OPT_USER + ['user']).freeze
-        OPT_GENERAL = %w{venv isolated no-cache-dir [v]erbose}.freeze
-        private_constant :REQUIREMENTS, :OPT_USER, :OPT_FORCE, :OPT_GENERAL
+        OPT_INSTALL = %w[I U break-system-packages check-build-dependencies compile dry-run force-reinstall
+                         ignore-installed ignore-requires-python no-build-isolation no-clean no-compile no-deps
+                         no-index no-warn-conflicts no-warn-script-location pre prefer-binary require-hashes upgrade
+                         use-pep517 user abi=s config-settings=s c=s constraint=s e=s editable=s extra-index-url=s
+                         f=s find-links=s global-option=s implementation=s i=s index-url=s no-binary=s only-binary=s
+                         platform=s prefix=s progress-bar=s python-version=s report=s r=s requirement=s
+                         root-user-action=s root=s src=s t=s target=s upgrade-strategy=s].freeze
+        OPT_GENERAL = %w[debug disable-pip-version-check isolated q quiet require-virtualenv v verbose
+                         no-cache-dir no-color no-input no-python-version-warning
+                         cache-dir=s cert=s client-cert=s exists-action=s log=s proxy=s python=s retries=i timeout=i
+                         trusted-host=s use-deprecated=s use-feature=s].freeze
+        private_constant :REQUIREMENTS, :OPT_INSTALL, :OPT_GENERAL
 
         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 venv?
@@ -47,40 +55,38 @@ module Squared
         end
 
         @@tasks[ref] = {
-          install: %i[user target upgrade force].freeze
+          'install' => %i[user upgrade force target].freeze
         }.freeze
 
         def ref
           Python.ref
         end
 
-        def populate(*)
+        def populate(*, **)
           super
           return unless outdated? && ref?(Python.ref)
 
           namespace name do
             @@tasks[Python.ref].each do |action, flags|
+              next if @pass.include?(action)
+
               namespace action do
                 flags.each do |flag|
                   case action
-                  when :install
-                    list = case flag
-                           when :target
-                             req = 'dir'
-                             OPT_USER + %w[upgrade eager]
-                           when :upgrade
-                             OPT_FORCE + ['eager']
-                           when :force
-                             OPT_FORCE
-                           else
-                             OPT_USER
-                           end
-                    list += OPT_GENERAL
-                    desc format_desc(action, flag, list, req: req)
-                    if flag == :target
-                      task flag, [:dir, :opts] do |_, args|
-                        dir = guard_params(action, flag, args: args, key: :dir)
-                        depend(flag, dir: dir, opts: args.to_a.drop(1))
+                  when 'install'
+                    if @@task_desc
+                      format_desc(action, flag, OPT_INSTALL + OPT_GENERAL, before: case flag
+                                                                                   when :target
+                                                                                     'dir'
+                                                                                   when :upgrade
+                                                                                     'strategy'
+                                                                                   end)
+                    end
+                    case flag
+                    when :target, :upgrade
+                      task flag, [:param] do |_, args|
+                        param = param_guard(action, flag, args: args, key: :param)
+                        depend(flag, param: param, opts: args.extras)
                       end
                     else
                       task flag do |_, args|
@@ -94,7 +100,7 @@ module Squared
           end
         end
 
-        def depend(flag = nil, dir: nil, opts: [], sync: invoked_sync?('depend', flag))
+        def depend(flag = nil, sync: invoked_sync?('depend', flag), param: nil, opts: [])
           if @depend && !flag
             super
           elsif outdated?
@@ -104,33 +110,117 @@ module Squared
               case flag
               when :user
                 cmd << '--user'
-                append_pip opts, OPT_USER
-              when :target
-                cmd << shell_option('target', basepath(dir), quote: true)
-                append_pip opts, OPT_USER + ['upgrade']
-                append_eager opts
               when :upgrade
                 cmd << '--upgrade'
-                append_pip opts, OPT_FORCE
-                append_eager opts
+                case param
+                when 'eager', 'only-if-needed'
+                  cmd << basic_option('upgrade-strategy', param)
+                else
+                  opts << param
+                end
               when :force
                 cmd << '--force-reinstall'
-                append_pip opts, OPT_FORCE
+              when :target
+                cmd << shell_option('target', basepath(param), quote: true)
               else
-                append_pip
+                append_global
+              end
+              append_pip opts if flag
+              if type == 2
+                cmd << '.'
+              elsif !cmd.find { |val| val =~ /^(?:-r|--requirement)/ }
+                cmd << '-r requirements.txt'
               end
-              cmd << (type == 1 ? '-r requirements.txt' : '.')
-              run(sync: sync)
             when 3
-              run_s('python setup.py install', sync: sync)
+              cmd = python_session 'setup.py', 'install'
+              case flag
+              when :user
+                cmd << '--user'
+              when :target
+                cmd << quote_option('build-base', basepath(dir))
+              end
+              if option('user')
+                cmd << '--user'
+              else
+                append_first(%w[home prefix], equals: true, escape: false, quote: true, ignore: false)
+              end
+              cmd.delete('--user') if workspace.windows?
             end
+            run(from: :depend, sync: sync)
           end
         end
 
         def outdated(*, sync: invoked_sync?('outdated'))
-          pip_session 'list', '--outdated'
-          append_pip
-          run(sync: sync)
+          cmd = pip_session 'list', '--outdated'
+          append_global
+          cmd = session_done(cmd)
+          log.info cmd
+          on :first, :outdated
+          banner = format_banner(cmd)
+          print_item banner if sync
+          start = 0
+          found = 0
+          major = 0
+          pwd_set(from: :outdated) do
+            buffer = []
+            out = ->(val) { sync ? puts(val) : buffer << val }
+            IO.popen(cmd).each do |line|
+              next if line =~ /^[\s-]+$/
+
+              if start > 0
+                unless stdin?
+                  data = line.scan(SEM_VER)
+                  next unless (cur = data.shift) && (lat = data.shift)
+
+                  latest = lat.join
+                  current = cur.join
+                  semver(cur)
+                  semver(lat)
+                  if semmajor?(cur, lat)
+                    type = 2
+                    major += 1
+                  else
+                    type = cur[2] == lat[2] ? 0 : 1
+                  end
+                  if type == 0
+                    styles = color(:yellow)
+                  else
+                    styles = color(:green)
+                    line = sub_style(line, pat: /^(\S+)(.+)$/, styles: if type == 2
+                                                                         styles << :bold
+                                                                         theme[:major]
+                                                                       else
+                                                                         theme[:active]
+                                                                       end)
+                  end
+                  if theme[:current]
+                    line = sub_style(line, pat: /^(.+)(#{Regexp.escape(current)})(.+)$/, styles: theme[:current],
+                                           index: 2)
+                  end
+                  line = sub_style(line, pat: /^(.+)(#{Regexp.escape(latest)})(.+)$/, styles: styles, index: 2)
+                  found += 1
+                end
+                out.("#{start.to_s.rjust(2)}. #{line}")
+                start += 1
+              elsif line =~ /^Package /
+                unless stdin?
+                  sub = { pat: /^(.*)(?<!\dm)(Package|Latest)(.+)$/, styles: theme[:header], index: 2 }
+                  out.(print_footer(" #  #{line.chomp}", reverse: true, sub: [sub, sub]))
+                end
+                start += 1
+              end
+            end
+            unless sync
+              print_item banner
+              puts buffer
+            end
+            if found > 0
+              puts print_footer empty_status('Updates are available', 'major', major)
+            elsif start == 0
+              puts 'No updates were found'
+            end
+          end
+          on :last, :outdated
         end
 
         def variable_set(key, *val, **)
@@ -162,29 +252,54 @@ module Squared
           session('pip', *cmd)
         end
 
-        def append_pip(opts = [], list = [])
+        def python_session(*cmd)
+          session('python', *cmd)
+        end
+
+        def append_pip(opts, list = nil, target: @session)
+          append_nocolor(target: target)
+          return if opts.empty?
+
+          out = []
+          opts, pat = option_partition(opts, list || (OPT_INSTALL + OPT_GENERAL), target: target)
           opts.each do |opt|
-            data = nil
-            next unless list.include?(opt) || OPT_GENERAL.include?(opt) || (data = opt.match(/^verbose|(v+)$/))
-
-            @session << case opt
-                        when 'venv'
-                          '--require-virtualenv'
-                        else
-                          (data && data[1] ? "-#{data[1]}" : "--#{opt}")
-                        end
+            if opt =~ /^(v+|q+)$/
+              cmd << "-#{$1}"
+            elsif opt =~ pat
+              case $1
+              when 'root', 'prefix', 'src', 'cert', 'client-cert', 'cache-dir', 'log', 'report',
+                   'r', 'requirement', 'c', 'constraint', 't', 'target'
+                target << quote_option($1, basepath($2))
+              when 'e', 'editable'
+                val = $2
+                target << quote_option($1, val =~ %r{^[a-z]+\+[a-z]+://} ? val : basepath(val))
+              when 'proxy', 'config-settings', 'global-option', 'extra-index-url',
+                   'f', 'find-links', 'i', 'index-url'
+                target << shell_option($1, $2, quote: true)
+              when 'retries', 'timeout'
+                target << basic_option($1, $2) if $2.to_i > 0
+              else
+                target << shell_option($1, $2)
+              end
+            else
+              out << opt
+            end
           end
-          val = nil
-          @session << shell_option('proxy', val, quote: true) if (val = option('proxy'))
-          @session << shell_option('python', basepath(val), quote: true) if (val = option('python'))
-          @session << shell_option('log', basepath(val), quote: true) if (val = option('log', ignore: false))
-          @session << '--user' if !list.empty? && option('user')
-          @session << '--no-input' if option('no-input')
-          append_nocolor option('no-color')
+          option_clear(out, target: target)
         end
 
-        def append_eager(opts)
-          @session << '--upgrade-strategy=eager' if opts.include?('eager')
+        def append_global
+          if (val = option('cache-dir'))
+            cmd << case val
+                   when '0', 'false'
+                     '--no-cache-dir'
+                   else
+                     quote_option('cache-dir', basepath(val))
+                   end
+          end
+          cmd << shell_option('proxy', val, quote: true) if (val = option('proxy'))
+          cmd << quote_option('python', basepath(val)) if (val = option('python'))
+          append_nocolor
         end
       end