pindo 5.13.9 → 5.13.10

data/lib/pindo/module/task/pindo_task.rb

@@ -32,20 +32,23 @@ module Pindo
     # PindoTask 基类（简化版，所有任务在主线程中执行）
     class PindoTask
       attr_accessor :id, :name, :status, :error, :result
-      attr_reader :type, :priority, :dependencies
+      attr_reader :type, :task_key, :priority, :dependencies, :data_dependencies
       attr_accessor :context, :metadata
       attr_reader :created_at, :started_at, :finished_at
       attr_accessor :retry_count  # 剩余重试次数
       attr_reader :retry_mode, :retry_delay, :max_retry_count  # max_retry_count: 初始最大重试次数
       attr_accessor :callbacks_setup  # 标记回调是否已经设置
+      attr_accessor :task_manager  # TaskManager 实例（依赖注入）
 
       def initialize(name, options = {})
         @id = SecureRandom.uuid
         @name = name
         @type = self.class.task_type
+        @task_key = self.class.task_key
         @priority = options[:priority] || TaskPriority::HIGH
         @status = TaskStatus::PENDING
         @dependencies = options[:dependencies] || []
+        @data_dependencies = options[:data_dependencies] || []
         @context = options[:context] || {}
         @metadata = options[:metadata] || {}
         @error = nil
@@ -73,6 +76,10 @@ module Pindo
         raise NotImplementedError, "Subclass must define task_type"
       end
 
+      def self.task_key
+        raise NotImplementedError, "Subclass must define task_key"
+      end
+
       # 默认重试配置
       def self.default_retry_mode
         RetryMode::IMMEDIATE
@@ -135,6 +142,93 @@ module Pindo
         @status == TaskStatus::CANCELLED
       end
 
+      # ========== 依赖任务数据获取 ==========
+
+      # 获取指定依赖任务
+      # @param dep_task_id [String] 依赖任务的 ID
+      # @return [PindoTask, nil] 依赖任务对象，如果不存在返回 nil
+      def get_dependency_task(dep_task_id)
+        return nil unless @task_manager
+        @task_manager.find_task(dep_task_id)
+      end
+
+      # 获取指定依赖任务的结果
+      # @param dep_task_id [String] 依赖任务的 ID
+      # @return [Hash, nil] 依赖任务的 result，如果任务不存在或未完成返回 nil
+      def get_dependency_result(dep_task_id)
+        dep_task = get_dependency_task(dep_task_id)
+        return nil unless dep_task
+        return nil unless dep_task.finished?
+        dep_task.result
+      end
+
+      # 获取所有依赖任务的结果（按依赖顺序）
+      # @return [Hash] key 为任务 ID，value 为任务结果
+      def get_all_dependencies_results
+        results = {}
+        @dependencies.each do |dep_id|
+          results[dep_id] = get_dependency_result(dep_id)
+        end
+        results
+      end
+
+      # ========== 任务数据参数传递 ==========
+
+      # 获取任务的数据参数（用于传递给其他任务）
+      # @return [Hash] 包含任务标识和参数的哈希
+      def data_param
+        {
+          task_id: @id,
+          task_type: @type,
+          task_key: @task_key,
+          task_name: @name,
+          task_param: build_task_param
+        }
+      end
+
+      # 获取指定数据依赖任务的数据参数
+      # @param task_id [String] 任务 ID
+      # @return [Hash, nil] 任务的数据参数，如果任务不存在或未完成返回 nil
+      def get_data_param(task_id)
+        dep_task = get_dependency_task(task_id)
+        return nil unless dep_task
+        return nil unless dep_task.finished? && dep_task.status == TaskStatus::SUCCESS
+        dep_task.data_param
+      end
+
+      # 获取所有数据依赖任务的数据参数
+      # @return [Array<Hash>] 数据参数数组
+      def get_all_data_params
+        @data_dependencies.map { |task_id| get_data_param(task_id) }.compact
+      end
+
+      # 根据 task_key 获取数据依赖任务的数据参数
+      # @param task_key [Symbol] 任务键
+      # @return [Hash, nil] 第一个匹配的任务数据参数
+      def get_data_param_by_key(task_key)
+        @data_dependencies.each do |task_id|
+          param = get_data_param(task_id)
+          return param if param && param[:task_key] == task_key
+        end
+        nil
+      end
+
+      # 获取所有指定 task_key 的数据参数
+      # @param task_key [Symbol] 任务键
+      # @return [Array<Hash>] 匹配的任务数据参数数组
+      def get_all_data_params_by_key(task_key)
+        get_all_data_params.select { |param| param[:task_key] == task_key }
+      end
+
+      # 获取主数据参数（第一个数据依赖任务的参数）
+      # @return [Hash, nil] 主数据参数
+      def primary_data_param
+        return nil if @data_dependencies.empty?
+        get_data_param(@data_dependencies.first)
+      end
+
+      # ========== 回调方法 ==========
+
       # 添加回调
       def on(event, &block)
         @callbacks[event] << block if @callbacks[event]
@@ -167,6 +261,12 @@ module Pindo
         raise NotImplementedError, "Subclass must implement do_work method"
       end
 
+      # 构建任务参数（子类重写以提供自定义参数）
+      # @return [Hash] 任务参数
+      def build_task_param
+        {}  # 默认返回空哈希
+      end
+
       private
 
       # 内部执行逻辑

data/lib/pindo/module/task/task_manager.rb

@@ -108,6 +108,15 @@ module Pindo
         task&.cancel
       end
 
+      # 查找任务（公共方法，供 PindoTask 获取依赖任务使用）
+      # @param task_id [String] 任务 ID
+      # @return [PindoTask, nil] 任务对象
+      def find_task(task_id)
+        all_tasks = @pending_queue + @completed_tasks
+        all_tasks << @current_task if @current_task
+        all_tasks.find { |t| t.id == task_id }
+      end
+
       private
 
       # 获取下一个可执行的任务
@@ -168,6 +177,9 @@ module Pindo
       def execute_task(task)
         @current_task = task
 
+        # 注入 TaskManager 实例（依赖注入）
+        task.task_manager = self
+
         # 设置任务进度回调
         setup_task_callbacks(task)
 
@@ -224,13 +236,6 @@ module Pindo
         Funlog.warning("任务 #{task.name} 因#{reason}而被取消")
       end
 
-      # 查找任务
-      def find_task(task_id)
-        all_tasks = @pending_queue + @completed_tasks
-        all_tasks << @current_task if @current_task
-        all_tasks.find { |t| t.id == task_id }
-      end
-
       # 输出任务执行计划
       def print_execution_plan
         # 按类型分组统计
@@ -242,37 +247,21 @@ module Pindo
         puts "=" * 60
 
         tasks_by_type.each do |type, tasks|
-          type_name = get_type_display_name(type)
-          puts "  #{type_name}: #{tasks.count} 个任务"
+          # 直接从任务类获取显示名称
+          type_name = tasks.first&.class&.task_type_name || type.to_s.capitalize
+          puts "\n  #{type_name}: #{tasks.count} 个任务"
+
+          # 显示该类型下的每个任务名称
+          tasks.each do |task|
+            puts "    - #{task.name}"
+          end
         end
 
-        puts "  总计: #{@pending_queue.count} 个任务"
+        puts "\n  总计: #{@pending_queue.count} 个任务"
         puts "=" * 60 + "\e[0m"
         puts "\n"
       end
 
-      # 获取任务类型的显示名称
-      def get_type_display_name(type)
-        case type
-        when :git_tag
-          "Git仓库打标签"
-        when :unity_config
-          "Unity编译模式配置"
-        when :unity_update
-          "Unity工具库更新"
-        when :unity_yoo_asset
-          "Unity资源Yoo 打包"
-        when :unity_export
-          "Unity导出"
-        when :build
-          "编译构建"
-        when :upload
-          "上传发布"
-        else
-          type.to_s.capitalize
-        end
-      end
-
       # 输出任务执行头部
       def print_task_header(task)
         puts "\n"
@@ -293,6 +282,14 @@ module Pindo
         puts "\n"
         Funlog.error("任务失败: #{task.name}")
         Funlog.error("错误信息: #{error.message}")
+
+        # 打印堆栈信息用于调试（仅在 PINDO_DEBUG 模式下）
+        if ENV['PINDO_DEBUG'] && error.backtrace && !error.backtrace.empty?
+          puts "\n堆栈信息:"
+          error.backtrace.first(10).each do |line|
+            puts "  #{line}"
+          end
+        end
       end
 
       # 输出任务底部分隔线

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

@@ -2,11 +2,11 @@ require 'fileutils'
 require 'json'
 require 'nokogiri'
 require 'open3'
+require 'pindo/base/git_handler'
 
 module Pindo
   module Unity
     class NugetHelper
-      extend Pindo::Githelper
 
       # ============================================
       # ID 格式转换
@@ -535,11 +535,11 @@ module Pindo
         default_message = "feat: 更新版本到 #{nuspec_version}"
 
         # 如果不是 Git 仓库，返回默认消息
-        unless is_git_directory?(local_repo_dir: package_dir)
+        unless Pindo::GitHandler.is_git_directory?(local_repo_dir: package_dir)
           return default_message
         end
 
-        git_root = git_root_directory(local_repo_dir: package_dir)
+        git_root = Pindo::GitHandler.git_root_directory(local_repo_dir: package_dir)
         unless git_root
           return default_message
         end
@@ -551,7 +551,7 @@ module Pindo
           Dir.chdir(git_root)
 
           # 获取所有 tags
-          all_tags = git!(%W(-C #{git_root} tag -l)).split("\n")
+          all_tags = Pindo::GitHandler.git!(%W(-C #{git_root} tag -l)).split("\n")
 
           # 查找匹配当前版本的 tag（不区分大小写，支持 v 前缀）
           matching_tag = all_tags.find do |tag|
@@ -570,7 +570,7 @@ module Pindo
             Dir.chdir(git_root)
 
             # 获取所有 tags 并按版本号排序
-            all_tags = git!(%W(-C #{git_root} tag -l)).split("\n")
+            all_tags = Pindo::GitHandler.git!(%W(-C #{git_root} tag -l)).split("\n")
             sorted_tags = all_tags.sort_by do |tag|
               version_str = tag.gsub(/^(v|V|release[\s_-]*)/i, '')
               version_str.split('.').map(&:to_i)
@@ -598,7 +598,7 @@ module Pindo
             # 获取最新 tag
             latest_tag = nil
             ["v", "V", "release", ""].each do |prefix|
-              latest_tag = get_latest_version_tag(project_dir: git_root, tag_prefix: prefix)
+              latest_tag = Pindo::GitHandler.get_latest_version_tag(project_dir: git_root, tag_prefix: prefix)
               break if latest_tag
             end
 
@@ -615,7 +615,7 @@ module Pindo
 
           # 使用特殊分隔符来区分不同的 commits
           separator = "---COMMIT-SEPARATOR---"
-          commits_raw = git!(%W(-C #{git_root} log #{git_range} --pretty=format:%B#{separator}))
+          commits_raw = Pindo::GitHandler.git!(%W(-C #{git_root} log #{git_range} --pretty=format:%B#{separator}))
 
           # 按分隔符拆分成单个 commits
           commits = commits_raw.split(separator).map(&:strip).reject(&:empty?)

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
 
       # 验证类型是否合法

data/lib/pindo/options/groups/build_options.rb

@@ -11,26 +11,42 @@ module Pindo
       def self.all_options
 
         @all_options ||= {
-          
+
           bundleid: OptionItem.new(
             key: :bundleid,
-            description: '指定打包的 Bundle ID',
+            name: 'Bundle ID',
+            description: '指定 iOS Bundle ID',
             type: String,
             env_name: 'PINDO_BUNDLE_ID',
-            aliases: [:bundle_id, :package_name, :bundle_name],
             optional: true,
+            cacheable: true,  # 存入文件缓存
             verify_block: proc do |value|
-              # 支持 iOS 格式 (com.example.app) 和 Android 格式 (com.example.app)
-              # iOS 可以包含大写字母、连字符和通配符（*）
               unless value =~ /^[a-zA-Z0-9\-\.\*]+$/
-                raise "Bundle ID/Package Name 格式错误: #{value}，应该类似 com.example.app 或 com.example.*"
+                raise "Bundle ID 格式错误: #{value}，应该类似 com.example.app"
               end
             end,
             example: 'pindo ios autobuild --bundleid=com.example.app'
           ),
 
+          bundle_name: OptionItem.new(
+            key: :bundle_name,
+            name: 'Package Name',
+            description: '指定 Android Package Name',
+            type: String,
+            env_name: 'PINDO_BUNDLE_NAME',
+            optional: true,
+            cacheable: true,  # 存入文件缓存
+            verify_block: proc do |value|
+              unless value =~ /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$/i
+                raise "Package Name 格式错误: #{value}，应该类似 com.example.app"
+              end
+            end,
+            example: 'pindo android autobuild --bundle_name=com.example.app'
+          ),
+
           build_type: OptionItem.new(
             key: :build_type,
+            name: '构建类型',
             description: '指定构建类型（dev/adhoc/release）',
             type: String,
             env_name: 'PINDO_BUILD_TYPE',
@@ -47,6 +63,7 @@ module Pindo
 
           scheme: OptionItem.new(
             key: :scheme,
+            name: 'Scheme',
             description: '指定构建 Scheme',
             type: String,
             env_name: 'PINDO_SCHEME',