squared 0.0.12 → 0.1.0

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

@@ -9,32 +9,31 @@ module Squared
         private_constant :OPT_PULL, :OPT_FETCH
 
         class << self
-          include ::Rake::DSL
+          include Rake::DSL
 
           def populate(ws, **)
             return if ws.series[:pull].empty?
 
-            name = ws.task_name('all')
-            desc ws.task_name('all[git?=rebase|stash]', desc: true)
-            task name, [:git] do |_, args|
-              sync = lambda do |key|
-                key = ws.task_name(key)
-                ws.task_defined?(ret = ws.task_join(key, 'sync')) ? ret : key
+            namespace(name = ws.task_name('git')) do
+              all = ws.task_join(name, 'all')
+
+              desc ws.task_name("#{all}[git?=rebase|stash,depend?]", desc: true)
+              task 'all', [:git, :depend] do |_, args|
+                cmd = case args.git
+                      when 'rebase'
+                        [ws.task_sync('rebase')]
+                      when 'stash'
+                        [ws.task_sync('stash'), ws.task_sync('pull')]
+                      else
+                        [ws.task_sync('pull')]
+                      end
+                cmd << ws.task_sync('depend') if args.depend && !ws.series[:depend].empty?
+                cmd << ws.task_sync('build')
+                Common::Utils.task_invoke(*cmd, **ws.invokeargs)
               end
-              cmd = [case args.git
-                     when 'rebase'
-                       sync.('rebase')
-                     when 'stash'
-                       invoke(sync.('stash'), **ws.invokeargs)
-                       sync.('pull')
-                     else
-                       sync.('pull')
-                     end]
-              cmd << ws.task_name('build')
-              Common::Utils.task_invoke(*cmd, **ws.invokeargs)
+              ws.series.sync << all
+              ws.series.multiple << all
             end
-            ws.series.sync << name
-            ws.series.multiple << name
           end
 
           def tasks
@@ -63,7 +62,8 @@ module Squared
           refs: %i[heads tags].freeze,
           reset: %i[head soft mixed hard merge keep submodules].freeze,
           restore: %i[worktree staged overlay].freeze,
-          rev: %i[commit branch].freeze
+          rev: %i[commit branch].freeze,
+          show: %i[oneline pretty format].freeze
         }.freeze
 
         def initialize(*, **)
@@ -200,6 +200,21 @@ module Squared
                         reset(flag, ref: args.ref)
                       end
                     end
+                  when :show
+                    if flag == :oneline
+                      desc format_desc(action, flag, 'object+')
+                      task flag, [:object] do |_, args|
+                        objs = guard_params(action, flag, args: args.to_a)
+                        show(objs, pretty: 'oneline', abbrev: true)
+                      end
+                    else
+                      desc format_desc(action, flag, 'format,object+')
+                      task flag, [:format, :object] do |_, args|
+                        format = guard_params(action, flag, args: args, key: :format)
+                        objs = guard_params(action, flag, args: args.to_a[1..-1] || [])
+                        show(objs, "#{flag}": format)
+                      end
+                    end
                   end
                 end
               end
@@ -220,7 +235,13 @@ module Squared
             cmd << '--commit'
           end
           append_pull opts, OPT_PULL, flag
-          source(sync: sync, **threadargs)
+          sub = if verbose
+                  [
+                    { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: :red, index: 4 },
+                    { pat: /^(.+)(\|\s+\d+\s+)(\++)(-*)(.*)$/, styles: :green, index: 3 }
+                  ]
+                end
+          source(sync: sync, sub: sub, **threadargs)
         end
 
         def rebase
@@ -399,17 +420,17 @@ module Squared
                        raise_error('commit', 'pathspec', hint: 'missing') if (files = projectmap(files)).empty?
                        "-- #{files.join(' ')}"
                      end
-          unless push?
-            source('git branch -vv --list', io: true, banner: false).first.each do |val|
-              origin = %r{^\* [^\[]+(?<= )\[([\w.-/]+?)/([\w.-]+)\] }.match(val)
-              next unless origin
-
-              @origin = origin[1]
-              @branch = origin[2]
-              break
-            end
+          origin = nil
+          branch = nil
+          source('git fetch --no-tags --quiet', io: true, banner: false)
+          source('git branch -vv --list', io: true, banner: false).first.each do |val|
+            next unless (data = %r{^\* [^\[]+(?<= )\[([\w.-/]+?)/([\w.-]+)\] }.match(val))
+
+            origin = data[1]
+            branch = data[2]
+            break
           end
-          raise_error('commit', 'work tree is not usable') unless push?
+          raise_error('commit', 'work tree is not usable') unless origin && branch
           cmd = git_session 'commit'
           cmd << '--dry-run' if option('dry-run')
           if amend
@@ -433,7 +454,7 @@ module Squared
           b << @origin << @branch
           puts if pass
           source a.join(' ')
-          source
+          source cmd
           source b.join(' ')
         end
 
@@ -444,9 +465,31 @@ module Squared
           source(stdout: true)
         end
 
+        def show(objs, pretty: nil, format: nil, abbrev: nil)
+          cmd = git_session 'show'
+          case (flag = pretty&.downcase)
+          when 'oneline', 'short', 'medium', 'full', 'fuller', 'reference', 'email', 'raw'
+            cmd << "--pretty=#{flag}"
+          else
+            if pretty
+              cmd << "--pretty=#{shell_escape("tformat:#{pretty}", quote: true)}"
+            elsif format
+              cmd << "--format=#{shell_escape(format, quote: true)}"
+            end
+          end
+          if (abbrev ||= option('abbrev')) == true
+            cmd << '--abbrev-commit'
+          elsif abbrev.to_i > 0
+            cmd << "--abbrev=#{abbrev}"
+          end
+          append_value objs
+          source(exception: false)
+        end
+
         private
 
-        def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true)
+        def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true,
+                   sub: nil)
           cmd = session_done(cmd)
           log.info cmd
           banner = format_banner(cmd.gsub(File.join(path, ''), ''), banner: banner)
@@ -469,11 +512,12 @@ module Squared
               require 'open3'
               if stderr
                 Open3.popen3(cmd) do |_, out, err|
-                  ret = write_lines(out, banner: banner, pass: true)
+                  ret = write_lines(out, banner: banner, sub: sub, pass: true)
                   if ret == 0
-                    write_lines(err, banner: banner)
+                    ret = write_lines(err, banner: banner)
+                    puts 'Success' if ret == 0 && banner && !stdin?
                   else
-                    write_lines(err, loglevel: ::Logger::DEBUG)
+                    write_lines(err, loglevel: Logger::DEBUG)
                   end
                 end
               else
@@ -484,15 +528,15 @@ module Squared
             log.error e
             raise if exception
 
-            warn log_message(::Logger::WARN, e) if warning?
+            warn log_message(Logger::WARN, e) if warning?
           end
         end
 
         def write_lines(data, banner: nil, loglevel: nil, grep: nil, sub: nil, pass: false)
-          grep = Regexp.new(grep == '*' ? '.+' : grep) if grep.is_a?(::String)
+          grep = Regexp.new(grep == '*' ? '.+' : grep) if grep.is_a?(String)
           sub = nil if stdin?
           ret = 0
-          lines = []
+          out = []
           data.each do |line|
             next if grep && !line.match?(grep)
 
@@ -501,14 +545,14 @@ module Squared
             else
               sub&.each { |h| line = sub_style(line, **h) }
               if banner
-                lines << line
+                out << line
               else
                 puts line
               end
             end
             ret += 1
           end
-          print_item banner, lines if banner && (ret > 0 || !pass)
+          print_item banner, out if banner && (ret > 0 || !pass)
           ret
         end
 
@@ -577,26 +621,18 @@ module Squared
           end
         end
 
-        def append_option(list)
-          list.each { |val| @session << "--#{val}" if option(val) }
-        end
-
         def git_session(*cmd)
           session('git', *cmd)
         end
 
-        def gitpath
-          basepath('.git')
-        end
-
-        def push?
-          !@origin.nil? && !@branch.nil?
-        end
-
         def dry_run?
           @session.include?('--dry-run')
         end
 
+        def gitpath
+          basepath('.git')
+        end
+
         def threadargs
           { stderr: true, exception: exception || !workspace.series.multiple? }
         end

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

@@ -74,7 +74,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])
@@ -117,52 +117,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]
+            pass = @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]
+              pass = 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.warn 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: pass, verbose: verbose)
+            end
           end
         end
 
@@ -233,10 +266,10 @@ module Squared
           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' : ''}")
@@ -255,7 +288,7 @@ module Squared
           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'] == json['name'] } if val.is_a?(Array)
               next unless val && (file = dep1[key] || dep2[key]) && file != '*'
 
               latest = val['latest']
@@ -271,8 +304,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 +389,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 +417,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, sync: invoked_sync?('bump', flag))
           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 +434,51 @@ 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 sync
           end
         end
 
-        def version
-          read_packagemanager
-          @pm[:version]
-        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 +486,7 @@ module Squared
         end
 
         def copy?
-          super || @copy.is_a?(::Hash)
+          super || @copy.is_a?(Hash)
         end
 
         def outdated?
@@ -475,8 +494,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 +514,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 +540,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 +597,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 +642,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