squared 0.0.1 → 0.0.3

data/lib/squared/repo/project/node.rb

@@ -4,60 +4,80 @@ module Squared
   module Repo
     module Project
       class Node < Git
+        REF = :node
+        private_constant :REF
+
         class << self
+          def populate(*); end
+
           def tasks
             nil
           end
 
-          def to_sym
-            :node
-          end
-
           def prod?
             ENV['NODE_ENV'] == 'production'
           end
 
-          def is_a?(path)
-            if path.is_a?(::String) || path.is_a?(::Pathname)
-              Pathname.new(path).join('package.json').exist?
+          def is_a?(val)
+            if (val = as_path(val))
+              val.join('package.json').exist?
             else
               super
             end
           end
         end
 
-        @@tasks[:node] = {
-          install: %i[force dedupe],
-          outdated: %i[major minor patch]
+        @@tasks[REF] = {
+          install: %i[force dedupe frozen],
+          outdated: %i[major minor patch],
+          run: nil
         }.freeze
 
-        def initialize(name, project, workspace, **kwargs)
+        def initialize(name, path, workspace, *, **kwargs)
           super
-          @clean ||= ['build/']
+          initialize_script(REF)
+          if (opts = env('BUILD', strict: true))
+            raise ArgumentError, message("BUILD_#{@name.upcase}", opts) if @output[0].is_a?(::Array)
+
+            @output[1] = opts
+          else
+            @output[1] = (@script && @script[:run]) || workspace.script
+          end
           @dev = workspace.bool_match(env('BUILD', suffix: 'DEV'), kwargs.delete(:dev))
           @prod = workspace.bool_match(env('BUILD', suffix: 'PROD'), kwargs.delete(:prod))
-          @package = {}
+          @pm = {}
         end
 
         def populate(*)
           super
           return unless outdated?
 
-          namespace @name do
-            @@tasks[:node].each do |action, flags|
-              namespace action do
-                flags.each do |flag|
-                  case action
-                  when :install
-                    desc format_desc(action, flag)
-                    task flag do
-                      install flag
-                    end
-                  when :outdated
-                    desc format_desc(action, flag, %w[prune dry-run], req: 'opts?')
-                    task flag, [:opts] do |_, args|
-                      opts = collect_args(args, :opts)
-                      outdated(flag, opts: opts)
+          namespace name do
+            @@tasks[REF].each do |action, flags|
+              if flags.nil?
+                case action
+                when :run
+                  desc format_desc(action, nil, 'command+')
+                  task action, [:command] do |_, args|
+                    command = collect_args(args, :command)
+                    guard_params(action, 'command', args: command)
+                    run_script command
+                  end
+                end
+              else
+                namespace action do
+                  flags.each do |flag|
+                    case action
+                    when :install
+                      desc format_desc(action, flag)
+                      task flag do
+                        install flag
+                      end
+                    when :outdated
+                      desc format_desc(action, flag, %w[prune dry-run], req: 'opts?')
+                      task flag, [:opts] do |_, args|
+                        outdated(flag, opts: collect_args(args, :opts))
+                      end
                     end
                   end
                 end
@@ -66,26 +86,24 @@ module Squared
           end
         end
 
-        def copy(from: 'build', glob: '**/*', basedir: 'node_modules', into: nil, also: [], override: false)
+        def copy(from: 'build', glob: '**/*', subdir: 'node_modules', into: nil, also: [], override: false)
           if @copy && !override
             return super if @copy.is_a?(::String)
 
             from = @copy[:from] if @copy.key?(:from)
             glob = @copy[:glob] if @copy.key?(:glob)
-            basedir = @copy[:basedir] if @copy.key?(:basedir)
+            subdir = @copy[:subdir] if @copy.key?(:subdir)
             into = @copy[:into] if @copy.key?(:into)
             also = @copy[:also] if @copy.key?(:also)
           end
-          return unless basedir
-
-          items = [@project == @workspace.main ? nil : @workspace.home].concat(as_a(also))
+          items = [project == workspace.main ? nil : workspace.home].concat(as_a(also))
           items.each_with_index do |dir, i|
             if i == 0
               next unless dev? & !doc?
 
               dest = dir
             elsif dir.is_a?(::String)
-              dest = @workspace.root_path(dir)
+              dest = workspace.root_path(dir)
             elsif dir.is_a?(::Symbol)
               dest = Repo.resolve(dir)&.path
             elsif dir.is_a?(Project)
@@ -99,8 +117,8 @@ module Squared
                   from = val
                 when :glob
                   glob = val
-                when :basedir
-                  basedir = val
+                when :subdir
+                  subdir = val
                 when :into
                   into = val
                 end
@@ -110,7 +128,7 @@ module Squared
             next unless dest&.directory?
 
             from = base_path(from)
-            dest = dest.join(basedir, into || @project)
+            dest = dest.join(subdir, into || project)
             warn "cp #{from.join(glob)} #{dest}"
             copy_d(from, dest, glob: glob, verbose: verbose?)
           end
@@ -120,15 +138,30 @@ module Squared
           if @depend
             super
           else
+            frozen = flag == :frozen
             force = flag == :force
             dedupe = flag == :dedupe
             if (yarn = install_type(:yarn)) > 0
-              cmd = session 'yarn', 'install'
+              cmd = session 'yarn'
               if yarn > 1
-                cmd << '--check-cache' if force
+                if dedupe
+                  cmd << 'dedupe'
+                else
+                  cmd << 'install'
+                  if force
+                    cmd << '--check-cache'
+                  elsif frozen
+                    cmd << '--immutable'
+                  end
+                end
               else
+                cmd << 'install'
+                if force
+                  cmd << '--force'
+                elsif frozen
+                  cmd << '--frozen-lockfile'
+                end
                 cmd << '--production' if prod?
-                cmd << '--force' if force
                 cmd << '--ignore-engines' unless env('YARN_IGNORE_ENGINES', equals: '0')
               end
             elsif pnpm?
@@ -137,19 +170,29 @@ module Squared
                 cmd << 'dedupe'
               else
                 cmd << 'install'
-                cmd << '--force' if force
+                if force
+                  cmd << '--force'
+                elsif frozen
+                  cmd << '--frozen-lockfile'
+                end
               end
               cmd << '--prod' if prod?
+              cmd << '--ignore-workspace' if env('NODE_WORKSPACES', equals: '0')
               append_nocolor
             else
-              cmd = session 'npm'
-              cmd << (dedupe ? 'dedupe' : 'install')
+              cmd = session 'npm', dedupe ? 'dedupe' : 'install'
+              if force
+                cmd << '--force'
+              elsif frozen
+                cmd << '--package-lock-only'
+              end
               cmd << '--omit=dev' if prod?
-              cmd << '--force' if force
+              cmd << '--workspaces=false' if env('NODE_WORKSPACES', equals: '0')
+              cmd << '--package-lock=false' if env('NPM_PACKAGE_LOCK', equals: '0')
               append_nocolor
             end
             append_loglevel
-            run(exception: @workspace.exception)
+            run(exception: workspace.exception)
           end
         end
 
@@ -159,23 +202,24 @@ module Squared
           cmd = pnpm? ? 'pnpm outdated' : 'npm outdated'
           print_item format_banner(message("#{cmd}#{opts.include?('dry-run') ? ' --dry-run' : ''}"), multitask: true)
           pwd = Dir.pwd
-          Dir.chdir(@path)
+          Dir.chdir(path)
           info cmd
           data = `#{cmd} --json --loglevel=error`
           Dir.chdir(pwd)
-          target = base_path('package.json')
-          doc = File.read(target)
-          json = JSON.parse(doc)
+          json = JSON.parse(doc = package.read)
+          pat = /^(\d+)(\.)(\d+)(\.)(\d+)$/
           dep1 = json['dependencies'] || {}
           dep2 = json['devDependencies'] || {}
           found = []
           avail = []
           if !data.empty?
-            validate = ->(ver) { /^\d+\.\d+\.\d+$/.match?(ver) }
+            validate = ->(ver) { ver.match?(pat) }
             JSON.parse(data).each_pair do |key, val|
-              file = dep1[key] || dep2[key]
+              val = val.find { |item| item['dependent'] == json['name'] } if val.is_a?(Array)
+              next unless val && (file = dep1[key] || dep2[key])
+
               ch = file[0]
-              if !/[~^]/.match?(ch)
+              unless ch.match?(/[~^]/)
                 avail << [key, file, val['latest'], true]
                 next
               end
@@ -202,7 +246,14 @@ module Squared
               if upgrade
                 next if file == want
 
-                found << [key, file, want]
+                index = if a != c
+                          1
+                        elsif b != d
+                          3
+                        else
+                          5
+                        end
+                found << [key, file, want, index]
               else
                 avail << [key, file, val['latest'], false]
               end
@@ -223,13 +274,13 @@ module Squared
                         else
                           ['No packages were updated', 'possible']
                         end
-            puts Project.footer(empty_status(msg, hint, pending + val))
+            puts print_footer(empty_status(msg, hint, pending + val))
           end
           if !found.empty?
-            col1 = size_col.(found, 0)
-            col2 = size_col.(found, 1)
+            col1 = size_col.(found, 0) + 4
+            col2 = size_col.(found, 1) + 4
             found.each_with_index do |item, i|
-              a, b, c = item
+              a, b, c, d = item
               cur = modified
               doc.sub!(/("#{Regexp.escape(a)}"\s*:\s*)"([~^])#{Regexp.escape(b)}"/) do |capture|
                 if $2 == '~' && rev != :patch
@@ -241,29 +292,37 @@ module Squared
                   "#{$1}\"#{$2 || ''}#{c}\""
                 end
               end
-              hint = if cur == -1
-                       'SKIP'
-                     else
-                       modified > cur ? c : 'FAIL'
-                     end
-              puts "#{pad_ord.(i, found)}. #{a.ljust(col1)}\t#{b.ljust(col2)}\t#{hint}"
+              a = a.ljust(col1)
+              c = if cur == -1
+                    'SKIP'
+                  elsif modified == cur
+                    'FAIL'
+                  elsif d == 1
+                    a = sub_style(a, :bold)
+                    sub_style(c, :green, :bold)
+                  else
+                    sub_style(c, :green, :bold, pat: pat, index: d)
+                  end
+              puts "#{pad_ord.(i, found)}. #{a}#{b.ljust(col2)}#{c}"
             end
             pending = avail.reduce(pending) { |a, b| a + (b[3] ? 0 : 1) }
             if opts.include?('dry-run') || (modified == 0 && pending > 0)
               footer.(modified)
             elsif modified > 0
-              File.write(target, doc)
+              File.write(package, doc)
               modified = -1
               footer.()
               commit(:add, 'package.json', pass: true)
               install if opts.include?('prune')
             end
           elsif !avail.empty?
-            col1 = size_col.(avail, 0)
-            col2 = size_col.(avail, 2)
+            col1 = size_col.(avail, 0) + 4
+            col2 = size_col.(avail, 1)
+            col3 = size_col.(avail, 2) + 4
             avail.each_with_index do |item, i|
               a, b, c, d = item
-              puts "#{pad_ord.(i, avail)}. #{a.ljust(col1)}\t#{c.ljust(col2)}\t#{d ? 'locked at' : 'from'} #{b}"
+              e = sub_style(b.ljust(col2), d ? :red : :yellow)
+              puts "#{pad_ord.(i, avail)}. #{a.ljust(col1)}#{c.ljust(col3)}#{e} (#{d ? 'locked' : 'latest'})"
               pending += 1 unless d
             end
             footer.()
@@ -272,7 +331,12 @@ module Squared
           end
         end
 
-        def compose(opts)
+        def run_script(cmd)
+          cmd.each { |val| run_s compose(val) }
+        end
+
+        def compose(args)
+          args ||= @output[1]
           cmd = [if yarn?
                    'yarn'
                  else
@@ -280,86 +344,93 @@ module Squared
                  end]
           cmd << 'run'
           append_loglevel cmd
-          if opts.is_a?(::Array)
-            cmd += opts
+          if args.is_a?(::Array)
+            cmd += args
+          elsif args.is_a?(::String)
+            cmd << args
           else
-            cmd << (opts || @workspace.script)
+            raise ArgumentError, message("#{cmd.first} script name", hint: args.nil? ? 'missing' : 'invalid')
           end
           cmd.join(' ')
         end
 
-        def install_type(prog)
+        def install_type(prog = nil)
+          prog ||= yarn? ? :yarn : :pnpm
           key = :"#{prog}?"
-          send(key) if respond_to?(key)
-          @package[prog.to_sym] || 0
+          __send__(key) if respond_to?(key)
+          @pm[prog] || 0
+        end
+
+        def build?
+          @output[0] != false && (!@output[0].nil? || !@output[1].nil?)
         end
 
         def depend?
-          !@depend.nil? || outdated?
+          !!@depend || outdated?
         end
 
         def copy?
-          !@copy.nil?
+          !!@copy
         end
 
         def outdated?
-          base_path('package.json').exist?
+          package.exist?
         end
 
         def yarn?
-          (@package[:yarn] ||= if File.exist?(base_path('yarn.lock'))
-                                 if File.exist?(rc = base_path('.yarnrc.yml'))
-                                   begin
-                                     require 'yaml'
-                                     doc = YAML.load_file(rc)
-                                     doc.nodeLinker == 'node-modules' ? 2 : 3
-                                   rescue StandardError
-                                     3
-                                   end
-                                 else
-                                   1
-                                 end
-                               else
-                                 ver = env('NODE_INSTALL')
-                                 if ver&.start_with?('yarn')
-                                   ver.include?('@1') ? 1 : 3
-                                 else
-                                   0
-                                 end
-                               end) > 0
+          (@pm[:yarn] ||= if File.exist?(base_path('yarn.lock'))
+                            if File.exist?(rc = base_path('.yarnrc.yml'))
+                              begin
+                                require 'yaml'
+                                doc = YAML.load_file(rc)
+                                doc.nodeLinker == 'node-modules' ? 2 : 3
+                              rescue StandardError
+                                3
+                              end
+                            else
+                              1
+                            end
+                          else
+                            ver = env('NODE_INSTALL')
+                            if ver&.start_with?('yarn')
+                              ver.include?('@1') ? 1 : 3
+                            else
+                              0
+                            end
+                          end) > 0
         end
 
         def pnpm?
-          (@package[:pnpm] ||= if File.exist?(base_path('pnpm-lock.yaml'))
-                                 begin
-                                   require 'yaml'
-                                   doc = YAML.load_file(base_path('node_modules/.modules.yaml'))
-                                   case doc['nodeLinker']
-                                   when 'hoisted'
-                                     1
-                                   when 'pnp'
-                                     3
-                                   else
-                                     4
-                                   end
-                                 rescue StandardError
-                                   4
-                                 end
-                               else
-                                 env('NODE_INSTALL')&.start_with?('pnpm') ? 4 : 0
-                               end) > 0
+          (@pm[:pnpm] ||= if File.exist?(base_path('pnpm-lock.yaml'))
+                            begin
+                              require 'yaml'
+                              doc = YAML.load_file(base_path('node_modules/.modules.yaml'))
+                              case doc['nodeLinker']
+                              when 'hoisted'
+                                1
+                              when 'pnp'
+                                3
+                              else
+                                4
+                              end
+                            rescue StandardError
+                              4
+                            end
+                          else
+                            env('NODE_INSTALL')&.start_with?('pnpm') ? 4 : 0
+                          end) > 0
         end
 
         def dev?
           return false if Node.prod?
 
-          @workspace.dev?(@dev, script: @output.last)
+          workspace.dev?(script: @output[1], pat: @dev, global: !@script || @script[:run].nil?)
         end
 
         def prod?
           return true if Node.prod?
 
-          @workspace.prod?(@prod, script: @output.last)
+          workspace.prod?(script: @output[1], pat: @prod, global: !@script || @script[:run].nil?)
         end
 
         protected
@@ -367,27 +438,39 @@ module Squared
         def append_loglevel(cmd = @session)
           return unless (level = env('NODE_LOGLEVEL'))
 
+          silent = !workspace.verbose || level == 'silent'
           if yarn?
             if install_type(:yarn) == 1
-              case level
-              when 'silent', 'verbose'
-                cmd << "--#{level}"
+              if silent
+                cmd << '--silent'
+              elsif level == 'verbose'
+                cmd << '--verbose'
               end
             end
           elsif pnpm?
+            if silent
+              cmd << '--reporter=silent'
+              level ||= 'error'
+            end
             case level
             when 'debug', 'info', 'warn', 'error'
               cmd << "--loglevel=#{level}"
-            when 'silent'
-              cmd << '--reporter=silent'
             end
+          elsif silent
+            cmd << '--loglevel=silent'
           else
             case level
-            when 'silent', 'error', 'warn', 'notice', 'http', 'info', 'verbose', 'silly'
+            when 'error', 'warn', 'notice', 'http', 'info', 'verbose', 'silly'
               cmd << "--loglevel=#{level}"
             end
           end
         end
+
+        private
+
+        def package
+          @package ||= base_path('package.json')
+        end
       end
     end
   end

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

@@ -4,31 +4,37 @@ module Squared
   module Repo
     module Project
       class Python < Git
+        REF = :python
+        REQUIREMENTS = %w[requirements.txt pyproject.toml setup.py].freeze
+        private_constant :REF, :REQUIREMENTS
+
         class << self
+          def populate(*); end
+
           def tasks
             nil
           end
 
-          def to_sym
-            :python
-          end
-
           def venv?
-            path = ENV['VIRTUAL_ENV']
-            !path.nil? && Dir.exist?(path)
+            val = ENV['VIRTUAL_ENV']
+            !val.nil? && Dir.exist?(val)
           end
 
-          def is_a?(path)
-            if path.is_a?(::String) || path.is_a?(::Pathname)
-              base = Pathname.new(path)
-              ['setup.py', 'requirements.txt'].any? { |file| base.join(file).exist? }
+          def is_a?(val)
+            if (val = as_path(val))
+              REQUIREMENTS.any? { |file| val.join(file).exist? }
             else
               super
             end
           end
         end
 
-        @@tasks[:python] = {
+        def initialize(name, path, workspace, *, **kwargs)
+          super
+          initialize_build(REF, **kwargs)
+        end
+
+        @@tasks[REF] = {
           install: %i[upgrade force]
         }.freeze
 
@@ -36,8 +42,8 @@ module Squared
           super
           return unless outdated?
 
-          namespace @name do
-            @@tasks[:python].each do |action, flags|
+          namespace name do
+            @@tasks[REF].each do |action, flags|
               namespace action do
                 flags.each do |flag|
                   case action
@@ -65,32 +71,45 @@ module Squared
         def depend(flag = nil, opts: [])
           if @depend
             super
-          else
-            cmd = pip_session 'install -r requirements.txt'
-            case flag
-            when :upgrade
-              cmd << '--upgrade'
-              cmd << '--upgrade-strategy=eager' if opts.include?('eager')
-            when :force
-              cmd << '--force-reinstall'
+          elsif outdated?
+            case install_type
+            when 1, 2
+              cmd = pip_session 'install'
+              case flag
+              when :upgrade
+                cmd << '--upgrade'
+                cmd << '--upgrade-strategy=eager' if opts.include?('eager')
+              when :force
+                cmd << '--force-reinstall'
+              end
+              cmd << '--pre' if opts.include?('pre')
+              cmd << '--require-virtualenv' if opts.include?('venv')
+              cmd << '--no-cache-dir' if opts.include?('no-cache')
+              cmd << '--dry-run' if opts.include?('dry-run')
+              append_nocolor
+              cmd << (install_type == 1 ? '-r requirements.txt' : '.')
+              run(exception: workspace.exception)
+            when 3
+              run_s "#{@bin} setup.py install"
             end
-            cmd << '--pre' if opts.include?('pre')
-            cmd << '--require-virtualenv' if opts.include?('venv')
-            cmd << '--no-cache-dir' if opts.include?('no-cache')
-            cmd << '--dry-run' if opts.include?('dry-run')
-            append_nocolor
-            run(exception: @workspace.exception)
           end
         end
 
         def outdated(*); end
 
+        def install_type(*)
+          return @requirements if @requirements
+
+          ret = REQUIREMENTS.index { |file| base_path(file).exist? }
+          @requirements = ret ? ret + 1 : 0
+        end
+
         def depend?
-          !@depend.nil? || outdated?
+          !!@depend || outdated?
         end
 
         def outdated?
-          base_path('requirements.txt').exist?
+          install_type > 0
         end
 
         private