squared 0.0.12 → 0.1.1

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

@@ -38,6 +38,7 @@ module Squared
           install: %i[force frozen dedupe].freeze,
           outdated: %i[major minor patch].freeze,
           bump: %i[major minor patch].freeze,
+          update: nil,
           run: nil
         }.freeze
 
@@ -74,7 +75,7 @@ module Squared
                     else
                       cmd = guard_params(action, 'command', args: args.to_a)
                       cmd.each do |val|
-                        if (data = indexdata(val))
+                        if (data = indexitem(val))
                           n, opts = data
                           list = read_scripts
                           if (item = list[n - 1])
@@ -89,6 +90,11 @@ module Squared
                       end
                     end
                   end
+                when :update
+                  desc format_desc(action, nil, 'packages*')
+                  task action, [:packages] do |_, args|
+                    update args.to_a
+                  end
                 end
               else
                 namespace action do
@@ -117,52 +123,85 @@ module Squared
           end
         end
 
-        def copy(from: 'build', glob: nil, into: 'node_modules', scope: nil, also: nil, override: false)
+        def copy(from: 'build', into: 'node_modules', workspace: false, include: nil, exclude: nil, scope: nil,
+                 also: nil, create: nil, override: false)
           return if @copy == false
 
           if @copy && !override
             return super if runnable?(@copy)
 
             from = @copy[:from] if @copy.key?(:from)
-            glob = @copy[:glob] if @copy.key?(:glob)
             into = @copy[:into] if @copy.key?(:into)
-            scope = @copy[:scope] if @copy.key?(:scope)
-            also = @copy[:also] if @copy.key?(:also)
+            workspace = @copy[:workspace] if @copy.key?(:workspace)
+            glob = @copy[:include]
+            exclude = @copy[:exclude]
+            scope = @copy[:scope]
+            also = @copy[:also]
+            create = @copy[:create]
           end
-          items = [path != workspace.home && workspace.home? ? workspace.home : nil]
+          items = []
+          items << @workspace.home if build? && path != @workspace.home && @workspace.home?
           items += as_a(also) if also
-          items.each_with_index do |dir, i|
-            if i == 0
-              next unless dev? && build?
+          return if items.empty?
 
+          print_item unless @output[0] || !verbose || task_invoked?(/^copy(?::#{Node.ref}|$)/)
+          items.each do |dir|
+            case dir
+            when Pathname
               dest = dir
+            when String
+              dest = @workspace.rootpath(dir)
+            when Symbol
+              dest = @workspace.find(name: dir)&.path
+              log.warn message("copy project :#{dir}", hint: 'not found') unless dest
+            when Hash
+              glob = dir[:include]
+              exclude = dir[:exclude]
+              from = dir[:from] if dir.key?(:from)
+              into = dir[:into] if dir.key?(:into)
+              scope = dir[:scope] if dir.key?(:scope)
+              dest = dir[:target]
+              create = dir[:create]
+              workspace = dir[:workspace]
+              dest = items.first unless dest && dest != true
+            when Project::Base
+              dest = dir.path
             else
-              case dir
-              when ::String
-                dest = workspace.rootpath(dir)
-              when ::Symbol
-                dest = workspace.find(name: dir)&.path
-                log.warn message("copy project :#{dir}", hint: 'not found') unless dest
-              when ::Hash
-                missing = ->(val) { log.warn message("copy attr :#{val}", hint: 'missing') }
-                glob = dir[:glob]
-                into = dir[:into] if dir.key?(:into)
-                scope = dir[:scope]
-                missing.('target') unless (dest = dir[:target])
-                missing.('from') unless (from = dir[:from])
-              when Project::Base
-                dest = dir.path
-              else
-                raise_error("given: #{dir}", hint: 'unknown')
-              end
+              raise_error("given: #{dir}", hint: 'unknown')
             end
             next unless from && dest&.directory?
 
             from = basepath(from)
-            dest = dest.join(into, scope || project)
             glob = as_a(glob || '**/*')
-            glob.each { |val| log.info "cp #{from.join(val)} #{dest}" }
-            copy_d(from, dest, glob: glob, verbose: verbose)
+            target = []
+            if workspace
+              Dir.glob(from.join('*')).each do |path|
+                next unless (path = Pathname.new(path)).directory?
+
+                sub = if (proj = @workspace.find(path))
+                        proj.packagename
+                      elsif (file = path.join('package.json')).exist?
+                        begin
+                          doc = JSON.parse(file.read)
+                          doc['name']
+                        rescue StandardError => e
+                          log.error e
+                          raise if exception
+                        end
+                      end
+                if sub
+                  target << [path, dest.join(into, sub)]
+                else
+                  log.debug message("package.json in \"#{path}\"", hint: 'not found')
+                end
+              end
+            else
+              target << [from, dest.join(into, scope || project)]
+            end
+            target.each do |src, to|
+              glob.each { |val| log.info "cp #{from.join(val)} #{to}" }
+              copy_d(src, to, glob: glob, create: create, pass: exclude, verbose: verbose)
+            end
           end
         end
 
@@ -229,33 +268,42 @@ module Squared
           end
         end
 
-        def outdated(rev = nil, opts: [])
+        def outdated(rev = nil, opts: [], sync: invoked_sync?('outdated', rev))
           dryrun = opts.include?('dry-run')
           if pnpm? && read_packagemanager(version: '7.15')
             cmd = 'pnpm outdated'
-            dryrun ||= !option('dry-run', prefix: 'pnpm').nil?
+            dryrun ||= dryrun?('pnpm')
           else
             cmd = 'npm outdated'
-            dryrun ||= !option('dry-run', prefix: 'npm').nil?
+            dryrun ||= dryrun?('npm')
           end
           log.info cmd
           banner = format_banner("#{cmd}#{dryrun ? ' --dry-run' : ''}")
-          if invoked_sync?('outdated', rev)
+          if sync
             print_item banner
             banner = nil
           end
-          data = nil
-          pwd_set { data = `#{cmd} --json --loglevel=error` }
-          json = JSON.parse(doc = dependfile.read)
-          dep1 = json['dependencies'] || {}
-          dep2 = json['devDependencies'] || {}
+          begin
+            data = pwd_set { `#{cmd} --json --loglevel=error` }
+            json = JSON.parse(doc = dependfile.read)
+          rescue StandardError => e
+            log.error e
+            raise if exception
+
+            warn log_message(Logger::WARN, e) if warning?
+            return
+          else
+            dep1 = json['dependencies'] || {}
+            dep2 = json['devDependencies'] || {}
+            target = json['name']
+          end
           found = []
           avail = []
           rev ||= (prod? ? :patch : :minor)
           inter = opts.include?('interactive')
           unless data.empty?
             JSON.parse(data).each_pair do |key, val|
-              val = val.find { |obj| obj['dependent'] == json['name'] } if val.is_a?(::Array)
+              val = val.find { |obj| obj['dependent'] == target } if val.is_a?(Array)
               next unless val && (file = dep1[key] || dep2[key]) && file != '*'
 
               latest = val['latest']
@@ -271,8 +319,8 @@ module Squared
               want = rev == :major && (ver = latest.match(SEM_VER)) && !ver[6] ? latest : val['wanted']
               next unless (val['current'] != want || file != want) && (want.match?(SEM_VER) || !file.match?(SEM_VER))
 
-              f = semver(semscan(file))
-              w = semver(semscan(want))
+              f = semscan(file)
+              w = semscan(want)
               a = f[0]
               b = f[2]
               c = w[0]
@@ -356,9 +404,9 @@ module Squared
             if dryrun || (modified == 0 && pending > 0)
               footer.(modified)
             elsif modified > 0
-              File.write(dependfile, doc)
               modified = -1
               footer.()
+              File.write(dependfile, doc)
               commit(:add, ['package.json'], pass: true)
               install if opts.include?('prune')
             end
@@ -384,30 +432,10 @@ module Squared
           end
         end
 
-        def compose(opts, flags = nil, script: false)
-          return unless opts && script
-
-          ret = session (if yarn?
-                           'yarn'
-                         else
-                           pnpm? ? 'pnpm' : 'npm'
-                         end), 'run', flags
-          append_loglevel
-          case opts
-          when ::Enumerable
-            ret += opts.to_a
-          when ::String
-            ret << opts
-          else
-            raise_error("#{ret.first} script name", hint: opts.nil? ? 'missing' : 'invalid')
-          end
-          ret
-        end
-
-        def bump(flag)
+        def bump(flag = nil)
           return unless (ver = version)
 
-          seg = semscan(ver)
+          seg = semscan(ver, fill: false)
           case flag
           when :major
             if seg[0] != '0' || seg[2].nil?
@@ -421,45 +449,74 @@ module Squared
             else
               seg[2] = seg[2].succ
             end
-          when :patch
+          else
             seg[4] &&= seg[4].succ
           end
-          unless (out = seg.join) == ver
-            begin
-              doc = dependfile.read
-              if doc.sub!(/"version"\s*:\s*"#{ver}"/, "\"version\": \"#{out}\"")
+          return if (out = seg.join) == ver
+
+          begin
+            doc = dependfile.read
+            if doc.sub!(/"version"\s*:\s*"#{ver}"/, "\"version\": \"#{out}\"")
+              unless dryrun?
                 dependfile.write(doc)
                 log.info "bump version #{ver} to #{out} (#{flag})"
-                if verbose
-                  major = flag == :major
-                  emphasize("version: #{out}", title: name, border: borderstyle, sub: [
-                    headerstyle,
-                    { pat: /^(version:)( )(\S+)(.*)$/, styles: color(major ? :green : :yellow), index: 3 },
-                    { pat: /^(version:)(.*)$/, styles: theme[major ? :major : :active] }
-                  ])
-                elsif stdin?
-                  puts out
-                end
-              else
-                raise_error('not found', hint: 'version')
               end
-            rescue StandardError => e
-              log.debug e
-              raise
+              if verbose
+                major = flag == :major
+                emphasize("version: #{out}", title: name, border: borderstyle, sub: [
+                  headerstyle,
+                  { pat: /^(version:)( )(\S+)(.*)$/, styles: color(major ? :green : :yellow), index: 3 },
+                  { pat: /^(version:)(.*)$/, styles: theme[major ? :major : :active] }
+                ])
+              elsif stdin?
+                puts out
+              end
+            else
+              raise_error('not found', hint: 'version')
             end
+          rescue StandardError => e
+            log.debug e
+            raise if exception
           end
         end
 
-        def version
-          read_packagemanager
-          @pm[:version]
+        def update(pkgs = [])
+          if (yarn = dependtype(:yarn)) > 0
+            cmd = session 'yarn'
+            if yarn > 1
+              cmd << 'up'
+            else
+              cmd << 'upgrade'
+              cmd << '--ignore-engines' unless option('ignore-engines', equals: '0')
+            end
+          elsif pnpm?
+            cmd = session 'pnpm', 'update'
+            cmd << '--prod' if prod?
+            append_nocolor option('no-color')
+          else
+            cmd = session 'npm', 'update'
+            cmd << '--omit=dev' if prod?
+            append_nocolor option('no-color')
+          end
+          append_loglevel
+          append_value pkgs
+          run
         end
 
-        def dependtype(prog)
-          return @pm[prog] if @pm.key?(prog)
+        def compose(opts, flags = nil, script: false)
+          return unless opts && script
 
-          meth = :"#{prog}?"
-          respond_to?(meth) && __send__(meth) ? @pm[prog] : 0
+          ret = session dependbin, 'run', flags
+          append_loglevel
+          case opts
+          when Enumerable
+            ret += opts.to_a
+          when String
+            ret << opts
+          else
+            raise_error("#{ret.first} script name", hint: opts.nil? ? 'missing' : 'invalid')
+          end
+          ret
         end
 
         def depend?
@@ -467,7 +524,7 @@ module Squared
         end
 
         def copy?
-          super || @copy.is_a?(::Hash)
+          super || @copy.is_a?(Hash)
         end
 
         def outdated?
@@ -475,8 +532,8 @@ module Squared
         end
 
         def yarn?
-          (@pm[:yarn] ||= if basepath('yarn.lock', ascend: find_package).exist?
-                            if (rc = basepath('.yarnrc.yml', ascend: find_package)).exist?
+          (@pm[:yarn] ||= if basepath('yarn.lock', ascend: dependext).exist?
+                            if (rc = basepath('.yarnrc.yml', ascend: dependext)).exist?
                               begin
                                 require 'yaml'
                                 doc = YAML.load_file(rc)
@@ -495,10 +552,10 @@ module Squared
         end
 
         def pnpm?
-          (@pm[:pnpm] ||= if basepath('pnpm-lock.yaml', ascend: find_package).exist?
+          (@pm[:pnpm] ||= if basepath('pnpm-lock.yaml', ascend: dependext).exist?
                             begin
                               require 'yaml'
-                              doc = YAML.load_file(basepath('node_modules/.modules.yaml', ascend: find_package))
+                              doc = YAML.load_file(basepath('node_modules/.modules.yaml', ascend: dependext))
                               @pm[:_] = doc['packageManager']
                               case doc['nodeLinker']
                               when 'hoisted'
@@ -521,24 +578,42 @@ module Squared
             basepath('pnpm-workspace.yaml').exist?
           else
             read_packagemanager
-            @pm[:workspaces].is_a?(::Array)
+            @pm[:workspaces].is_a?(Array)
           end
         end
 
         def dev?
-          !Node.prod? && super
+          super && (!Node.prod? || (@dev == true && !prod?))
         end
 
         def prod?
           @prod != false && (Node.prod? || super)
         end
 
+        def dependtype(prog)
+          return @pm[prog] if @pm.key?(prog)
+
+          meth = :"#{prog}?"
+          respond_to?(meth) && __send__(meth) ? @pm[prog] : 0
+        end
+
+        def version
+          read_packagemanager
+          @pm[:version]
+        end
+
+        def packagename
+          read_packagemanager
+          @pm[:name]
+        end
+
         private
 
         def read_packagemanager(version: nil)
           if @pm[:_].nil?
             doc = JSON.parse(dependfile.read)
             @pm[:_] = (val = doc['packageManager']) ? val[0..(val.index('+') || 0) - 1] : false
+            @pm[:name] = doc['name']
             @pm[:scripts] = doc['scripts']
             @pm[:version] = doc['version']
             @pm[:workspaces] = doc['workspaces']
@@ -560,7 +635,7 @@ module Squared
 
         def read_scripts
           read_packagemanager
-          @pm[:scripts].is_a?(::Hash) ? @pm[:scripts].to_a : []
+          @pm[:scripts].is_a?(Hash) ? @pm[:scripts].to_a : []
         end
 
         def append_loglevel
@@ -605,12 +680,24 @@ module Squared
                           'PATCH'
                         end, styles: theme[:header])
           b = sub_style("#{pkg} #{ver}", styles: theme[:inline])
-          c, d = rev == 1 || lock ? %w[y/N N] : %w[Y/n Y]
+          c, d = rev == 1 || lock ? ['y/N', 'N'] : ['Y/n', 'Y']
           e = lock ? " #{sub_style('(locked)', styles: color(:red))}" : ''
           Common::Prompt.confirm("Upgrade to #{a}? #{b}#{e} [#{c}] ", d, timeout: 60)
         end
 
-        def find_package
+        def dryrun?(prefix = dependbin)
+          !option('dry-run', prefix: prefix).nil?
+        end
+
+        def dependbin
+          if yarn?
+            'yarn'
+          else
+            pnpm? ? 'pnpm' : 'npm'
+          end
+        end
+
+        def dependext
           'package.json' if parent&.has?('outdated', Node.ref)
         end
       end

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

@@ -6,7 +6,7 @@ module Squared
       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_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
 
@@ -116,6 +116,8 @@ module Squared
               when :force
                 cmd << '--force-reinstall'
                 append_pip opts, OPT_FORCE
+              else
+                append_pip
               end
               cmd << (type == 1 ? '-r requirements.txt' : '.')
               run(sync: sync)
@@ -125,9 +127,10 @@ module Squared
           end
         end
 
-        def outdated(*)
+        def outdated(*, sync: invoked_sync?('outdated'))
           pip_session 'list', '--outdated'
-          run
+          append_pip
+          run(sync: sync)
         end
 
         def variable_set(key, *val, **)
@@ -159,7 +162,7 @@ module Squared
           session('pip', *cmd)
         end
 
-        def append_pip(opts, list = [])
+        def append_pip(opts = [], list = [])
           opts.each do |opt|
             next unless list.include?(opt) || OPT_GENERAL.include?(opt) || (v = opt.match(/^v+$/))
 
@@ -170,14 +173,13 @@ module Squared
                           (v ? "-#{v[0]}" : "--#{opt}")
                         end
           end
-          @session << '--user' if option('user')
-          @session << '--no-input' if option('no-input')
           if (val = option('proxy', ignore: false))
             @session << "--proxy=#{shell_escape(val, quote: true)}"
           end
-          if (val = option('log', ignore: false))
-            @session << "--log=#{shell_escape(basepath(val), quote: true)}"
-          end
+          @session << "--python=#{shell_escape(basepath(val), quote: true)}" if (val = option('python', ignore: false))
+          @session << "--log=#{shell_escape(basepath(val), quote: true)}" if (val = option('log', ignore: false))
+          @session << '--user' if option('user')
+          @session << '--no-input' if option('no-input')
           append_nocolor option('no-color')
         end
 

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

@@ -6,7 +6,7 @@ module Squared
       class Ruby < Git
         VAR_SET = %i[version autodetect].freeze
         GEMFILE = %w[Gemfile Gemfile.lock gem.deps.rb Isolate].freeze
-        RUBY_DIR = [*GEMFILE, *::Rake::Application::DEFAULT_RAKEFILES, 'README.rdoc'].freeze
+        RUBY_DIR = (GEMFILE + Rake::Application::DEFAULT_RAKEFILES + ['README.rdoc']).freeze
         OPT_INSTALL = %w[no-cache force].freeze
         OPT_UPDATE = %w[redownload local strict conservative group=s].freeze
         OPT_OUTDATED = %w[local strict pre only-explicit group=s].freeze
@@ -95,7 +95,7 @@ module Squared
                     if args.command == '#'
                       format_list(read_rakefile, 'rake[^N]', 'tasks', grep: args.extras, from: rakefile.to_s,
                                                                       each: ->(val) { val[0] + val[1].to_s })
-                    elsif (data = indexdata(args.command))
+                    elsif (data = indexitem(args.command))
                       n, opts = data
                       list = read_rakefile
                       if (item = list[n - 1])
@@ -206,35 +206,36 @@ module Squared
           end
         end
 
-        def copy(from: 'lib', glob: nil, into: @gemdir, override: false)
+        def copy(from: 'lib', include: nil, exclude: nil, into: @gemdir, override: false)
           if @copy && !override
             return super if runnable?(@copy)
 
             from = @copy[:from] if @copy.key?(:from)
-            glob = @copy[:glob] if @copy.key?(:glob)
+            glob = @copy[:include] if @copy.key?(:include)
+            exclude = @copy[:exclude] if @copy.key?(:exclude)
             into = @copy[:into] if @copy.key?(:into)
           end
           return unless into
 
           dest = Pathname.new(into).realpath
-          print_item unless @output[0]
+          print_item unless @output[0] || task_invoked?(/^copy(?::#{Ruby.ref}|$)/)
           glob = as_a(glob || '**/*')
           as_a(from).each_with_index do |val, i|
             a = basepath(val)
             b = dest.join(val)
             c = glob[i] || glob[0]
             log.info "cp #{a.join(c)} #{b}"
-            copy_d(a, b, glob: c, verbose: verbose)
+            copy_d(a, b, glob: c, pass: exclude, verbose: verbose)
           end
         end
 
-        def outdated(rev = nil, opts: [])
+        def outdated(rev = nil, opts: [], sync: invoked_sync?('outdated', rev))
           cmd = bundle_session 'outdated', rev && "--#{rev}"
           append_bundle opts, OPT_OUTDATED
           cmd = session_done(cmd)
           log.info cmd
           banner = format_banner(cmd)
-          if invoked_sync?('outdated', rev)
+          if sync
             print_item banner
             banner = nil
           end
@@ -363,10 +364,11 @@ module Squared
         end
 
         def rake(*cmd)
+          file = shell_quote(Rake.application.rakefile)
           if cmd.empty?
-            run_s 'rake'
+            run_s("rake --rakefile=#{file}", chdir: workspace.pwd)
           else
-            run_s(*cmd.map { |val| "rake #{val}" }, banner: false)
+            run_s(*cmd.map { |val| "rake --rakefile=#{file} #{val}" }, chdir: workspace.pwd, banner: false)
           end
         end
 
@@ -375,7 +377,7 @@ module Squared
         end
 
         def copy?
-          return true if super || (@copy.is_a?(::Hash) && copy.fetch(:into, nil))
+          return true if super || (@copy.is_a?(Hash) && copy.fetch(:into, nil))
           return gemdir? if @gemdir
 
           if @version && (val = ENV['GEM_HOME'])
@@ -385,9 +387,8 @@ module Squared
           return false unless @autodetect
 
           unsafe = ->(hint) { raise_error('failed to parse', hint: hint) }
-          out = `gem -C #{shell_quote(path)} list --local -d #{project}`
-          data = /#{Regexp.escape(project)} \(([^)]+)\)/.match(out)
-          unsafe.('version') unless data
+          out = pwd_set { `gem list --local -d #{project}` }
+          unsafe.('version') unless (data = /#{Regexp.escape(project)} \(([^)]+)\)/.match(out))
           ver = data[1].split(/\s*,\s*/)
           ver.unshift(@version).uniq! if @version
           ver.each do |v|
@@ -414,11 +415,6 @@ module Squared
 
         private
 
-        def variables
-          ret = super + VAR_SET
-          ret.freeze
-        end
-
         def run_rb(sync: true)
           run(sync: sync, banner: !@session.include?('--quiet'))
         end
@@ -457,26 +453,34 @@ module Squared
           return @rakelist if @rakelist
 
           ret = []
-          IO.popen("rake -C #{shell_quote(path)} -AT").each do |line|
-            next unless (data = /^rake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/.match(line))
+          pass = Rake::VERSION >= '13.0.4'
+          pwd_set(pass: pass) do
+            IO.popen("rake#{pass ? " -C #{shell_quote(path)}" : ''} -AT").each do |line|
+              next unless (data = /^rake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/.match(line))
 
-            ret << [data[1], data[2]]
+              ret << [data[1], data[2]]
+            end
           end
           @rakelist = ret
         end
 
+        def gemdir?
+          @gemdir.exist? && !@gemdir.empty?
+        end
+
+        def variables
+          ret = super + VAR_SET
+          ret.freeze
+        end
+
         def rakefile
-          file = ::Rake::Application::DEFAULT_RAKEFILES.find { |val| basepath(val).exist? }
+          file = Rake::Application::DEFAULT_RAKEFILES.find { |val| basepath(val).exist? }
           basepath(file) if file
         end
 
         def gempath
           File.join('gems', "#{project}-#{@version}")
         end
-
-        def gemdir?
-          @gemdir.exist? && !@gemdir.empty?
-        end
       end
 
       Application.implement Ruby