squared 0.0.10 → 0.0.12

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

@@ -8,30 +8,39 @@ module Squared
           def populate(*); end
 
           def tasks
-            nil
+            %i[outdated].freeze
+          end
+
+          def batchargs
+            [ref, { refresh: %i[build copy] }]
+          end
+
+          def aliasargs
+            [ref, { refresh: :build }]
+          end
+
+          def bannerargs
+            %i[version dependfile].freeze
           end
 
           def prod?
             ENV['NODE_ENV'] == 'production'
           end
 
-          def is_a?(val)
-            if (val = as_path(val))
-              val.join('package.json').exist?
-            else
-              super
-            end
+          def config?(val)
+            return false unless (val = as_path(val))
+
+            val.join('package.json').exist?
           end
         end
 
         @@tasks[ref] = {
-          install: %i[force frozen dedupe],
-          outdated: %i[major minor patch],
+          install: %i[force frozen dedupe].freeze,
+          outdated: %i[major minor patch].freeze,
+          bump: %i[major minor patch].freeze,
           run: nil
         }.freeze
 
-        attr_reader :package
-
         def initialize(*, **kwargs)
           super
           if @pass.include?(Node.ref)
@@ -42,7 +51,7 @@ module Squared
             initialize_env(**kwargs)
           end
           @pm = {}
-          @package = base_path('package.json')
+          @dependfile = basepath('package.json')
         end
 
         def ref
@@ -58,11 +67,27 @@ module Squared
               if flags.nil?
                 case action
                 when :run
-                  desc format_desc(action, nil, 'command+')
+                  desc format_desc(action, nil, 'command+|^index|#,pattern*')
                   task action, [:command] do |_, args|
-                    cmd = args.to_a
-                    guard_params(action, 'command', args: cmd)
-                    cmd.each { |val| run_s compose(val) }
+                    if args.command == '#'
+                      format_list(read_scripts, 'run[^N]', 'scripts', grep: args.extras, from: dependfile.to_s)
+                    else
+                      cmd = guard_params(action, 'command', args: args.to_a)
+                      cmd.each do |val|
+                        if (data = indexdata(val))
+                          n, opts = data
+                          list = read_scripts
+                          if (item = list[n - 1])
+                            val = opts ? "#{item.first} #{opts}" : item.first
+                          elsif exception
+                            indexerror n, list
+                          else
+                            next log.warn "run script #{n} of #{list.size} (out of range)"
+                          end
+                        end
+                        run compose(val, script: true)
+                      end
+                    end
                   end
                 end
               else
@@ -75,10 +100,15 @@ module Squared
                         depend(flag)
                       end
                     when :outdated
-                      desc format_desc(action, flag, %w[prune interactive dry-run], arg: 'opts?')
+                      desc format_desc(action, flag, %w[prune interactive dry-run].freeze, arg: 'opts?')
                       task flag, [:opts] do |_, args|
                         outdated(flag, opts: args.to_a)
                       end
+                    else
+                      desc format_desc(action, flag)
+                      task flag do
+                        __send__(action, flag)
+                      end
                     end
                   end
                 end
@@ -87,17 +117,19 @@ module Squared
           end
         end
 
-        def copy(from: 'build', glob: '**/*', subdir: 'node_modules', into: nil, also: nil, override: false)
+        def copy(from: 'build', glob: nil, into: 'node_modules', scope: nil, also: 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)
-            subdir = @copy[:subdir] if @copy.key?(:subdir)
             into = @copy[:into] if @copy.key?(:into)
+            scope = @copy[:scope] if @copy.key?(:scope)
             also = @copy[:also] if @copy.key?(:also)
           end
-          items = [path == workspace.home ? nil : workspace.home]
+          items = [path != workspace.home && workspace.home? ? workspace.home : nil]
           items += as_a(also) if also
           items.each_with_index do |dir, i|
             if i == 0
@@ -107,46 +139,38 @@ module Squared
             else
               case dir
               when ::String
-                dest = workspace.root_path(dir)
+                dest = workspace.rootpath(dir)
               when ::Symbol
-                dest = Workspace.resolve(dir)&.path
+                dest = workspace.find(name: dir)&.path
+                log.warn message("copy project :#{dir}", hint: 'not found') unless dest
               when ::Hash
-                glob = '**/*'
-                dest = nil
-                into = nil
-                dir.each do |key, val|
-                  case key.to_sym
-                  when :target
-                    dest = val
-                  when :from
-                    from = val
-                  when :glob
-                    glob = val
-                  when :subdir
-                    subdir = val
-                  when :into
-                    into = val
-                  end
-                end
+                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
-              next unless into
             end
-            next unless dest&.directory?
+            next unless from && dest&.directory?
 
-            from = base_path(from)
-            dest = dest.join(subdir, into || project)
-            log.warn "cp #{from.join(glob)} #{dest}"
+            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)
           end
         end
 
-        def depend(flag = nil)
+        def depend(flag = nil, sync: invoked_sync?('depend', flag))
           if @depend && !flag
             super
           elsif outdated?
-            if (yarn = install_type(:yarn)) > 0
+            if (yarn = dependtype(:yarn)) > 0
               cmd = session 'yarn'
               if yarn > 1
                 if flag == :dedupe
@@ -165,7 +189,7 @@ module Squared
                                       '--frozen-lockfile'
                                     end
                 cmd << '--production' if flag && prod?
-                cmd << '--ignore-engines' unless env('YARN_IGNORE_ENGINES', equals: '0')
+                cmd << '--ignore-engines' unless option('ignore-engines', equals: '0')
               end
             elsif pnpm?
               cmd = session 'pnpm'
@@ -179,11 +203,11 @@ module Squared
                                     end
               end
               cmd << '--prod' if flag && prod?
-              if (val = env('PNPM_PUBLIC_HOIST_PATTERN'))
+              if (val = option('public-hoist-pattern', ignore: false))
                 split_escape(val).each { |opt| cmd << "--public-hoist-pattern=#{shell_escape(opt, quote: true)}" }
               end
               cmd << '--ignore-workspace' if env('NODE_WORKSPACES', equals: '0')
-              append_nocolor
+              append_nocolor option('no-color')
             else
               cmd = session 'npm'
               if flag == :dedupe
@@ -197,26 +221,32 @@ module Squared
               end
               cmd << '--omit=dev' if flag && prod?
               cmd << '--workspaces=false' if env('NODE_WORKSPACES', equals: '0')
-              cmd << '--package-lock=false' if env('NPM_PACKAGE_LOCK', equals: '0')
-              append_nocolor
+              cmd << '--package-lock=false' if option('package-lock', equals: '0')
+              append_nocolor option('no-color')
             end
             append_loglevel
-            run(sync: invoked_sync?('depend', flag))
+            run(sync: sync)
           end
         end
 
         def outdated(rev = nil, opts: [])
-          dryrun = opts.include?('dry-run') || !env('NODE_DRY_RUN').nil?
-          cmd = pnpm? && read_packagemanager(ver: '7.15') ? 'pnpm outdated' : 'npm outdated'
+          dryrun = opts.include?('dry-run')
+          if pnpm? && read_packagemanager(version: '7.15')
+            cmd = 'pnpm outdated'
+            dryrun ||= !option('dry-run', prefix: 'pnpm').nil?
+          else
+            cmd = 'npm outdated'
+            dryrun ||= !option('dry-run', prefix: 'npm').nil?
+          end
           log.info cmd
-          banner = format_banner("#{cmd}#{dryrun ? ' --dry-run' : ''}", multiple: true)
+          banner = format_banner("#{cmd}#{dryrun ? ' --dry-run' : ''}")
           if invoked_sync?('outdated', rev)
             print_item banner
             banner = nil
           end
           data = nil
           pwd_set { data = `#{cmd} --json --loglevel=error` }
-          json = JSON.parse(doc = package.read)
+          json = JSON.parse(doc = dependfile.read)
           dep1 = json['dependencies'] || {}
           dep2 = json['devDependencies'] || {}
           found = []
@@ -226,7 +256,7 @@ module Squared
           unless data.empty?
             JSON.parse(data).each_pair do |key, val|
               val = val.find { |obj| obj['dependent'] == json['name'] } if val.is_a?(::Array)
-              next unless val && (file = dep1[key] || dep2[key])
+              next unless val && (file = dep1[key] || dep2[key]) && file != '*'
 
               latest = val['latest']
               ch = file[0]
@@ -238,18 +268,18 @@ module Squared
                 avail << [key, file, latest, true]
                 next
               end
-              want = rev == :major && latest.match(SEM_VER) && !Regexp.last_match(6) ? latest : val['wanted']
+              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(file.scan(SEM_VER)).first
-              w = semver(want.scan(SEM_VER)).first
+              f = semver(semscan(file))
+              w = semver(semscan(want))
               a = f[0]
               b = f[2]
               c = w[0]
               d = w[2]
               case rev
               when :major
-                upgrade = a == '0' ? c == '0' : true
+                upgrade = a == '0' ? c == '0' || c == '1' : true
               when :minor
                 upgrade = ch == '^' && (a == '0' ? c == '0' && b == d : a == c)
               when :patch
@@ -294,7 +324,7 @@ module Squared
             col2 = size_col.(found, 1) + 4
             found.each_with_index do |item, i|
               a, b, c, d, e = item
-              if inter && (rev != :major || e || semmajor(item[5], item[6])) && !confirm_outdated(a, c, d)
+              if inter && (rev != :major || e || semmajor?(item[5], item[6])) && !confirm_outdated(a, c, d, e)
                 cur = -1
               else
                 cur = modified
@@ -326,10 +356,10 @@ module Squared
             if dryrun || (modified == 0 && pending > 0)
               footer.(modified)
             elsif modified > 0
-              File.write(package, doc)
+              File.write(dependfile, doc)
               modified = -1
               footer.()
-              commit(:add, 'package.json', pass: true)
+              commit(:add, ['package.json'], pass: true)
               install if opts.include?('prune')
             end
           elsif !avail.empty?
@@ -354,12 +384,14 @@ module Squared
           end
         end
 
-        def compose(opts)
+        def compose(opts, flags = nil, script: false)
+          return unless opts && script
+
           ret = session (if yarn?
                            'yarn'
                          else
                            pnpm? ? 'pnpm' : 'npm'
-                         end), 'run'
+                         end), 'run', flags
           append_loglevel
           case opts
           when ::Enumerable
@@ -372,11 +404,66 @@ module Squared
           ret
         end
 
-        def install_type(prog = nil)
-          prog ||= yarn? ? :yarn : :pnpm
-          key = :"#{prog}?"
-          __send__(key) if respond_to?(key)
-          @pm[prog] || 0
+        def bump(flag)
+          return unless (ver = version)
+
+          seg = semscan(ver)
+          case flag
+          when :major
+            if seg[0] != '0' || seg[2].nil?
+              seg[0] = seg[0].succ
+            else
+              seg[2] = seg[2].succ
+            end
+          when :minor
+            if seg[0] == '0'
+              seg[4] &&= seg[4].succ
+            else
+              seg[2] = seg[2].succ
+            end
+          when :patch
+            seg[4] &&= seg[4].succ
+          end
+          unless (out = seg.join) == ver
+            begin
+              doc = dependfile.read
+              if doc.sub!(/"version"\s*:\s*"#{ver}"/, "\"version\": \"#{out}\"")
+                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
+            end
+          end
+        end
+
+        def version
+          read_packagemanager
+          @pm[:version]
+        end
+
+        def dependtype(prog)
+          return @pm[prog] if @pm.key?(prog)
+
+          meth = :"#{prog}?"
+          respond_to?(meth) && __send__(meth) ? @pm[prog] : 0
+        end
+
+        def depend?
+          @depend != false && (!@depend.nil? || outdated?)
         end
 
         def copy?
@@ -384,12 +471,12 @@ module Squared
         end
 
         def outdated?
-          package.exist?
+          dependfile.exist?
         end
 
         def yarn?
-          (@pm[:yarn] ||= if base_path('yarn.lock').exist?
-                            if (rc = base_path('.yarnrc.yml')).exist?
+          (@pm[:yarn] ||= if basepath('yarn.lock', ascend: find_package).exist?
+                            if (rc = basepath('.yarnrc.yml', ascend: find_package)).exist?
                               begin
                                 require 'yaml'
                                 doc = YAML.load_file(rc)
@@ -408,10 +495,10 @@ module Squared
         end
 
         def pnpm?
-          (@pm[:pnpm] ||= if base_path('pnpm-lock.yaml').exist?
+          (@pm[:pnpm] ||= if basepath('pnpm-lock.yaml', ascend: find_package).exist?
                             begin
                               require 'yaml'
-                              doc = YAML.load_file(base_path('node_modules/.modules.yaml'))
+                              doc = YAML.load_file(basepath('node_modules/.modules.yaml', ascend: find_package))
                               @pm[:_] = doc['packageManager']
                               case doc['nodeLinker']
                               when 'hoisted'
@@ -429,6 +516,15 @@ module Squared
                           end) > 0
         end
 
+        def workspaces?
+          if pnpm?
+            basepath('pnpm-workspace.yaml').exist?
+          else
+            read_packagemanager
+            @pm[:workspaces].is_a?(::Array)
+          end
+        end
+
         def dev?
           !Node.prod? && super
         end
@@ -439,13 +535,41 @@ module Squared
 
         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[:scripts] = doc['scripts']
+            @pm[:version] = doc['version']
+            @pm[:workspaces] = doc['workspaces']
+          end
+        rescue StandardError => e
+          log.debug e if dependfile.exist?
+          @pm[:_] = false
+          nil
+        else
+          !(ret = @pm[:_]) || (version && ret[ret.index('@') + 1..-1] < version) ? nil : ret
+        end
+
+        def read_install
+          return unless (ret = env('NODE_INSTALL'))
+
+          @pm[:_] ||= ret if ret.include?('@')
+          ret
+        end
+
+        def read_scripts
+          read_packagemanager
+          @pm[:scripts].is_a?(::Hash) ? @pm[:scripts].to_a : []
+        end
+
         def append_loglevel
           level = env('NODE_LOGLEVEL')
           silent = !verbose || level == 'silent'
           return unless silent || level
 
           if yarn?
-            if install_type(:yarn) == 1
+            if dependtype(:yarn) == 1
               if silent
                 @session << '--silent'
               elsif level == 'verbose'
@@ -471,43 +595,27 @@ module Squared
           end
         end
 
-        def confirm_outdated(pkg, ver, rev)
-          rev = case rev
-                when 1
-                  'MAJOR'
-                when 3
-                  'MINOR'
-                else
-                  'PATCH'
-                end
-          a = sub_style(rev, styles: theme[:header])
+        def confirm_outdated(pkg, ver, rev, lock)
+          a = sub_style(case rev
+                        when 1
+                          'MAJOR'
+                        when 3
+                          'MINOR'
+                        else
+                          'PATCH'
+                        end, styles: theme[:header])
           b = sub_style("#{pkg} #{ver}", styles: theme[:inline])
-          c, d = rev == 'MAJOR' ? ['y/N', 'N'] : ['Y/n', 'Y']
-          confirm("Upgrade to #{a}? #{b} [#{c}] ", d, timeout: 60)
-        end
-
-        def read_packagemanager(ver: nil)
-          if @pm[:_].nil?
-            doc = JSON.parse(package.read)
-            @pm[:_] = (val = doc['packageManager']) ? val[0..(val.index('+') || 0) - 1] : false
-          end
-        rescue StandardError => e
-          log.warn e if package.exist?
-          @pm[:_] = false
-          nil
-        else
-          return unless @pm[:_]
-
-          ver ? @pm[:_][@pm[:_].index('@') + 1..-1] >= ver : @pm[:_]
+          c, d = rev == 1 || lock ? %w[y/N N] : %w[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 read_install
-          return unless (ret = env('NODE_INSTALL'))
-
-          @pm[:_] ||= ret if ret.include?('@')
-          ret
+        def find_package
+          'package.json' if parent&.has?('outdated', Node.ref)
         end
       end
+
+      Application.implement Node
     end
   end
 end