pindo 5.13.9 → 5.13.10

data/lib/pindo/base/pindocontext.rb

@@ -1,602 +0,0 @@
-require 'singleton'
-require 'digest'
-require 'json'
-require 'fileutils'
-
-module Pindo
-  class PindoContext
-    # 选择键定义
-    module SelectionKey
-      TAG_DECISION = :tag_decision      # 打Tag决定
-      PROJECT_NAME = :project_name      # 项目名称
-      BUNDLE_ID = :bundle_id            # Bundle ID
-      ANDROID_BUNDLE_NAME = :android_bundle_name  # Android Bundle Name
-      CERT_TYPE = :cert_type            # 证书类型
-    end
-    
-    include Singleton
-
-    attr_reader :current_command, :current_directory
-
-    def initialize
-      @current_command = nil      # 根命令（第一个设置的命令）
-      @current_directory = nil    # 项目路径
-      @memory_selections = {}      # 三级结构的内存缓存
-      @file_cache_loaded = false   # 标记文件缓存是否已加载
-      @cache_enabled = false       # 默认禁用缓存
-      @command_group = nil         # 命令组名称
-      @verbose = false             # 是否输出详细日志
-      @loaded_file_cache = nil     # 已加载但未应用的文件缓存数据
-      @cache_confirmed = false     # 标记缓存确认是否已完成
-      ensure_cache_dir
-    end
-
-    # 判断是否处于 verbose 模式
-    def verbose?
-      @verbose || ENV['PINDO_VERBOSE'] == '1' || ENV['PINDO_DEBUG'] == '1'
-    end
-
-    # 设置当前上下文
-    def set_context(command, directory = nil, options = {})
-      # 如果已有命令在执行，这是嵌套调用，不需要做任何事
-      unless @current_command.nil?
-        puts "[PindoContext] 嵌套调用 #{command}，使用已有上下文 (根命令: #{@current_command}，命令组: #{@command_group})" if verbose?
-        return
-      end
-
-      # 第一次设置，是顶层命令
-      @current_command = command  # 保持原始命令名称
-      @current_directory = directory || Dir.pwd  # 固定项目目录
-
-      # 从选项中获取缓存配置
-      @cache_enabled = options[:cache_enabled] || false
-      @verbose = options[:verbose] || false
-      # 使用 get_command_group 来确定缓存组
-      @command_group = get_command_group(command)
-
-      if verbose?
-        puts "\n[PindoContext] ========== 设置顶层命令上下文 =========="
-        puts "[PindoContext] 命令: #{command}"
-        puts "[PindoContext] 目录: #{@current_directory}"
-        puts "[PindoContext] 缓存启用: #{@cache_enabled}"
-        puts "[PindoContext] 命令组: #{@command_group}"
-        puts "[PindoContext] options: #{options.inspect}"
-      end
-
-      # 仅在启用缓存时加载文件缓存（不确认，只加载到临时变量）
-      if @cache_enabled && !@file_cache_loaded
-        puts "[PindoContext] 准备加载文件缓存..." if verbose?
-        load_file_cache
-        @file_cache_loaded = true
-      else
-        if verbose?
-          if !@cache_enabled
-            puts "[PindoContext] 缓存未启用，跳过文件缓存加载"
-          elsif @file_cache_loaded
-            puts "[PindoContext] 文件缓存已加载，跳过重复加载"
-          end
-        end
-      end
-      puts "[PindoContext] ======================================\n" if verbose?
-    end
-
-    # 重置上下文（顶层命令结束时调用）
-    def reset_context
-      # 仅在启用缓存时保存文件缓存
-      save_file_cache if @cache_enabled && @current_command
-
-      @current_command = nil
-      @current_directory = nil
-      @file_cache_loaded = false
-      @cache_enabled = false
-      @command_group = nil
-      @cache_confirmed = false
-      # 暂不清理内存缓存，让同一进程内可以复用
-    end
-
-    # 设置用户选择（三级结构：项目路径 -> 根命令 -> 键值）
-    def set_selection(key, value)
-      # 构建三级键 - 使用统一的项目路径获取方法
-      project_path = get_project_path
-      root_command = @command_group || @current_command
-
-      # 如果没有有效的项目路径或命令，不保存
-      unless project_path && root_command
-        puts "[PindoContext] 警告: 无法保存选择，缺少项目路径或命令上下文"
-        return
-      end
-
-      # 初始化三级结构（总是保存到内存，不管是否启用缓存）
-      @memory_selections[project_path] ||= {}
-      @memory_selections[project_path][root_command] ||= {}
-
-      # 如果值为 nil，则删除该键而不是保存 nil
-      if value.nil?
-        @memory_selections[project_path][root_command].delete(key)
-        puts "[PindoContext] 从内存删除: [#{project_path}][#{root_command}][#{key}]" if verbose?
-      else
-        @memory_selections[project_path][root_command][key] = value
-        puts "[PindoContext] 保存到内存: [#{project_path}][#{root_command}][#{key}] = #{value.inspect}" if verbose?
-      end
-
-      # 更新该命令组的最后修改时间
-      @memory_selections[project_path][root_command]['__last_modified__'] = Time.now.to_i
-
-      # 仅在启用缓存时保存到文件
-      if @cache_enabled
-        save_file_cache
-        puts "[PindoContext] 已保存到文件缓存" if verbose?
-      else
-        puts "[PindoContext] 缓存未启用，仅保存到内存" if verbose?
-      end
-    end
-
-    # 获取用户选择（三级结构访问）
-    def get_selection(key)
-      # 使用统一的项目路径获取方法
-      project_path = get_project_path
-      root_command = @command_group || @current_command
-
-      return nil unless project_path && root_command
-
-      # 从三级结构中获取值（总是从内存获取，不管是否启用缓存）
-      value = @memory_selections.dig(project_path, root_command, key)
-
-      if value
-        puts "[PindoContext] 从内存获取: [#{project_path}][#{root_command}][#{key}] = #{value.inspect}" if verbose?
-      else
-        puts "[PindoContext] 内存中未找到: [#{project_path}][#{root_command}][#{key}]" if verbose?
-      end
-
-      value
-    end
-
-    # 检查是否有缓存的选择
-    def has_selection?(key)
-      # 总是检查内存中是否有值，不管是否启用缓存
-      !get_selection(key).nil?
-    end
-
-    # 启用/禁用缓存
-    def enable_cache(enabled = true)
-      @cache_enabled = enabled
-      if enabled && !@file_cache_loaded && @current_command
-        load_file_cache
-        @file_cache_loaded = true
-      end
-    end
-
-    # 检查缓存是否启用
-    def cache_enabled?
-      @cache_enabled
-    end
-
-    # 是否是嵌套调用
-    def nested_call?
-      !@current_command.nil?
-    end
-
-    # 是否是顶层命令（非嵌套）
-    def top_level_command?
-      @current_command.nil?
-    end
-
-    # 获取当前根命令
-    def root_command
-      @command_group || @current_command
-    end
-
-    # 获取当前项目路径（统一的获取方法，确保一致性）
-    def project_path
-      get_project_path
-    end
-
-    # 内部使用的项目路径获取方法
-    # 优先使用已设置的目录，如果没有则尝试获取Git仓库根目录
-    def get_project_path
-      # 如果已经设置了目录，直接返回
-      return @current_directory if @current_directory
-
-      # 尝试获取Git仓库根目录
-      begin
-        git_root = `git rev-parse --show-toplevel 2>/dev/null`.strip
-        return git_root if $?.success? && !git_root.empty?
-      rescue
-        # git命令失败
-      end
-
-      # 最后的后备：使用当前目录
-      Dir.pwd
-    end
-
-    # 清除当前上下文的缓存
-    def clear_current_cache
-      return unless @cache_enabled
-
-      proj_path = get_project_path
-      cmd = root_command
-      return unless proj_path && cmd
-
-      if @memory_selections[proj_path] && @memory_selections[proj_path][cmd]
-        @memory_selections[proj_path].delete(cmd)
-        @memory_selections.delete(proj_path) if @memory_selections[proj_path].empty?
-        save_file_cache
-        puts "[PindoContext] 清除缓存: [#{proj_path}][#{cmd}]" if verbose?
-      end
-    end
-
-    private
-
-    # 递归将Hash的键从字符串转换为符号
-    def symbolize_keys(obj)
-      case obj
-      when Hash
-        obj.each_with_object({}) do |(key, value), result|
-          result[key.to_sym] = symbolize_keys(value)
-        end
-      when Array
-        obj.map { |item| symbolize_keys(item) }
-      else
-        obj
-      end
-    end
-
-    # 确保缓存目录存在
-    def ensure_cache_dir
-      cache_dir = File.expand_path('~/.pindo/cache')
-      FileUtils.mkdir_p(cache_dir) unless File.exist?(cache_dir)
-    end
-
-    # 获取缓存文件路径
-    def cache_file_path
-      cache_dir = File.expand_path('~/.pindo/cache')
-      File.join(cache_dir, 'context_selections.json')
-    end
-
-    # 加载文件缓存（仅加载，不确认）
-    def load_file_cache
-      file_path = cache_file_path
-
-      puts "[PindoContext] 检查文件缓存: #{file_path}" if verbose?
-
-      unless File.exist?(file_path)
-        puts "[PindoContext] 文件缓存不存在，跳过加载" if verbose?
-        @loaded_file_cache = nil
-        return
-      end
-
-      begin
-        file_content = File.read(file_path)
-        file_cache = JSON.parse(file_content)
-
-        # 清理过期缓存（超过7天）
-        file_cache = clean_expired_cache(file_cache)
-
-        # 保存加载的缓存数据，但不应用到内存
-        @loaded_file_cache = file_cache
-
-        # 加载其他项目/命令的缓存到内存（不需要确认的部分）
-        project_path = get_project_path
-        root_command = @command_group || @current_command
-
-        file_cache.each do |proj_path, commands|
-          @memory_selections[proj_path] ||= {}
-          commands.each do |cmd, selections|
-            # 跳过当前上下文（需要确认）
-            next if proj_path == project_path && cmd == root_command
-
-            @memory_selections[proj_path][cmd] ||= {}
-            selections.each do |key, value|
-              symbol_key = key.to_sym
-              @memory_selections[proj_path][cmd][symbol_key] = symbolize_keys(value)
-            end
-          end
-        end
-
-        puts "[PindoContext] 已加载文件缓存到临时存储" if verbose?
-      rescue => e
-        puts "[PindoContext] 加载缓存失败: #{e.message}" if verbose?
-        @loaded_file_cache = nil
-      end
-    end
-
-    # 保存文件缓存（三级结构）
-    def save_file_cache
-      file_path = cache_file_path
-
-      begin
-        # 转换内存缓存为可序列化的格式（保持三级结构）
-        file_cache = {}
-        @memory_selections.each do |project_path, commands|
-          file_cache[project_path] ||= {}
-          commands.each do |command, selections|
-            file_cache[project_path][command] ||= {}
-            selections.each do |key, value|
-              # 跳过 nil 值，不保存到文件
-              next if value.nil?
-              # 将符号键转换为字符串
-              string_key = key.to_s
-              file_cache[project_path][command][string_key] = value
-            end
-          end
-        end
-
-        # 写入文件
-        File.write(file_path, JSON.pretty_generate(file_cache))
-
-        puts "[PindoContext] 保存文件缓存: #{file_path}" if verbose?
-      rescue => e
-        puts "[PindoContext] 保存缓存失败: #{e.message}" if verbose?
-      end
-    end
-
-    # 获取命令组名称（统一管理命令缓存组）
-    def get_command_group(command)
-      # 根据需求文档定义命令组，相关命令共享同一缓存
-      case command
-      # iOS 构建相关命令组
-      when 'unity:ipa'
-        'ios:autobuild'
-
-      # Android 构建相关命令组
-      when 'unity:apk'
-        'and:autobuild'
-
-      # Web 构建相关命令组
-      when 'unity:web'
-        'web:autobuild'
-
-      else
-        command  # 其他命令使用独立缓存（命令名本身作为组）
-      end
-    end
-
-    # 清理过期缓存（超过7天的缓存）
-    def clean_expired_cache(cache_data)
-      return {} unless cache_data.is_a?(Hash)
-
-      current_time = Time.now.to_i
-      seven_days_in_seconds = 7 * 24 * 60 * 60
-      cleaned_cache = {}
-      expired_commands = []
-      expired_projects = []
-
-      cache_data.each do |project_path, commands|
-        # 初始化项目路径
-        cleaned_commands = {}
-
-        commands.each do |command, selections|
-          # 获取最后修改时间
-          last_modified = selections['__last_modified__']
-
-          # 如果没有时间戳，视为过期
-          if last_modified.nil?
-            expired_commands << "[#{project_path}][#{command}] (无时间戳)"
-            puts "[PindoContext] 清理无时间戳缓存: [#{project_path}][#{command}]" if verbose?
-            next
-          end
-
-          # 检查是否过期（超过7天）
-          if (current_time - last_modified.to_i) > seven_days_in_seconds
-            days_old = (current_time - last_modified.to_i) / (24 * 60 * 60)
-            expired_commands << "[#{project_path}][#{command}] (#{days_old}天前)"
-            puts "[PindoContext] 清理过期缓存 (#{days_old}天前): [#{project_path}][#{command}]" if verbose?
-            next
-          end
-
-          # 保留未过期的缓存
-          cleaned_commands[command] = selections
-        end
-
-        # 如果该项目路径下还有有效的命令缓存，保留它
-        if cleaned_commands.any?
-          cleaned_cache[project_path] = cleaned_commands
-        else
-          # 整个项目路径下的所有命令都过期了，删除整个项目路径
-          expired_projects << project_path
-          puts "[PindoContext] 删除空项目路径: #{project_path}" if verbose?
-        end
-      end
-
-      # 输出清理总结
-      if expired_commands.any? || expired_projects.any?
-        puts "[PindoContext] 缓存清理完成:"
-        if expired_commands.any?
-          puts "  - 清理了 #{expired_commands.size} 个过期命令缓存"
-          expired_commands.each { |cmd| puts "    • #{cmd}" } if verbose?
-        end
-        if expired_projects.any?
-          puts "  - 删除了 #{expired_projects.size} 个空项目路径"
-          expired_projects.each { |proj| puts "    • #{proj}" } if verbose?
-        end
-
-        # 立即保存清理后的缓存到文件
-        File.write(cache_file_path, JSON.pretty_generate(cleaned_cache))
-      end
-
-      cleaned_cache
-    end
-
-
-    public
-
-    # 加载 JPSBuildConfig.json 并覆盖项目名称（如果存在）
-    # 应在 confirm_and_apply_cache 之前调用
-    def load_and_apply_jps_config(project_dir = nil)
-      project_dir ||= get_project_path
-
-      # 判断工程类型并确定配置文件路径
-      # Unity 工程：ProjectSettings/JPSBuildConfig.json
-      # iOS/Android 工程：JPSBuildConfig.json
-      config_file = nil
-      project_type = nil
-
-      # 检查是否是 Unity 工程（存在 ProjectSettings 目录）
-      if File.directory?(File.join(project_dir, 'ProjectSettings'))
-        config_file = File.join(project_dir, 'ProjectSettings', 'JPSBuildConfig.json')
-        project_type = 'Unity'
-      else
-        # iOS/Android 工程，直接在根目录
-        config_file = File.join(project_dir, 'JPSBuildConfig.json')
-        project_type = 'iOS/Android'
-      end
-
-      unless File.exist?(config_file)
-        puts "[PindoContext] JPSBuildConfig.json 不存在 (#{project_type} 工程)，跳过" if verbose?
-        return nil
-      end
-
-      begin
-        config_content = File.read(config_file)
-        jps_config = JSON.parse(config_content)
-
-        if jps_config['project_name'] && !jps_config['project_name'].empty?
-          project_name = jps_config['project_name']
-          puts "[PindoContext] 从 JPSBuildConfig.json 加载项目名称 (#{project_type}): #{project_name}" if verbose?
-
-          # 设置到当前上下文的缓存中
-          set_selection(SelectionKey::PROJECT_NAME, project_name)
-
-          puts "使用 JPS 配置的项目名称: #{project_name}"
-          return project_name
-        end
-      rescue => e
-        puts "[PindoContext] 加载 JPSBuildConfig.json 失败: #{e.message}" if verbose?
-      end
-
-      nil
-    end
-
-    # 确认并应用缓存（供命令在 run 函数中调用）
-    # 返回值：true 表示使用缓存，false 表示不使用缓存
-    def confirm_and_apply_cache
-      return false unless @cache_enabled
-      return false unless @loaded_file_cache
-
-      # 如果已经确认过缓存，直接返回（避免嵌套调用时重复询问）
-      if @cache_confirmed
-        puts "[PindoContext] 缓存已确认，跳过重复询问" if verbose?
-        # 检查内存中是否已有缓存数据
-        project_path = get_project_path
-        root_command = @command_group || @current_command
-        return @memory_selections.dig(project_path, root_command) != nil
-      end
-
-      project_path = get_project_path
-      root_command = @command_group || @current_command
-
-      return false unless project_path && root_command
-
-      # 检查三级结构中是否有当前上下文的缓存
-      cached_selections = @loaded_file_cache.dig(project_path, root_command)
-
-      unless cached_selections && !cached_selections.empty?
-        puts "[PindoContext] 当前上下文没有缓存数据" if verbose?
-        return false
-      end
-
-      # 根据命令组显示更友好的描述
-      group_desc = case root_command
-                   when 'ios:autobuild'
-                     'iOS 构建'
-                   when 'and:autobuild', 'android:autobuild'
-                     'Android 构建'
-                   when 'web:autobuild'
-                     'Web 构建'
-                   else
-                     @current_command  # 其他命令显示原始命令名
-                   end
-
-      puts "\n检测到之前的选择 (#{group_desc}):"
-      puts "────────────────────────────────────────"
-
-      cached_selections.each do |key, value|
-        # 跳过内部字段和 nil 值
-        next if key.to_s.start_with?('__')
-        next if value.nil?
-
-        case key.to_s
-        when 'bundle_id'
-          puts "  Bundle ID: #{value}"
-        when 'android_bundle_name'
-          puts "  Bundle Name: #{value}"
-        when 'project_name', 'app_key'  # 兼容旧的 app_key
-          puts "  项目名称: #{value}"
-        when 'tag_decision'
-          if value.is_a?(Hash)
-            action_desc = value['description'] || value['action']
-            puts "  Tag决定: #{action_desc}"
-          end
-        when 'cert_type'
-          puts "  证书类型: #{value}"
-        end
-      end
-      puts "────────────────────────────────────────"
-
-      # 检查是否设置了强制编译环境变量
-      force_build = ENV['PINDO_FORCE_BUILD']
-
-      confirm = false
-      if force_build && !force_build.empty?
-        # 环境变量存在，自动使用缓存
-        puts "\n检测到 PINDO_FORCE_BUILD 环境变量，自动使用缓存的选择"
-        confirm = true
-      else
-        # 询问用户是否使用缓存
-        require 'highline/import'
-        cli = HighLine.new
-        confirm = cli.agree("\n是否使用以上缓存的选择？ (y/n) ")
-      end
-
-      if confirm
-        puts "使用缓存的选择\n" unless force_build
-        # 恢复当前上下文的文件缓存到内存缓存
-        @memory_selections[project_path] ||= {}
-        @memory_selections[project_path][root_command] ||= {}
-        cached_selections.each do |key, value|
-          symbol_key = key.to_sym
-          @memory_selections[project_path][root_command][symbol_key] = symbolize_keys(value)
-        end
-        # 标记缓存已确认，避免嵌套调用时重复询问
-        @cache_confirmed = true
-        return true
-      else
-        puts "清除缓存，重新选择\n"
-        # 清除当前上下文的文件缓存（三级结构）
-        file_path = cache_file_path
-        if @loaded_file_cache[project_path] && @loaded_file_cache[project_path][root_command]
-          @loaded_file_cache[project_path].delete(root_command)
-          # 如果项目路径下没有任何命令缓存了，删除项目路径键
-          @loaded_file_cache.delete(project_path) if @loaded_file_cache[project_path].empty?
-          # 保存清理后的缓存到文件
-          save_file_cache
-        end
-        # 标记缓存已确认（用户选择不使用）
-        @cache_confirmed = true
-        return false
-      end
-    end
-
-    # 调试信息
-    def debug_info
-      puts "\n=== PindoContext Debug Info ==="
-      puts "当前命令: #{@current_command || '无'}"
-      puts "命令组: #{@command_group || '无'}"
-      puts "设置的目录: #{@current_directory || '未设置'}"
-      puts "实际项目路径: #{get_project_path}"
-      puts "缓存启用: #{@cache_enabled}"
-
-      proj_path = get_project_path
-      root_cmd = @command_group || @current_command
-
-      if root_cmd && @memory_selections.dig(proj_path, root_cmd)
-        puts "当前缓存的选择:"
-        @memory_selections[proj_path][root_cmd].each do |k, v|
-          next if k.to_s.start_with?('__')  # 跳过内部字段
-          puts "  #{k}: #{v.inspect}"
-        end
-      end
-      puts "================================\n"
-    end
-  end
-end