pindo 5.13.7 → 5.13.10

data/lib/pindo/module/unity/unity_proc_helper.rb

@@ -0,0 +1,390 @@
+module Pindo
+  module Unity
+    # Unity 进程管理助手
+    # 负责 Unity 进程的检测、管理和清理
+    # 所有方法均为类方法，无需实例化
+    class UnityProcHelper
+
+      # 构建前检查 Unity 进程（交互式）
+      # @param unity_exe_full_path [String] Unity 可执行文件路径
+      # @param project_path [String] Unity 项目路径
+      def self.check_unity_processes(unity_exe_full_path: nil, project_path: nil)
+        # 如果没有提供路径参数，直接跳过Unity进程检查
+        if unity_exe_full_path.nil? && project_path.nil?
+          return
+        end
+
+        # 检查是否有Unity进程在运行
+        unity_processes = `ps aux | grep -i unity | grep -v grep`.strip
+
+        if !unity_processes.empty?
+          # 解析Unity进程信息，传入Unity路径和项目路径进行精确匹配
+          unity_pids = parse_unity_processes(unity_processes, unity_exe_full_path: unity_exe_full_path, project_path: project_path)
+
+          # 过滤掉僵尸进程和无效进程
+          unity_pids = filter_valid_unity_processes(unity_pids)
+
+          if unity_pids.any?
+            puts "⚠️  检测到与当前项目相关的 Unity 进程正在运行："
+            # 只显示真正的Unity进程，不显示 pindo 相关进程
+            unity_pids.each_with_index do |process_info, index|
+              puts "  #{index + 1}. PID: #{process_info[:pid]}, 命令: #{process_info[:command]}"
+            end
+            puts ""
+
+            # 询问用户是否要自动关闭Unity进程
+            loop do
+              puts "批处理模式需要关闭这些 Unity 进程以避免冲突"
+              puts "  [y] 是, 自动关闭所有 Unity 进程"
+              puts "  [s] 跳过, 我已经手动关闭 Unity 进程，继续构建（可能导致冲突）"
+              puts "  [e] 退出编译"
+              print "请输入选择 (y/s/e): "
+
+              input = STDIN.gets
+              choice = input ? input.chomp.strip.downcase : ""
+
+              case choice
+              when 'y', 'yes', '1'
+                puts "\n正在关闭 Unity 相关进程..."
+                success_count = 0
+                unity_pids.each do |process_info|
+                  if kill_unity_process(process_info[:pid])
+                    puts "✅ 成功关闭进程 #{process_info[:pid]}"
+                    success_count += 1
+                  else
+                    puts "❌ 关闭进程 #{process_info[:pid]} 失败"
+                  end
+                end
+
+                if success_count > 0
+                  puts "\n✅ 已关闭 #{success_count} 个 Unity 相关进程"
+                  puts "等待3秒后继续编译..."
+                  sleep(3)
+                else
+                  puts "\n❌ 无法关闭 Unity 相关进程，请手动关闭后重试"
+                  raise "Unity进程冲突：无法自动关闭 Unity 相关进程，请手动关闭后重试"
+                end
+                break  # 退出循环
+
+              when 's', 'skip', '2'
+                puts "\n✅ 跳过检查，继续编译..."
+                puts "假设Unity Editor已经手动关闭，如果仍在运行可能导致编译失败"
+                sleep(1)
+                break  # 退出循环
+
+              when 'e', 'exit', '3'
+                puts "\n⚠️  用户选择退出编译"
+                puts "退出Unity编译流程"
+                exit 0
+
+              else
+                puts "\n⚠️ 无效选择: '#{choice}'"
+                puts "请输入 y (是), s (跳过), 或 e (退出)\n\n"
+                # 继续循环，让用户重新输入
+              end
+            end
+          else
+            # 没有检测到与当前项目相关的Unity进程，静默继续
+          end
+        end
+      end
+
+      # 构建完成后清理 Unity 进程残留（自动）
+      # @param unity_exe_full_path [String] Unity 可执行文件路径
+      # @param project_path [String] Unity 项目路径
+      def self.cleanup_unity_processes_after_build(unity_exe_full_path: nil, project_path: nil)
+        begin
+          # 等待一小段时间让 Unity 进程自然退出
+          sleep(2)
+
+          # 如果没有提供路径参数，不清理进程
+          if unity_exe_full_path.nil? && project_path.nil?
+            return
+          end
+
+          # 检查是否还有 Unity 进程在运行
+          unity_processes = `ps aux | grep -i unity | grep -v grep`.strip
+
+          if !unity_processes.empty?
+            # 解析进程信息，传入Unity路径和项目路径进行精确匹配
+            unity_pids = parse_unity_processes(unity_processes, unity_exe_full_path: unity_exe_full_path, project_path: project_path)
+
+            if unity_pids.any?
+              puts "\e[33m检测到构建后仍有项目相关的 Unity 进程残留，正在清理...\e[0m"
+              # 自动清理残留的 Unity 进程
+              cleaned_count = 0
+              unity_pids.each do |process_info|
+                if kill_unity_process(process_info[:pid])
+                  cleaned_count += 1
+                end
+              end
+
+              if cleaned_count > 0
+                puts "\e[32m✅ 已清理 #{cleaned_count} 个 Unity 相关进程残留\e[0m"
+              end
+            end
+          end
+        rescue => e
+          # 清理失败不影响主流程
+          # 静默处理，不输出错误信息
+        end
+      end
+
+      # 解析 Unity 进程信息
+      # @param processes_output [String] ps 命令输出
+      # @param unity_exe_full_path [String] Unity 可执行文件路径
+      # @param project_path [String] Unity 项目路径
+      # @return [Array<Hash>] 进程信息数组
+      def self.parse_unity_processes(processes_output, unity_exe_full_path: nil, project_path: nil)
+        processes = []
+
+        processes_output.lines.each do |line|
+          # 解析 ps aux 输出格式
+          parts = line.strip.split(/\s+/)
+          if parts.length >= 11
+            pid = parts[1]
+            command = parts[10..-1].join(' ')
+
+            # 过滤掉grep进程本身和pindo进程
+            unless command.include?('grep') || command.include?('pindo')
+              # 精确匹配Unity进程
+              is_relevant_unity_process = false
+              match_reasons = []
+
+              # 1. 必须是Unity Editor主进程（排除VS Code等其他进程）
+              is_unity_editor = command.match?(/Unity\.app.*\/Unity/i) || command.match?(/Unity\.exe/i)
+
+              if is_unity_editor
+                # 2. 检查是否是打开了指定项目的Unity进程
+                # Unity 使用 -projectpath 参数指定项目路径
+                if project_path
+                  # 标准化路径以确保匹配
+                  normalized_project_path = File.expand_path(project_path)
+                  # 精确匹配项目路径（必须完全匹配，不能只是包含）
+                  if command.match?(/-projectpath\s+#{Regexp.escape(normalized_project_path)}(\s|$)/i)
+                    # 只有当项目路径完全匹配时才认为是相关进程
+                    is_relevant_unity_process = true
+                    match_reasons << "Unity Editor打开了当前项目"
+
+                    # 如果还指定了Unity路径，也要验证
+                    if unity_exe_full_path
+                      if command.include?(unity_exe_full_path)
+                        match_reasons << "使用指定的Unity版本"
+                      else
+                        # Unity路径不匹配，不是我们要的进程
+                        is_relevant_unity_process = false
+                        match_reasons.clear
+                      end
+                    end
+                  end
+                elsif unity_exe_full_path && command.include?(unity_exe_full_path)
+                  # 只提供了Unity路径，没有项目路径时才匹配
+                  # 这种情况下匹配所有使用该Unity版本的进程
+                  is_relevant_unity_process = true
+                  match_reasons << "使用指定的Unity版本"
+                end
+              end
+
+              # 3. 如果没有提供路径参数，不匹配任何进程（由上层函数处理）
+
+              if is_relevant_unity_process
+                processes << { pid: pid, command: command }
+              end
+            end
+          end
+        end
+        processes
+      end
+
+      # 过滤掉僵尸进程和无效进程
+      # @param processes [Array<Hash>] 进程信息数组
+      # @return [Array<Hash>] 有效进程数组
+      def self.filter_valid_unity_processes(processes)
+        valid_processes = []
+
+        processes.each do |process_info|
+          # PID 可能是字符串，确保正确处理
+          pid = process_info[:pid]
+          pid_int = pid.to_i
+
+          # 检查进程是否真的存在且活跃
+          if process_exists_and_active?(pid_int)
+            valid_processes << process_info
+          end
+        end
+
+        valid_processes
+      end
+
+      # 检查进程是否真的存在且活跃
+      # @param pid [Integer] 进程 ID
+      # @return [Boolean] true 如果进程存在且活跃
+      def self.process_exists_and_active?(pid)
+        begin
+          # 使用更简单可靠的方式检查进程
+          # 尝试发送信号0来检查进程是否存在
+          Process.kill(0, pid)
+
+          # 如果需要检查进程状态，使用不同的命令格式
+          # -o pid=,stat= 去掉标题行
+          process_info = `ps -p #{pid} -o pid=,stat= 2>/dev/null`.strip
+
+          if process_info.empty?
+            return false
+          end
+
+          # 解析进程状态
+          parts = process_info.split(/\s+/)
+          if parts.length >= 2
+            stat = parts[1]
+            # Z = 僵尸进程, T = 停止进程
+            # 只过滤僵尸进程，不过滤停止进程（T可能是正常的暂停状态）
+            if stat.include?('Z')
+              puts "        进程 #{pid} 是僵尸进程，过滤掉"
+              return false
+            end
+          end
+
+          true
+        rescue Errno::ESRCH
+          # 进程不存在
+          false
+        rescue Errno::EPERM
+          # 权限不足，但进程存在
+          true
+        rescue => e
+          puts "检查进程 #{pid} 时出错: #{e.message}"
+          # 如果出错，假设进程存在（保守处理）
+          true
+        end
+      end
+
+      # 关闭 Unity 进程
+      # @param pid [String, Integer] 进程 ID
+      # @return [Boolean] true 如果成功关闭
+      def self.kill_unity_process(pid)
+        begin
+          pid_int = pid.to_i
+
+          # 安全检查：确保不是当前进程
+          if pid_int == Process.pid
+            puts "⚠️  跳过当前进程 #{pid}"
+            return true
+          end
+
+          # 检查进程是否存在
+          unless process_exists?(pid_int)
+            puts "进程 #{pid} 已不存在"
+            return true
+          end
+
+          # 获取进程信息进行额外验证
+          process_info = get_process_info(pid_int)
+          if process_info && !process_info.include?('Unity')
+            puts "⚠️  跳过非Unity进程 #{pid}: #{process_info}"
+            return true
+          end
+
+          puts "正在关闭Unity进程 #{pid}..."
+
+          # 先尝试优雅关闭
+          begin
+            Process.kill('TERM', pid_int)
+            puts "已发送TERM信号给进程 #{pid}"
+          rescue Errno::EPERM
+            puts "❌ 没有权限关闭进程 #{pid}，尝试使用sudo"
+            return kill_unity_process_with_sudo(pid)
+          rescue Errno::ESRCH
+            puts "进程 #{pid} 已不存在"
+            return true
+          end
+
+          # 等待进程优雅退出
+          sleep(3)
+
+          # 检查进程是否还存在
+          if process_exists?(pid_int)
+            puts "进程 #{pid} 未响应TERM信号，尝试强制关闭..."
+            begin
+              Process.kill('KILL', pid_int)
+              puts "已发送KILL信号给进程 #{pid}"
+              sleep(2)
+            rescue Errno::EPERM
+              puts "❌ 没有权限强制关闭进程 #{pid}"
+              return false
+            rescue Errno::ESRCH
+              puts "进程 #{pid} 已不存在"
+              return true
+            end
+          end
+
+          # 最终检查
+          if process_exists?(pid_int)
+            puts "❌ 无法关闭进程 #{pid}"
+            false
+          else
+            puts "✅ 成功关闭进程 #{pid}"
+            true
+          end
+
+        rescue => e
+          puts "❌ 关闭进程 #{pid} 时出错: #{e.message}"
+          puts "错误类型: #{e.class}"
+          false
+        end
+      end
+
+      # 使用 sudo 关闭进程
+      # @param pid [String, Integer] 进程 ID
+      # @return [Boolean] true 如果成功关闭
+      def self.kill_unity_process_with_sudo(pid)
+        begin
+          puts "尝试使用sudo关闭进程 #{pid}..."
+          result = system("sudo kill -TERM #{pid}")
+          if result
+            sleep(3)
+            if process_exists?(pid.to_i)
+              puts "TERM信号无效，尝试KILL信号..."
+              system("sudo kill -KILL #{pid}")
+              sleep(2)
+            end
+            !process_exists?(pid.to_i)
+          else
+            puts "❌ sudo命令执行失败"
+            false
+          end
+        rescue => e
+          puts "❌ sudo关闭进程时出错: #{e.message}"
+          false
+        end
+      end
+
+      # 获取进程信息
+      # @param pid [Integer] 进程 ID
+      # @return [String, nil] 进程命令名称
+      def self.get_process_info(pid)
+        begin
+          `ps -p #{pid} -o comm=`.strip
+        rescue => e
+          nil
+        end
+      end
+
+      # 检查进程是否存在
+      # @param pid [Integer] 进程 ID
+      # @return [Boolean] true 如果进程存在
+      def self.process_exists?(pid)
+        begin
+          Process.kill(0, pid)
+          true
+        rescue Errno::ESRCH
+          false
+        rescue Errno::EPERM
+          # 权限不足，但进程存在
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/pindo/options/core/global_options_state.rb

@@ -11,6 +11,14 @@ module Pindo
     class GlobalOptionsState
       include Singleton
 
+      # 所有已知的 OptionGroup 模块（用于查找参数显示名称）
+      OPTION_GROUPS = [
+        -> { Pindo::Options::BuildOptions },
+        -> { Pindo::Options::JPSOptions },
+        -> { Pindo::Options::UnityOptions },
+        -> { Pindo::Options::GitOptions }
+      ].freeze
+
       def initialize
         # 运行时状态（内存）
         @current_command = nil        # 当前命令名称
@@ -40,10 +48,23 @@ module Pindo
       end
 
       # 加载缓存的参数值（带用户确认）
+      # 环境变量 PINDO_OPTIONS_CACHE 控制缓存行为：
+      #   - 1/true/force: 强制使用缓存，不询问用户
+      #   - 0/false/disable: 禁用缓存，不询问用户
+      #   - 其他/不设置: 默认行为，询问用户
       # @return [Hash] 缓存的参数值
       def load_cached_values
         return {} unless @current_directory && @current_command
 
+        # 检查缓存控制环境变量
+        cache_mode = ENV['PINDO_OPTIONS_CACHE']&.downcase
+
+        # 禁用缓存模式: 0, false, disable
+        if %w[0 false disable].include?(cache_mode)
+          log_verbose("PINDO_OPTIONS_CACHE=#{cache_mode}，跳过缓存")
+          return {}
+        end
+
         cached_params = @cache_data.dig(@current_directory.to_sym, @current_command.to_sym)
 
         # 没有缓存数据，直接返回空Hash
@@ -52,17 +73,14 @@ module Pindo
           return {}
         end
 
-        # 检查环境变量是否强制使用缓存
-        force_build = ENV['PINDO_FORCE_BUILD']
-
-        if force_build && !force_build.empty?
-          # 自动使用缓存
-          puts "\n检测到 PINDO_FORCE_BUILD 环境变量，自动使用缓存的参数"
+        # 强制使用缓存模式: 1, true, force
+        if %w[1 true force].include?(cache_mode)
+          puts "\n自动使用缓存的参数 (PINDO_OPTIONS_CACHE=#{cache_mode})"
           log_verbose("加载缓存参数: #{cached_params.inspect}")
           return cached_params
         end
 
-        # 显示缓存的参数
+        # 默认模式：显示缓存的参数并询问用户
         display_cached_params(cached_params)
 
         # 询问用户是否使用缓存
@@ -82,6 +100,20 @@ module Pindo
         end
       end
 
+      # 参数显示顺序（优先级从高到低）
+      PARAM_DISPLAY_ORDER = [
+        # 1. 核心标识参数
+        :bundleid, :bundle_id, :bundle_name,
+        # 2. 构建配置
+        :build_type, :scheme,
+        # 3. JPS 相关
+        :proj, :upload, :send, :desc,
+        # 4. Unity 相关
+        :skipconfig, :skiplib, :skipyoo,
+        # 5. Git 相关
+        :ver_inc, :tag_type, :tag_pre, :release_branch
+      ].freeze
+
       # 显示缓存的参数
       def display_cached_params(cached_params)
         # 根据命令名显示友好的描述
@@ -99,10 +131,18 @@ module Pindo
         puts "\n检测到之前的参数 (#{group_desc}):"
         puts "────────────────────────────────────────"
 
-        cached_params.each do |key, value|
+        # 按照预定义顺序排序参数
+        sorted_keys = cached_params.keys.sort_by do |key|
+          order_index = PARAM_DISPLAY_ORDER.index(key.to_sym)
+          order_index || PARAM_DISPLAY_ORDER.size  # 未定义的参数排在最后
+        end
+
+        sorted_keys.each do |key|
+          value = cached_params[key]
           # 跳过内部字段
           next if key.to_s.start_with?('__')
           next if value.nil?
+          next unless is_cacheable?(key)  # 跳过不可缓存的参数
 
           # 格式化显示参数
           key_name = format_param_name(key)
@@ -112,24 +152,28 @@ module Pindo
         puts "────────────────────────────────────────"
       end
 
-      # 格式化参数名称
+      # 格式化参数名称（从 OptionItem 定义中查找显示名称）
+      # @param key [Symbol, String] 参数键名
+      # @return [String] 显示名称
       def format_param_name(key)
-        case key.to_s
-        when 'bundleid', 'bundle_id'
-          'Bundle ID'
-        when 'build_type'
-          '构建类型'
-        when 'upload'
-          '上传JPS'
-        when 'send'
-          '发送通知'
-        when 'proj', 'project_name'
-          '项目名称'
-        when 'scheme'
-          'Scheme'
-        else
-          key.to_s
+        key_sym = key.to_sym
+
+        # 遍历所有已知的 OptionGroup，查找匹配的 OptionItem
+        OPTION_GROUPS.each do |group_proc|
+          begin
+            group = group_proc.call
+            if group.respond_to?(:all_options)
+              option_item = group.all_options[key_sym]
+              return option_item.display_name if option_item
+            end
+          rescue NameError
+            # 模块尚未加载，跳过
+            next
+          end
         end
+
+        # 如果没有找到匹配的 OptionItem，返回 key 本身
+        key.to_s
       end
 
       # 清除当前命令的缓存
@@ -235,10 +279,12 @@ module Pindo
         # 确保缓存数据结构存在
         @cache_data[@current_directory.to_sym] ||= {}
 
-        # 提取当前参数值（排除 nil 值）
+        # 提取当前参数值（排除 nil 值和不可缓存的参数）
         current_params = {}
         @current_options.instance_variable_get(:@values).each do |key, value|
-          current_params[key] = value unless value.nil?
+          next if value.nil?
+          next unless is_cacheable?(key)  # 过滤不可缓存的参数
+          current_params[key] = value
         end
 
         # 保存到缓存
@@ -248,6 +294,30 @@ module Pindo
         save_cache_to_file_immediate
       end
 
+      # 判断参数是否可缓存
+      # @param key [Symbol, String] 参数键名
+      # @return [Boolean] 是否可缓存
+      def is_cacheable?(key)
+        key_sym = key.to_sym
+
+        # 遍历所有已知的 OptionGroup，查找匹配的 OptionItem
+        OPTION_GROUPS.each do |group_proc|
+          begin
+            group = group_proc.call
+            if group.respond_to?(:all_options)
+              option_item = group.all_options[key_sym]
+              return option_item.cacheable? if option_item
+            end
+          rescue NameError
+            # 模块尚未加载，跳过
+            next
+          end
+        end
+
+        # 如果没有找到匹配的 OptionItem，默认可缓存
+        true
+      end
+
       # 立即保存缓存数据到文件（内部方法）
       def save_cache_to_file_immediate
         begin

data/lib/pindo/options/core/option_configuration.rb

@@ -133,6 +133,9 @@ module Pindo
       # 应用 value_block（交互式获取值）
       # 优先级：命令行参数 > 缓存（已在 raw_values） > value_block > 默认值
       def apply_value_blocks
+        # 检测是否是 help 请求，跳过交互式选择
+        return if ARGV.include?('--help') || ARGV.include?('-h')
+
         @available_options.each do |item|
           # 只有当参数没有值时，才调用 value_block
           next if @values.key?(item.key) && !@values[item.key].nil?

data/lib/pindo/options/core/option_item.rb

@@ -5,12 +5,14 @@ module Pindo
 
       # 核心属性
       attr_accessor :key              # Symbol: 参数键名
+      attr_accessor :name             # String: 显示名称（用于缓存确认等场景）
       attr_accessor :description      # String: 参数描述
       attr_accessor :type             # Class: 数据类型 (String/Integer/Boolean)
       attr_accessor :env_name         # String: 环境变量名
       attr_accessor :aliases          # Array<Symbol>: 参数别名
       attr_accessor :default_value    # Any: 默认值
       attr_accessor :optional         # Boolean: 是否可选（默认为 true）
+      attr_accessor :cacheable        # Boolean: 是否存入缓存（默认为 true）
       attr_accessor :verify_block     # Proc: 自定义验证逻辑
       attr_accessor :value_block      # Proc: 获取参数值的 block（交互式输入）
       attr_accessor :example          # String: 使用示例
@@ -25,12 +27,14 @@ module Pindo
         raise ArgumentError, "key must be a Symbol" unless key.is_a?(Symbol)
 
         @key = key
+        @name = options[:name]  # 显示名称，如果未设置则使用 key
         @description = options[:description] || options[:desc] || ""
         @type = options[:type] || String
         @env_name = options[:env_name]
         @aliases = options[:aliases] || []
         @default_value = options[:default_value] || options[:default]
         @optional = options.fetch(:optional, true)
+        @cacheable = options.fetch(:cacheable, false)  # 默认不存入缓存
         @verify_block = options[:verify_block]
         @value_block = options[:value_block]
         @example = options[:example]
@@ -38,11 +42,21 @@ module Pindo
         validate_type!
       end
 
+      # 获取显示名称（优先使用 name，否则使用 key）
+      def display_name
+        @name || @key.to_s
+      end
+
       # 判断是否是 Boolean 类型
       def boolean?
         @type == Boolean || @type == :boolean
       end
 
+      # 判断是否需要存入缓存
+      def cacheable?
+        @cacheable
+      end
+
       # 从环境变量读取值
       # @return [String, nil] 环境变量的值
       def fetch_env_value
@@ -98,6 +112,28 @@ module Pindo
         [option_string, description_text]
       end
 
+      # 复制当前 OptionItem 并覆盖指定属性
+      # @param overrides [Hash] 要覆盖的属性
+      # @return [OptionItem] 新的 OptionItem 实例
+      # @example
+      #   UnityOptions.select(:skipconfig).first.with(default_value: true)
+      def with(**overrides)
+        OptionItem.new(
+          key: overrides[:key] || @key,
+          name: overrides[:name] || @name,
+          description: overrides[:description] || @description,
+          type: overrides[:type] || @type,
+          env_name: overrides[:env_name] || @env_name,
+          aliases: overrides[:aliases] || @aliases,
+          default_value: overrides.key?(:default_value) ? overrides[:default_value] : @default_value,
+          optional: overrides.key?(:optional) ? overrides[:optional] : @optional,
+          cacheable: overrides.key?(:cacheable) ? overrides[:cacheable] : @cacheable,
+          verify_block: overrides[:verify_block] || @verify_block,
+          value_block: overrides[:value_block] || @value_block,
+          example: overrides[:example] || @example
+        )
+      end
+
       private
 
       # 验证类型是否合法