squared 0.4.3 → 0.4.5

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

@@ -4,13 +4,15 @@ module Squared
   module Workspace
     module Project
       class Python < Git
-        REQUIREMENTS = %w[requirements.txt pyproject.toml setup.cfg poetry.lock].freeze
+        REQUIREMENTS = %w[requirements.txt poetry.lock pyproject.toml setup.cfg].freeze
         SETUPTOOLS = %w[setup.py pyproject.toml].freeze
         DIR_PYTHON = (REQUIREMENTS + SETUPTOOLS).freeze
         OPT_PYTHON = {
           common: %w[b B d E h i I O OO P q s S u v x c=q m=b W=b X=q check-hash-based-pycs=b].freeze,
           build: %w[n|no-isolation s|sdist v|verbose w|wheel x|skip-dependency-check C|config-setting=q installer=b
-                    o|outdir=p].freeze
+                    o|outdir=p].freeze,
+          venv: %w[clear copies symlinks system-site-packages upgrade upgrade-deps without-scm-ignore-files
+                   without-pip prompt=q].freeze
         }.freeze
         OPT_PIP = {
           common: %w[debug disable-pip-version-check isolated no-cache-dir no-color no-input no-python-version-warning
@@ -22,7 +24,9 @@ module Squared
                       config-settings=q c|constraint=p e|editable=b? extra-index-url=q f|find-links=q global-option=q
                       implementation=b i|index-url=q no-binary=q only-binary=q platform=q prefix=p progress-bar=b
                       python-version=q report=p r|requirement=p root=p root-user-action=b src=p t|target=p
-                      upgrade-strategy=b].freeze
+                      upgrade-strategy=b].freeze,
+          uninstall: %w[break-system-packages y|yes r|requirement=p root-user-action=b].freeze,
+          freeze: %w[all exclude-editable l|local user exclude=b path=p r|requirement=p].freeze
         }.freeze
         OPT_POETRY = {
           common: %w[ansi no-ansi no-cache n|no-interaction no-plugins P|project=p q|quiet v|verbose].freeze,
@@ -67,7 +71,9 @@ module Squared
           end
         end
 
-        def initialize(*, **kwargs)
+        attr_reader :venv
+
+        def initialize(*, venv: nil, **kwargs)
           super
           if @pass.include?(Python.ref)
             initialize_ref Python.ref
@@ -78,13 +84,16 @@ module Squared
           end
           @dependindex = REQUIREMENTS.index { |file| basepath(file).exist? }
           @dependfile = basepath(REQUIREMENTS[@dependindex || 0])
+          venv_set venv if venv
         end
 
-        @@tasks[ref] = {
+        subtasks({
+          'venv' => %i[create remove show].freeze,
+          'pip' => %i[uninstall freeze].freeze,
           'install' => %i[user force upgrade target editable].freeze,
           'build' => %i[python poetry hatch].freeze,
           'publish' => %i[poetry twine hatch].freeze
-        }.freeze
+        })
 
         def ref
           Python.ref
@@ -101,6 +110,51 @@ module Squared
               namespace action do
                 flags.each do |flag|
                   case action
+                  when 'venv'
+                    if flag == :create
+                      format_desc action, flag, 'dir,opts*'
+                      task flag, [:dir] do |_, args|
+                        dir = param_guard(action, flag, args: args, key: :dir)
+                        opts = python_session('-m venv', opts: args.extras).last
+                        opts = option_sanitize(opts, OPT_PYTHON[:venv]).first
+                        append_value(dir = basepath(dir), delim: true)
+                        option_clear(opts, pass: false)
+                        run(exception: true)
+                        puts(dir.directory? ? "Success: #{dir}" : 'Failed')
+                      end
+                    elsif venv
+                      case flag
+                      when :remove
+                        next unless projectpath?(venv)
+
+                        format_desc action, flag, 'c|reate?,d|epend?'
+                        task flag do |_, args|
+                          venv.rmtree(verbose: true)
+                          venv_init if has_value?(%w[c create], args.to_a)
+                          depend if has_value?(%w[d depend], args.to_a)
+                        end
+                      when :show
+                        format_desc action, flag
+                        task flag do
+                          puts venv
+                        end
+                      end
+                    end
+                  when 'pip'
+                    case flag
+                    when :freeze
+                      format_desc action, flag, 'file?=requirements.txt,opts*'
+                      task flag do |_, args|
+                        if (file = pip(flag, args.to_a)) && verbose
+                          puts File.read(file)
+                        end
+                      end
+                    when :uninstall
+                      format_desc action, flag, 'package+,opts*'
+                      task flag do |_, args|
+                        pip flag, args.to_a
+                      end
+                    end
                   when 'install'
                     format_desc(action, flag, 'opts*', before: case flag
                                                                when :target
@@ -167,23 +221,30 @@ module Squared
           if @depend && !flag
             super
           elsif outdated?
+            venv_init
             workspace.rev_clear name
-            if !flag && dependtype == 4
-              cmd = session 'poetry', 'install'
+            if !flag && dependtype == 2
+              cmd = session 'poetry', 'install', '-n'
+              cmd << '--no-ansi' unless verbose
               cmd << '--no-root' if option('no-root')
             else
               cmd = pip_session 'install'
-              case flag
-              when :user
-                cmd << "--#{flag}"
-              when :target
-                cmd << quote_option('target', basepath(target))
-              when :force
-                cmd << '--force-reinstall'
+              if flag
+                case flag
+                when :user
+                  cmd << '--user'
+                when :target
+                  cmd << quote_option('target', basepath(target))
+                when :force
+                  cmd << '--force-reinstall'
+                end
+                append_pip(flag, opts, from: :install)
               else
+                if (val = option('editable', 'e'))
+                  cmd << quote_option('e', editable(val))
+                end
                 append_global
               end
-              append_pip(flag, opts, from: :install) if flag
               if dependtype == 1 && !session_arg?('e', 'editable')
                 cmd << '-r requirements.txt' unless session_arg?('r', 'requirement')
               elsif !session_arg?('e', 'editable', value: true)
@@ -208,7 +269,7 @@ module Squared
           pwd_set(from: :outdated) do
             buffer = []
             out = ->(val) { sync ? puts(val) : buffer << val }
-            IO.popen(cmd).each do |line|
+            IO.popen(runenv || {}, cmd).each do |line|
               next if line.match?(/^[\s-]+$/)
 
               if start > 0
@@ -272,7 +333,7 @@ module Squared
           out = append_pip(flag, opts, from: :install)
           case flag
           when :editable
-            cmd << '--editable' << (out.pop || '.')
+            cmd << quote_option('e', out.shift || '.')
             option_clear out
           when :upgrade
             cmd << '--upgrade'
@@ -283,24 +344,21 @@ module Squared
         end
 
         def buildx(flag, opts = [])
-          cmd = session flag
           out = []
           srcdir = nil
           case flag
           when :python
-            cmd << shell_option('m', 'build')
-            list = OPT_PYTHON[:build] + OPT_PYTHON[:common]
+            cmd, opts = python_session('-m build', opts: opts)
+            list = OPT_PYTHON[:build]
           when :poetry
-            cmd << 'build'
+            cmd = session 'poetry', 'build'
             list = OPT_POETRY[:build] + OPT_POETRY[:common]
           when :hatch
-            cmd << 'build'
-            list = OPT_HATCH[:build] + OPT_HATCH[:common]
+            cmd, opts = hatch_session('build', opts: opts)
+            list = OPT_HATCH[:build]
           end
-          option_sanitize(opts, list).first.each do |opt|
-            if opt =~ /^(v+|q+)$/ || (flag == :python && opt =~ /^(b+)$/)
-              cmd << "-#{$1}"
-            elsif !srcdir && basepath(opt).exist? && projectpath?(opt)
+          option_sanitize(opts, list, single: flag == :python ? /^(?:v+|q+|b+)$/ : /^(?:v+|q+)$/).first.each do |opt|
+            if !srcdir && basepath(opt).exist? && projectpath?(opt)
               srcdir = opt
             else
               out << opt
@@ -331,7 +389,6 @@ module Squared
 
         def publish(flag, opts = [])
           cmd = session flag
-          out = []
           case flag
           when :poetry
             cmd << 'publish'
@@ -340,16 +397,10 @@ module Squared
             cmd << 'upload'
             list = OPT_TWINE[:publish]
           when :hatch
-            cmd << 'publish'
-            list = OPT_HATCH[:publish] + OPT_HATCH[:common]
-          end
-          option_sanitize(opts, list).first.each do |opt|
-            if flag != :twine && opt =~ /^(v+|q+)$/
-              cmd << "-#{$1}"
-            else
-              out << opt
-            end
+            opts = hatch_session('publish', opts: opts).last
+            list = OPT_HATCH[:publish]
           end
+          out = option_sanitize(opts, list, single: flag == :twine ? nil : /^(?:v+|q+)$/).first
           if out.empty?
             dist = basepath.join('dist')
             raise_error('no source files given', hint: dist) unless dist.directory? && !dist.empty?
@@ -359,6 +410,23 @@ module Squared
           run(from: :"#{flag}:publish")
         end
 
+        def pip(flag, opts = [])
+          cmd = pip_session flag
+          out = append_pip(nil, opts, from: flag)
+          case flag
+          when :uninstall
+            raise_error('no packages given', subject: name, hint: 'uninstall') if out.empty?
+            cmd.merge(out)
+          when :freeze
+            venv_init
+            ret = basepath(out.shift || 'requirements.txt')
+            cmd << '>' << shell_quote(ret)
+            option_clear out
+          end
+          run(from: :"pip:#{flag}")
+          ret
+        end
+
         def variable_set(key, *val, **)
           case key
           when :dependfile
@@ -369,6 +437,8 @@ module Squared
             else
               log.warn "variable_set: @#{key}=#{req} (not supported)"
             end
+          when :venv
+            @venv = val.empty? ? nil : basepath(*val)
           else
             super
           end
@@ -385,63 +455,128 @@ module Squared
         private
 
         def pip_session(*cmd)
-          session('pip', *cmd)
+          session('pip', *cmd, path: venv.nil?)
         end
 
-        def python_session(*cmd)
-          session('python', *cmd)
+        def python_session(*cmd, opts: nil)
+          return session('python', *cmd, path: venv.nil?) unless opts
+
+          out = []
+          opts = option_sanitize(opts, OPT_PYTHON[:common], target: out, single: /^v+$/).first
+          ret = session('python', *out, *cmd, path: venv.nil?)
+          [ret, opts]
         end
 
-        def append_pip(flag, opts, target: @session, from: nil)
-          append_nocolor(target: target)
-          return [] unless from && !opts.empty?
+        def hatch_session(*cmd, opts: nil)
+          return session('hatch', *cmd, path: venv.nil?) unless opts
 
-          opts, pat = option_sanitize(opts, OPT_PIP[from] + OPT_PIP[:common], target: target)
           out = []
-          edit = nil
-          opts.each do |opt|
-            if opt =~ /^(v+|q+)$/
-              cmd << "-#{$1}"
-            elsif opt =~ pat
-              case $1
-              when 'e', 'editable'
-                edit = $2
+          opts = option_sanitize(opts, OPT_HATCH[:common], target: out, single: /^(?:v+|q+)$/).first
+          ret = session('hatch', *out, *cmd, path: venv.nil?)
+          [ret, opts]
+        end
+
+        def append_pip(flag, opts, from: nil)
+          if !from || opts.empty?
+            append_global
+            return []
+          end
+          opts, pat = option_sanitize(opts, OPT_PIP[from] + OPT_PIP[:common], single: /^(?:v+|q+)$/)
+          append_global
+          if from == :install
+            out = []
+            edit = nil
+            opts.each do |opt|
+              if opt =~ pat
+                case $1
+                when 'e', 'editable'
+                  edit = $2
+                end
+              elsif flag == :editable && !edit
+                edit = opt
+              else
+                out << opt
               end
-            elsif flag == :editable && !edit
-              edit = opt
-            else
-              out << opt
             end
-          end
-          if edit
-            edit = basepath(edit) unless %r{^[a-z]+(?:\+[a-z]+)?://}i.match?(edit)
-            if flag == :editable
-              out << edit
+            if edit
+              edit = editable(edit)
+              if flag == :editable
+                out << edit
+              else
+                target << quote_option('e', edit)
+              end
+            end
+            case flag
+            when :editable, :upgrade
+              out
             else
-              target << quote_option('editable', edit)
+              option_clear out
+              []
             end
-          end
-          case flag
-          when :editable, :upgrade
-            out
           else
-            option_clear(out, target: target)
-            []
+            opts
           end
         end
 
-        def append_global
+        def append_global(target: @session)
           if (val = option('cache-dir'))
-            cmd << case val
-                   when '0', 'false'
-                     '--no-cache-dir'
-                   else
-                     quote_option('cache-dir', basepath(val))
-                   end
+            target << case val
+                      when '0', 'false'
+                        '--no-cache-dir'
+                      else
+                        quote_option('cache-dir', basepath(val))
+                      end
+          end
+          target << shell_option('proxy', val) if (val = option('proxy'))
+          target << quote_option('python', basepath(val)) if (val = option('python'))
+          append_nocolor(target: target)
+        end
+
+        def editable(val)
+          %r{^[a-z]+(?:\+[a-z]+)?://}i.match?(val) ? val : basepath(val)
+        end
+
+        def variables
+          (super + %i[venv]).freeze
+        end
+
+        def runenv
+          return unless venv
+
+          if workspace.windows?
+            shell_quote(venvbin.join(workspace.powershell? ? 'Activate.ps1' : 'activate.bat'), option: false)
+          else
+            { 'VIRTUAL_ENV' => venv.to_s, 'PATH' => "#{venvbin}:#{ENV['PATH']}" }
           end
-          cmd << shell_option('proxy', val) if (val = option('proxy'))
-          cmd << quote_option('python', basepath(val)) if (val = option('python'))
-          append_nocolor
+        end
+
+        def venvbin
+          @venv.join(workspace.windows? ? 'Scripts' : 'bin')
+        end
+
+        def venv_set(val)
+          @venv = Pathname.new(val)
+          @venv = basepath(@venv) unless @venv.absolute?
+          if projectpath?(@venv)
+            if @venv.exist?
+              log.debug "venv found: #{@venv}"
+            elsif @path.directory? && !@path.empty?
+              @venv.mkpath
+              log.info "venv mkdir: #{@venv}"
+            end
+          elsif !@venv.directory?
+            log.warn "venv invalid: #{@venv}"
+            @venv = nil
+          end
+        end
+
+        def venv_init
+          return if !venv || (venvbin.directory? && !venvbin.empty?)
+
+          puts log_message(Logger::INFO, venv, subject: 'venv', hint: 'init')
+          cmd = python_session '-m venv', shell_option('prompt', name), '--upgrade-deps', shell_quote(venv)
+          run(cmd, false, exception: true, banner: false)
+          puts log_message(Logger::INFO, venv, subject: 'venv', hint: 'created')
         end
       end