squared 0.0.1

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

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+
+module Squared
+  module Repo
+    module Project
+      class Node < Git
+        class << self
+          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?
+            else
+              super
+            end
+          end
+        end
+
+        @@tasks[:node] = {
+          install: %i[force dedupe],
+          outdated: %i[major minor patch]
+        }.freeze
+
+        def initialize(name, project, workspace, **kwargs)
+          super
+          @clean ||= ['build/']
+          @dev = workspace.bool_match(env('BUILD', suffix: 'DEV'), kwargs.delete(:dev))
+          @prod = workspace.bool_match(env('BUILD', suffix: 'PROD'), kwargs.delete(:prod))
+          @package = {}
+        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)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def copy(from: 'build', glob: '**/*', basedir: '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)
+            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.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)
+            elsif dir.is_a?(::Symbol)
+              dest = Repo.resolve(dir)&.path
+            elsif dir.is_a?(Project)
+              dest = dir.path
+            elsif dir.is_a?(::Hash)
+              into = nil
+              glob = nil
+              dir.each do |key, val|
+                case key.to_sym
+                when :from
+                  from = val
+                when :glob
+                  glob = val
+                when :basedir
+                  basedir = val
+                when :into
+                  into = val
+                end
+              end
+              next unless into
+            end
+            next unless dest&.directory?
+
+            from = base_path(from)
+            dest = dest.join(basedir, into || @project)
+            warn "cp #{from.join(glob)} #{dest}"
+            copy_d(from, dest, glob: glob, verbose: verbose?)
+          end
+        end
+
+        def depend(flag = nil)
+          if @depend
+            super
+          else
+            force = flag == :force
+            dedupe = flag == :dedupe
+            if (yarn = install_type(:yarn)) > 0
+              cmd = session 'yarn', 'install'
+              if yarn > 1
+                cmd << '--check-cache' if force
+              else
+                cmd << '--production' if prod?
+                cmd << '--force' if force
+                cmd << '--ignore-engines' unless env('YARN_IGNORE_ENGINES', equals: '0')
+              end
+            elsif pnpm?
+              cmd = session 'pnpm'
+              if dedupe
+                cmd << 'dedupe'
+              else
+                cmd << 'install'
+                cmd << '--force' if force
+              end
+              cmd << '--prod' if prod?
+              append_nocolor
+            else
+              cmd = session 'npm'
+              cmd << (dedupe ? 'dedupe' : 'install')
+              cmd << '--omit=dev' if prod?
+              cmd << '--force' if force
+              append_nocolor
+            end
+            append_loglevel
+            run(exception: @workspace.exception)
+          end
+        end
+
+        def outdated(rev = nil, opts: [])
+          require 'json'
+          rev ||= prod? ? :patch : :minor
+          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)
+          info cmd
+          data = `#{cmd} --json --loglevel=error`
+          Dir.chdir(pwd)
+          target = base_path('package.json')
+          doc = File.read(target)
+          json = JSON.parse(doc)
+          dep1 = json['dependencies'] || {}
+          dep2 = json['devDependencies'] || {}
+          found = []
+          avail = []
+          if !data.empty?
+            validate = ->(ver) { /^\d+\.\d+\.\d+$/.match?(ver) }
+            JSON.parse(data).each_pair do |key, val|
+              file = dep1[key] || dep2[key]
+              ch = file[0]
+              if !/[~^]/.match?(ch)
+                avail << [key, file, val['latest'], true]
+                next
+              end
+              file = file[1..-1]
+              cur = val['current']
+              want = if rev == :major && validate.(val['latest'])
+                       [val['latest'], val['wanted']].max { |a, b| a <=> b }
+                     else
+                       val['wanted']
+                     end
+              next unless (cur != want || file != want) && (validate.(want) || !validate.(file))
+
+              a, b = file.split('.')
+              c, d = want.split('.')
+              upgrade = false
+              case rev
+              when :major
+                upgrade = a == '0' ? c == '0' : true
+              when :minor
+                upgrade = ch == '^' && (a == '0' ? c == '0' && b == d : a == c)
+              when :patch
+                upgrade = a == c && b == d
+              end
+              if upgrade
+                next if file == want
+
+                found << [key, file, want]
+              else
+                avail << [key, file, val['latest'], false]
+              end
+            end
+          end
+          pending = 0
+          modified = 0
+          size_col = ->(items, i) { items.map { |a| a[i] }.max_by(&:size).size }
+          pad_ord = lambda do |val, ord|
+            ret = val.succ.to_s
+            ord.size > 9 ? ret.rjust(ord.size.to_s.size) : ret
+          end
+          footer = lambda do |val = 0|
+            next unless verbose?
+
+            msg, hint = if modified == -1
+                          ['Packages were updated', 'more possible']
+                        else
+                          ['No packages were updated', 'possible']
+                        end
+            puts Project.footer(empty_status(msg, hint, pending + val))
+          end
+          if !found.empty?
+            col1 = size_col.(found, 0)
+            col2 = size_col.(found, 1)
+            found.each_with_index do |item, i|
+              a, b, c = item
+              cur = modified
+              doc.sub!(/("#{Regexp.escape(a)}"\s*:\s*)"([~^])#{Regexp.escape(b)}"/) do |capture|
+                if $2 == '~' && rev != :patch
+                  cur = -1
+                  pending += 1
+                  capture
+                else
+                  modified += 1
+                  "#{$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}"
+            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)
+              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)
+            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}"
+              pending += 1 unless d
+            end
+            footer.()
+          else
+            puts 'No updates were found'
+          end
+        end
+
+        def compose(opts)
+          cmd = [if yarn?
+                   'yarn'
+                 else
+                   pnpm? ? 'pnpm' : 'npm'
+                 end]
+          cmd << 'run'
+          append_loglevel cmd
+          if opts.is_a?(::Array)
+            cmd += opts
+          else
+            cmd << (opts || @workspace.script)
+          end
+          cmd.join(' ')
+        end
+
+        def install_type(prog)
+          key = :"#{prog}?"
+          send(key) if respond_to?(key)
+          @package[prog.to_sym] || 0
+        end
+
+        def depend?
+          !@depend.nil? || outdated?
+        end
+
+        def copy?
+          !@copy.nil?
+        end
+
+        def outdated?
+          base_path('package.json').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
+        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
+        end
+
+        def dev?
+          return false if Node.prod?
+
+          @workspace.dev?(@dev, script: @output.last)
+        end
+
+        def prod?
+          return true if Node.prod?
+
+          @workspace.prod?(@prod, script: @output.last)
+        end
+
+        protected
+
+        def append_loglevel(cmd = @session)
+          return unless (level = env('NODE_LOGLEVEL'))
+
+          if yarn?
+            if install_type(:yarn) == 1
+              case level
+              when 'silent', 'verbose'
+                cmd << "--#{level}"
+              end
+            end
+          elsif pnpm?
+            case level
+            when 'debug', 'info', 'warn', 'error'
+              cmd << "--loglevel=#{level}"
+            when 'silent'
+              cmd << '--reporter=silent'
+            end
+          else
+            case level
+            when 'silent', 'error', 'warn', 'notice', 'http', 'info', 'verbose', 'silly'
+              cmd << "--loglevel=#{level}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Squared
+  module Repo
+    module Project
+      class Python < Git
+        class << self
+          def tasks
+            nil
+          end
+
+          def to_sym
+            :python
+          end
+
+          def venv?
+            path = ENV['VIRTUAL_ENV']
+            !path.nil? && Dir.exist?(path)
+          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? }
+            else
+              super
+            end
+          end
+        end
+
+        @@tasks[:python] = {
+          install: %i[upgrade force]
+        }.freeze
+
+        def populate(*)
+          super
+          return unless outdated?
+
+          namespace @name do
+            @@tasks[:python].each do |action, flags|
+              namespace action do
+                flags.each do |flag|
+                  case action
+                  when :install
+                    options = lambda do |*opts|
+                      opts += %w[pre venv no-cache dry-run]
+                      format_desc(action, flag, opts)
+                    end
+                    case flag
+                    when :upgrade
+                      desc options.('eager')
+                    when :force
+                      desc options.()
+                    end
+                    task flag do |_, args|
+                      install(flag, opts: collect_args(args, :opts))
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        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'
+            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 depend?
+          !@depend.nil? || outdated?
+        end
+
+        def outdated?
+          base_path('requirements.txt').exist?
+        end
+
+        private
+
+        def pip_session(*cmd)
+          session('pip', *cmd)
+        end
+      end
+    end
+  end
+end