pindo 5.13.1 → 5.13.3

data/lib/pindo/module/xcode/xcode_swark_helper.rb

@@ -0,0 +1,341 @@
+require 'fileutils'
+require 'json'
+require 'yaml'
+
+module Pindo
+  # Xcode Swark/Quark 辅助工具类
+  # 用于配置和运行 Quark 和 Swark 开发环境
+  class XcodeSwarkHelper
+
+    # 配置 Quark 开发环境
+    # @param pindo_dir [String] Pindo 工作目录
+    # @param quark_git_url [String] Quark Git 仓库 URL
+    # @return [Boolean] 是否配置成功
+    def self.setup_quark_env(pindo_dir:, quark_git_url:)
+      require 'pindo/base/git_handler'
+      require_relative '../../base/funlog'
+
+      begin
+        # 确保 pindo 目录存在
+        FileUtils.mkdir_p(pindo_dir) unless File.exist?(pindo_dir)
+
+        Funlog.instance.fancyinfo_start("正在配置 Quark 开发环境...")
+
+        # 获取仓库名称
+        reponame = get_repo_base_name(repo_url: quark_git_url)
+
+        # 克隆或更新 Quark 仓库
+        quark_path = Pindo::GitHandler.getcode_to_dir(
+          reponame: reponame,
+          remote_url: quark_git_url,
+          path: pindo_dir,
+          new_branch: nil
+        )
+
+        # 执行 quark-install
+        install_command = File.join(quark_path, 'quark-install')
+        if File.exist?(install_command)
+          Funlog.instance.fancyinfo("执行 quark-install...")
+          system "/bin/chmod 777 #{install_command}"
+          system install_command
+        else
+          Funlog.instance.fancyinfo_warning("未找到 quark-install 文件: #{install_command}")
+        end
+
+        # 执行 quark-upgrade
+        upgrade_command = File.join(quark_path, 'quark-upgrade')
+        if File.exist?(upgrade_command)
+          Funlog.instance.fancyinfo("执行 quark-upgrade...")
+          system "/bin/chmod 777 #{upgrade_command}"
+          system upgrade_command
+        else
+          Funlog.instance.fancyinfo_warning("未找到 quark-upgrade 文件: #{upgrade_command}")
+        end
+
+        Funlog.instance.fancyinfo_success("Quark 开发环境配置完成！")
+        return true
+
+      rescue StandardError => e
+        Funlog.instance.fancyinfo_error("配置 Quark 环境失败: #{e.message}")
+        puts e.backtrace
+        return false
+      end
+    end
+
+    # 配置 Swark 开发环境
+    # @param pindo_dir [String] Pindo 工作目录
+    # @param swark_git_url [String] Swark Git 仓库 URL
+    # @return [Boolean] 是否配置成功
+    def self.setup_swark_env(pindo_dir:, swark_git_url:)
+      require 'pindo/base/git_handler'
+      require_relative '../../base/funlog'
+
+      begin
+        # 确保 swark 目录存在
+        swark_dir = File.expand_path(pindo_dir)
+        FileUtils.mkdir_p(swark_dir) unless File.exist?(swark_dir)
+
+        Funlog.instance.fancyinfo_start("正在配置 Swark 开发环境...")
+
+        # 获取仓库名称
+        reponame = get_repo_base_name(repo_url: swark_git_url)
+
+        # 克隆或更新 Swark 仓库（强制使用 swark-toolchain-lite 作为目录名）
+        swark_path = Pindo::GitHandler.getcode_to_dir(
+          reponame: 'swark-toolchain-lite',
+          remote_url: swark_git_url,
+          path: swark_dir,
+          new_branch: nil
+        )
+
+        # 执行 install
+        install_command = File.join(swark_path, 'install')
+        if File.exist?(install_command)
+          Funlog.instance.fancyinfo("执行 swark install...")
+          system "/bin/chmod 777 #{install_command}"
+          system install_command
+        else
+          Funlog.instance.fancyinfo_warning("未找到 install 文件: #{install_command}")
+        end
+
+        # 执行 swark-upgrade
+        swark_exe_dir = File.expand_path("~")
+        upgrade_command = File.join(swark_exe_dir, 'swark-toolchain/tools/swark-upgrade')
+        if File.exist?(upgrade_command)
+          Funlog.instance.fancyinfo("执行 swark-upgrade...")
+          puts "升级命令: #{upgrade_command}"
+          system "/bin/chmod 777 #{upgrade_command}"
+          system upgrade_command
+        else
+          Funlog.instance.fancyinfo_warning("未找到 swark-upgrade 文件: #{upgrade_command}")
+        end
+
+        Funlog.instance.fancyinfo_success("Swark 开发环境配置完成！")
+        return true
+
+      rescue StandardError => e
+        Funlog.instance.fancyinfo_error("配置 Swark 环境失败: #{e.message}")
+        puts e.backtrace
+        return false
+      end
+    end
+
+    private
+
+    # 从 Git URL 中提取仓库基础名称
+    # @param repo_url [String] Git 仓库 URL
+    # @return [String] 仓库基础名称
+    def self.get_repo_base_name(repo_url:)
+      return nil if repo_url.nil? || repo_url.empty?
+
+      # 移除 .git 后缀
+      base_name = repo_url.sub(/\.git$/, '')
+
+      # 提取最后一个路径部分
+      base_name = base_name.split('/').last
+
+      base_name
+    end
+
+    # 运行 Swark 配置
+    # @param project_dir [String] 项目目录
+    # @param config_json [Hash] 配置 JSON 数据
+    # @param build_type [String] 构建类型 (dev/adhoc/release)
+    # @return [Boolean] 是否成功
+    def self.swark_run(project_dir:, config_json:, build_type: 'release')
+      require_relative '../../base/funlog'
+
+      begin
+        Funlog.instance.fancyinfo_start("正在配置 Swark 环境...")
+
+        # 1. 设置 Swark 环境
+        require 'pindo/config/pindoconfig'
+        pindo_dir = Pindo::Pindoconfig.instance.pindo_dir
+        swark_git_url = Pindo::Pindoconfig.instance.deploy_swark_giturl
+        setup_swark_env(pindo_dir: pindo_dir, swark_git_url: swark_git_url)
+
+        # 2. 运行 Swark 授权
+        bundle_id = config_json['app_info']['app_identifier'] if config_json && config_json['app_info']
+        if bundle_id && !bundle_id.empty?
+          swark_authorize_run(bundle_id: bundle_id)
+        end
+
+        # 3. 创建 Swark.host.yaml 配置文件
+        swark_host_name = File.join(project_dir, "Swark.host.yaml")
+        host_json = {}
+        host_json["remote"] = {}
+        host_json["remote"]["test"] = ""
+
+        # 获取 host URL
+        host_url = ""
+        if config_json && config_json['app_setting']
+          if config_json['app_setting']['app_client_url']
+            host_url = File.join(config_json['app_setting']['app_client_url'], 'api/v3/init')
+          elsif config_json['app_setting']['kGUKeyAppClientHost']
+            host_url = File.join(config_json['app_setting']['kGUKeyAppClientHost'], 'api/v3/init')
+          end
+        end
+
+        host_json["remote"]["pre"] = host_url
+        host_json["remote"]["prod"] = host_url
+
+        # 设置 embed 名称
+        embed_name = "vdisk.dat"
+        category_name = "VMDemo"
+        if config_json['project_info'] && config_json['project_info']['project_name']
+          category_name = config_json['project_info']['project_name']
+          category_name = category_name.gsub(/ /, '').gsub(/\'/, '')
+          embed_name = category_name + ".dat"
+        end
+        host_json["embed"] = embed_name
+
+        # 写入 YAML 文件
+        File.open(swark_host_name, "w") do |file|
+          YAML.dump(host_json, file)
+        end
+
+        # 4. 运行 swark host 命令
+        # dev 使用 pre 模式，其他使用 prod 模式
+        swark_mode = (build_type == 'dev') ? 'pre' : 'prod'
+        command = "swark host #{swark_mode}"
+
+        Funlog.instance.fancyinfo("执行命令: #{command}")
+        system command
+
+        Funlog.instance.fancyinfo_success("Swark 配置完成！")
+        return true
+
+      rescue StandardError => e
+        Funlog.instance.fancyinfo_error("Swark 配置失败: #{e.message}")
+        puts e.backtrace
+        return false
+      end
+    end
+
+    # 运行 Quark 配置
+    # @param project_dir [String] 项目目录
+    # @param config_json [Hash] 配置 JSON 数据
+    # @param build_type [String] 构建类型 (dev/adhoc/release)
+    # @return [Boolean] 是否成功
+    def self.quark_run(project_dir:, config_json:, build_type: 'release')
+      require_relative '../../base/funlog'
+
+      begin
+        Funlog.instance.fancyinfo_start("正在配置 Quark 环境...")
+
+        # 1. 设置 Quark 环境
+        require 'pindo/config/pindoconfig'
+        pindo_dir = Pindo::Pindoconfig.instance.pindo_dir
+        quark_git_url = Pindo::Pindoconfig.instance.deploy_quark_giturl
+        setup_quark_env(pindo_dir: pindo_dir, quark_git_url: quark_git_url)
+
+        # 2. 运行 quark host 命令
+        # dev 使用 test 模式，其他使用 prod 模式
+        quark_mode = (build_type == 'dev') ? 'test' : 'prod'
+        command = "quark host #{quark_mode}"
+
+        Funlog.instance.fancyinfo("执行命令: #{command}")
+        system command
+
+        # 3. 修改 Quark.lock 文件
+        quark_json_file = File.join(project_dir, "QuarkData/Quark.lock")
+        unless File.exist?(quark_json_file)
+          Funlog.instance.fancyinfo_warning("未找到 Quark.lock 文件: #{quark_json_file}")
+          return false
+        end
+
+        quark_json = JSON.parse(File.read(quark_json_file))
+
+        # 设置 remote URL
+        if config_json && config_json['app_setting'] && config_json['app_setting']['app_client_url']
+          quark_json['remote'] = File.join(config_json['app_setting']['app_client_url'], 'api/init')
+        end
+
+        # 设置 embed 和 category 名称
+        embed_name = "Meety.dat"
+        category_name = "PodsDummy"
+        if config_json['project_info'] && config_json['project_info']['project_name']
+          category_name = config_json['project_info']['project_name']
+          category_name = category_name.gsub(/ /, '').gsub(/\'/, '')
+          embed_name = category_name + ".dat"
+        end
+
+        quark_json['embed'] = embed_name
+        quark_json['category'] = category_name
+        quark_json['env'] = quark_mode
+
+        # 写入文件
+        File.open(quark_json_file, "w") do |file|
+          file.write(JSON.pretty_generate(quark_json))
+        end
+
+        Funlog.instance.fancyinfo_success("Quark 配置完成！")
+        return true
+
+      rescue StandardError => e
+        Funlog.instance.fancyinfo_error("Quark 配置失败: #{e.message}")
+        puts e.backtrace
+        return false
+      end
+    end
+
+    # 运行 Swark 授权
+    # @param bundle_id [String] Bundle ID
+    # @return [Boolean] 是否成功
+    def self.swark_authorize_run(bundle_id:)
+      require_relative '../../base/funlog'
+      require 'pindo/base/git_handler'
+      require 'pindo/config/pindoconfig'
+
+      begin
+        Funlog.instance.fancyinfo_start("正在执行 Swark 授权...")
+
+        pindo_dir = Pindo::Pindoconfig.instance.pindo_dir
+        app_config_dir = File.join(File.expand_path(pindo_dir), bundle_id)
+        swark_authorize_file = File.join(app_config_dir, "swark_authorize.json")
+
+        unless File.exist?(swark_authorize_file)
+          Funlog.instance.fancyinfo_warning("未找到 swark_authorize.json 文件: #{swark_authorize_file}")
+          return false
+        end
+
+        swark_authorize_json = JSON.parse(File.read(swark_authorize_file))
+
+        # 检查是否已经授权
+        if swark_authorize_json && swark_authorize_json['swark_authorize_status']
+          Funlog.instance.fancyinfo("Swark 已经授权过了")
+          return true
+        end
+
+        # 执行授权命令
+        command = "swark authorize "
+        command += swark_authorize_json["swark_authorize_teamid"] + "." + swark_authorize_json["swark_authorize_bundleid"]
+
+        Funlog.instance.fancyinfo("执行命令: #{command}")
+        puts
+        puts
+        puts command
+        puts
+        system command
+
+        # 更新授权状态
+        swark_authorize_json['swark_authorize_status'] = true
+        File.open(swark_authorize_file, "w") do |f|
+          f.write(JSON.pretty_generate(swark_authorize_json))
+        end
+
+        # 提交到配置仓库
+        Pindo::GitHandler.git_addpush_repo(path: app_config_dir, message: "swark authorize success !!!")
+
+        Funlog.instance.fancyinfo_success("Swark 授权完成！")
+        return true
+
+      rescue StandardError => e
+        Funlog.instance.fancyinfo_error("Swark 授权失败: #{e.message}")
+        puts e.backtrace
+        return false
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,268 @@
+require 'singleton'
+require 'json'
+require 'fileutils'
+
+module Pindo
+  module Options
+    # 全局参数状态管理器（单例，简化版）
+    # 职责：
+    # 1. 管理当前命令的参数状态
+    # 2. 管理文件缓存的加载、保存和应用
+    class GlobalOptionsState
+      include Singleton
+
+      def initialize
+        # 运行时状态（内存）
+        @current_command = nil        # 当前命令名称
+        @current_options = nil        # 当前参数配置对象
+        @current_directory = nil      # 当前项目目录
+        @cache_enabled = false        # 是否启用缓存
+
+        # 缓存状态（文件）
+        @cache_data = {}              # 缓存数据：{ 项目目录 => { 命令 => 参数Hash } }
+        @cache_loaded = false         # 是否已加载缓存文件
+
+        # 调试
+        @verbose = ENV['PINDO_VERBOSE'] == '1'
+
+        ensure_cache_dir
+      end
+
+      # ==================== 运行时状态管理 ====================
+
+      # 准备缓存（在创建 OptionConfiguration 之前调用）
+      # @param command_name [String] 命令名称
+      # @param directory [String] 项目目录
+      def prepare_cache(command_name, directory)
+        @current_command = command_name
+        @current_directory = directory
+        load_cache_from_file
+      end
+
+      # 加载缓存的参数值（带用户确认）
+      # @return [Hash] 缓存的参数值
+      def load_cached_values
+        return {} unless @current_directory && @current_command
+
+        cached_params = @cache_data.dig(@current_directory.to_sym, @current_command.to_sym)
+
+        # 没有缓存数据，直接返回空Hash
+        unless cached_params && cached_params.is_a?(Hash) && cached_params.any?
+          log_verbose("没有找到缓存参数: #{@current_directory} / #{@current_command}")
+          return {}
+        end
+
+        # 检查环境变量是否强制使用缓存
+        force_build = ENV['PINDO_FORCE_BUILD']
+
+        if force_build && !force_build.empty?
+          # 自动使用缓存
+          puts "\n检测到 PINDO_FORCE_BUILD 环境变量，自动使用缓存的参数"
+          log_verbose("加载缓存参数: #{cached_params.inspect}")
+          return cached_params
+        end
+
+        # 显示缓存的参数
+        display_cached_params(cached_params)
+
+        # 询问用户是否使用缓存
+        require 'highline/import'
+        cli = HighLine.new
+        confirm = cli.agree("\n是否使用以上缓存的参数？ (y/n) ")
+
+        if confirm
+          puts "使用缓存的参数\n"
+          log_verbose("加载缓存参数: #{cached_params.inspect}")
+          cached_params
+        else
+          puts "清除缓存，使用新参数\n"
+          # 清除当前命令的缓存
+          clear_current_cache
+          {}
+        end
+      end
+
+      # 显示缓存的参数
+      def display_cached_params(cached_params)
+        # 根据命令名显示友好的描述
+        group_desc = case @current_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_params.each do |key, value|
+          # 跳过内部字段
+          next if key.to_s.start_with?('__')
+          next if value.nil?
+
+          # 格式化显示参数
+          key_name = format_param_name(key)
+          puts "  #{key_name}: #{value}"
+        end
+
+        puts "────────────────────────────────────────"
+      end
+
+      # 格式化参数名称
+      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
+        end
+      end
+
+      # 清除当前命令的缓存
+      def clear_current_cache
+        return unless @current_directory && @current_command
+
+        if @cache_data[@current_directory.to_sym]
+          @cache_data[@current_directory.to_sym].delete(@current_command.to_sym)
+
+          # 如果项目目录下没有其他命令缓存了，删除整个项目目录
+          if @cache_data[@current_directory.to_sym].empty?
+            @cache_data.delete(@current_directory.to_sym)
+          end
+
+          # 立即保存到文件
+          save_cache_to_file_immediate
+        end
+      end
+
+      # 设置当前命令上下文
+      # @param command_name [String] 命令名称（如 "ios:autobuild"）
+      # @param options [OptionConfiguration] 参数配置对象
+      # @param directory [String] 项目目录
+      # @param enable_cache [Boolean] 是否启用缓存
+      def set_command(command_name, options, directory: nil, enable_cache: false)
+        @current_command = command_name
+        @current_options = options
+        @current_directory = directory || Dir.pwd
+        @cache_enabled = enable_cache
+
+        log_verbose("设置命令: #{command_name}")
+        log_verbose("项目目录: #{@current_directory}")
+        log_verbose("缓存启用: #{@cache_enabled}")
+      end
+
+      # 清除当前命令状态
+      def clear
+        # 如果启用了缓存，保存当前参数
+        save_cache_to_file if @cache_enabled && @current_options
+
+        @current_command = nil
+        @current_options = nil
+        @current_directory = nil
+        @cache_enabled = false
+      end
+
+      # 访问当前参数值
+      # @param key [Symbol] 参数键名
+      # @return [Any] 参数值
+      def [](key)
+        @current_options ? @current_options[key] : nil
+      end
+
+      # 设置当前参数值
+      # @param key [Symbol] 参数键名
+      # @param value [Any] 参数值
+      def []=(key, value)
+        @current_options[key] = value if @current_options
+      end
+
+      # ==================== 文件缓存管理 ====================
+
+      # 缓存文件路径
+      def cache_file_path
+        File.join(cache_dir, 'options_cache.json')
+      end
+
+      # 缓存目录
+      def cache_dir
+        File.join(Dir.home, '.pindo', 'cache')
+      end
+
+      # 确保缓存目录存在
+      def ensure_cache_dir
+        FileUtils.mkdir_p(cache_dir) unless Dir.exist?(cache_dir)
+      end
+
+      # 从文件加载缓存
+      def load_cache_from_file
+        return if @cache_loaded
+
+        if File.exist?(cache_file_path)
+          begin
+            content = File.read(cache_file_path)
+            @cache_data = JSON.parse(content, symbolize_names: true)
+            log_verbose("加载缓存文件: #{cache_file_path}")
+            log_verbose("缓存内容: #{@cache_data.inspect}")
+          rescue StandardError => e
+            log_verbose("加载缓存文件失败: #{e.message}")
+            @cache_data = {}
+          end
+        else
+          log_verbose("缓存文件不存在: #{cache_file_path}")
+        end
+
+        @cache_loaded = true
+      end
+
+      # 保存当前参数到缓存文件
+      def save_cache_to_file
+        return unless @current_directory && @current_command && @current_options
+
+        # 确保缓存数据结构存在
+        @cache_data[@current_directory.to_sym] ||= {}
+
+        # 提取当前参数值（排除 nil 值）
+        current_params = {}
+        @current_options.instance_variable_get(:@values).each do |key, value|
+          current_params[key] = value unless value.nil?
+        end
+
+        # 保存到缓存
+        @cache_data[@current_directory.to_sym][@current_command.to_sym] = current_params
+
+        # 写入文件
+        save_cache_to_file_immediate
+      end
+
+      # 立即保存缓存数据到文件（内部方法）
+      def save_cache_to_file_immediate
+        begin
+          File.write(cache_file_path, JSON.pretty_generate(@cache_data))
+          log_verbose("保存缓存文件: #{cache_file_path}")
+        rescue StandardError => e
+          log_verbose("保存缓存文件失败: #{e.message}")
+        end
+      end
+
+      # ==================== 调试日志 ====================
+
+      def log_verbose(message)
+        puts "[GlobalOptionsState] #{message}" if @verbose
+      end
+    end
+  end
+end