m-git 2.5.4

data/lib/m-git/manifest.rb

@@ -0,0 +1,181 @@
+#coding=utf-8
+
+require 'm-git/manifest/light_repo'
+require 'm-git/manifest/linter'
+require 'm-git/manifest/internal'
+
+module MGit
+
+  # Sample: 'm-git/manifest/manifest.sample'
+  #
+  class Manifest
+    include Linter
+    include Internal
+
+    # [Hash] 配置内容
+    attr_reader :config
+
+    # [String] 配置表内容哈希
+    # attr_reader :config_hash
+    attr_reader :hash_sha1
+
+    # [Array<LightRepo>] 与config中‘repositories’字段对应的Manifest::LightRepo对象数组，包含git仓库和非git仓库
+    attr_reader :light_repos
+
+    # [Array<LightRepo>] 类型同light_repos，表示上次操作，但本次未操作的仓库
+    attr_reader :previous_extra_light_repos
+
+    # [LightRepo] 包含配置表的配置仓库
+    attr_reader :config_repo
+
+    # [String] 配置文件路径
+    attr_reader :path
+
+    # [String] 缓存文件路径
+    attr_reader :cache_path
+
+    # [Hash] 上次改动生成的配置缓存
+    attr_reader :previous_config
+
+    # 在mgit根目录中搜索配置文件并根据配置文件生成对应LightRepo对象。
+    #
+    # [!!!!!] 请勿随意修改该接口
+    #
+    # @param root [String] mgit工作区根目录
+    #
+    # @param mgit_managed_only [Boolean] default: false，是否只获取mgit管理的git仓库
+    #
+    # @param only_exist [Boolean] default: false，是否只获取实际存在的仓库
+    #
+    # @param exclude_dummy [Boolean] default: false，是否排除dummy仓库
+    #
+    # @return [Array<LightRepo>] 仓库列表
+    #
+    def self.generate_light_repos(root, mgit_managed_only: false, only_exist:false, exclude_dummy:false)
+      config_path = File.join(root, Constants::PROJECT_DIR[:source_config])
+      config = self.parse(config_path)
+
+      if mgit_managed_only
+        repos = config.repo_list
+      elsif exclude_dummy
+        repos = config.light_repos.select { |repo| !repo.dummy }
+      else
+        repos = config.light_repos
+      end
+
+      if only_exist
+        existing_repos = []
+        repos.each { |repo|
+          abs_path = repo.abs_dest(root)
+          # 被管理的仓库验证是否是git仓库，不被管理的仓库只验证文件夹是否存在
+          if (repo.mgit_excluded && Dir.exist?(abs_path)) || (!repo.mgit_excluded && Repo.is_git_repo?(abs_path))
+            existing_repos.push(repo)
+          end
+        }
+        repos = existing_repos
+      end
+
+      return repos
+    end
+
+    # 全流程校验，除了字段合法性校验外，还包含缓存生成/校验，local配置文件校验/合并
+    #
+    # @param config_path [String] 配置文件本地路径
+    #
+    # @param strict_mode [Boolean] default: true 如果为true，出错直接报错退出，如果为false，出错抛出异常（MGit::Error）
+    #
+    # @return [Manifest] 配置对象
+    #
+    def self.parse(config_path, strict_mode:true)
+      config = Manifest.new
+      config.__setup(config_path, strict_mode)
+      return config
+    end
+
+    # 简单校验，仅校验配置内容，无缓存生成/校验，无local配置文件校验/合并
+    #
+    # @param config_content [String/Hash] 配置表json字符串或字典(key值需为String)
+    #
+    # @param strict_mode [Boolean] default: true 如果为true，出错直接报错退出，如果为false，出错抛出异常（MGit::Error）
+    #
+    # @return [Manifest] 配置对象
+    #
+    def self.simple_parse(config_content, strict_mode:true)
+      config = Manifest.new
+      config.__simple_setup(config_content, strict_mode)
+      return config
+    end
+
+
+    # 返回所有git仓库列表
+    #
+    # @param selection [Array<String>] default: nil，需要筛选的仓库名数组
+    #
+    # @param exclusion [Array<String>] default: nil，需要排除的仓库名数组
+    #
+    # @param all [Boolean] default: false 若指定为true，则忽略mgit_excluded的字段值，只要remote url存在（即有对应远程仓库），则选取
+    #
+    # @return [Array<LightRepo>] 被mgit管理的仓库生成的LightRepo数组
+    #
+    def repo_list(selection: nil, exclusion: nil, all:false)
+      list = []
+      light_repos.each { |light_repo|
+        if !light_repo.mgit_excluded || (all && !light_repo.url.nil?)
+          # 选取指定仓库
+          if (selection.nil? && exclusion.nil?) ||
+            (!selection.nil? && selection.is_a?(Array) && selection.any? { |e| e.downcase == light_repo.name.downcase }) ||
+            (!exclusion.nil? && exclusion.is_a?(Array) && !exclusion.any? { |e| e.downcase == light_repo.name.downcase })
+            list.push(light_repo)
+          end
+        end
+      }
+      list
+    end
+
+    # 获取全局配置
+    #
+    # @param key [Symbol] 配置字段【符号】
+    #
+    # @return [Object] 对应配置字段的值，可能是字符串，也可能是字典
+    #
+    def global_config(key)
+      key_str = Constants::CONFIG_KEY[key]
+      value = config[key_str]
+      terminate!("无法获取多仓库配置必需字段\"#{key}\"的值!") if value.nil? && Constants::REQUIRED_CONFIG_KEY.include?(key_str)
+      value
+    end
+
+    # 更新缓存
+    #
+    # @param root [String] 多仓库根目录
+    #
+    # @param config_content [Hash] 配置Hash
+    #
+    def update_cache_with_content(root, config_content)
+      config_dir = File.join(root, Constants::PROJECT_DIR[:source_config])
+      cache_path = File.join(config_dir, Constants::CONFIG_FILE_NAME[:manifest_cache])
+      sha1 = __generate_hash_sha1(config_content.to_json)
+      CacheManager.save_to_cache(cache_path, sha1, config_content)
+    end
+
+    # 更新（对比上次操作）冗余的轻量仓库对象
+    #
+    # @param root [String] 多仓库根目录
+    #
+    def update_previous_extra_light_repos(root)
+      cache_path = File.join(root, Constants::PROJECT_DIR[:source_config],  Constants::CONFIG_FILE_NAME[:manifest_cache])
+      __load_cache(cache_path)
+    end
+
+    def terminate!(msg, type:nil)
+      if @strict_mode
+        Foundation.help!(msg)
+      else
+        raise Error.new(msg, type:type)
+      end
+    end
+
+  end
+
+  RepoConfig = Manifest
+end

data/lib/m-git/manifest/cache_manager.rb

@@ -0,0 +1,44 @@
+
+module MGit
+  class Manifest
+    class CacheManager
+
+      attr_reader :path
+      attr_reader :hash_sha1
+      attr_reader :hash_data
+
+      def load_path(cache_path)
+        return unless File.exist?(cache_path)
+        begin
+          cache = JSON.parse(File.read(cache_path))
+        rescue => _
+          Output.puts_fail_message("配置文件缓存解析失败！将根据原配置文件进行仓库配置。")
+        end
+
+        @path = cache_path
+        @hash_sha1 = cache[Constants::CONFIG_CACHE_KEY[:hash]]
+        @hash_data = cache[Constants::CONFIG_CACHE_KEY[:cache]]
+      end
+
+      # 缓存配置文件
+      #
+      # @param cache_path [string] 配置文件目录
+      #
+      # @param hash_sha1 [String] 配置哈希字符串
+      #
+      # @param hash_data [Hash] 配置字典
+      #
+      def self.save_to_cache(cache_path, hash_sha1, hash_data)
+        FileUtils.mkdir_p(File.dirname(cache_path))
+        File.open(cache_path, 'w') do |file|
+          file.write({
+                         Constants::CONFIG_CACHE_KEY[:hash]   => hash_sha1,
+                         Constants::CONFIG_CACHE_KEY[:cache]  => hash_data
+                     }.to_json)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/m-git/manifest/internal.rb

@@ -0,0 +1,182 @@
+
+require 'm-git/manifest/cache_manager'
+
+module MGit
+  class Manifest
+    module Internal
+
+
+      # 配置对象
+      #
+      # @param config_path [String] 配置文件路径或目录
+      #
+      # @param strict_mode [Boolean] 是否使用严格模式。在严格模式下，出错将终止执行。在非严格模式下，出错将抛出异常，程序有机会继续执行。
+      #
+      def __setup(config_path, strict_mode)
+        @strict_mode = strict_mode
+        if File.directory?(config_path)
+          config_dir = config_path
+          config_path = File.join(config_dir, Constants::CONFIG_FILE_NAME[:manifest])
+        else
+          config_dir = File.dirname(config_path)
+          config_path = File.join(config_dir, File.basename(config_path))
+        end
+
+        local_path = File.join(config_dir, Constants::CONFIG_FILE_NAME[:local_manifest])
+        cache_path = File.join(config_dir, Constants::CONFIG_FILE_NAME[:manifest_cache])
+
+        __load_config(config_path, local_config_path: local_path, cache_path: cache_path)
+      end
+
+      # 简单配置对象，部分属性为nil
+      #
+      # @param config_content [Hash] 配置Hash
+      #
+      # @param strict_mode [Boolean] 是否使用严格模式。在严格模式下，出错将终止执行。在非严格模式下，出错将抛出异常，程序有机会继续执行。
+      #
+      def __simple_setup(config_content, strict_mode)
+        @strict_mode = strict_mode
+
+        if config_content.is_a?(Hash)
+          @config = config_content.deep_clone
+        else
+          @config = JSON.parse(config_content)
+        end
+        lint_raw_json!(config)
+
+        @light_repos = __generate_light_repos(config)
+        @config_repo = light_repos.find { |light_repo| light_repo.is_config_repo }
+
+        # 计算配置文件哈希
+        @hash_sha1 = __generate_hash_sha1(config.to_json)
+      end
+
+
+      private
+
+      def cache_manager
+        @cache_manager ||= CacheManager.new
+      end
+
+
+      # 加载配置文件
+      #
+      def __load_config(config_path, config_content: nil, local_config_path: nil, cache_path: nil)
+        if config_content
+          config_hash = __parse_manifest_json(config_content)
+        else
+          # 校验配置文件路径
+          lint_manifest_path(config_path)
+
+          # 读取配置文件
+          config_hash = __parse_manifest(config_path)
+        end
+
+        lint_raw_json!(config_hash)
+
+        if local_config_path && File.exist?(local_config_path)
+          lint_local_manifest_path(local_config_path)
+          local_config_hash = __parse_manifest(local_config_path)
+
+          __merge_manifest_hash(config_hash, local_config_hash)
+        end
+
+        @light_repos = __generate_light_repos(config_hash)
+        @config_repo = light_repos.find { |light_repo| light_repo.is_config_repo }
+        lint_light_repos!
+
+        @path = config_path
+        @config = config_hash
+        # 计算配置文件哈希
+        @hash_sha1 = __generate_hash_sha1(config_hash.to_json)
+
+        __load_cache(cache_path)
+        if previous_config.nil? || previous_config != config_hash
+          # 更新缓存
+          @cache_path = cache_path
+          @previous_config = config
+          CacheManager.save_to_cache(cache_path, hash_sha1, config)
+        end
+      end
+
+      def __load_cache(cache_path)
+        if cache_path && File.exist?(cache_path)
+          cache_manager.load_path(cache_path)
+          @cache_path = cache_manager.path
+          @previous_config = cache_manager.hash_data
+
+          @previous_extra_light_repos = __generate_extra_light_repos(config, previous_config)
+        end
+      end
+
+      def __parse_manifest_json(raw_string)
+        begin
+          raw_json = JSON.parse(raw_string)
+        rescue => _
+          terminate!("manifest文件解析错误，请检查json文件格式是否正确！")
+        end
+
+        raw_json
+      end
+
+      def __parse_manifest(path)
+        begin
+          raw_string = File.read(path)
+        rescue => e
+          terminate!("配置文件#{path}读取失败：#{e.message}")
+        end
+        __parse_manifest_json(raw_string)
+      end
+
+      def __generate_light_repos(config_hash)
+        light_repos = []
+        repositories = config_hash[Constants::CONFIG_KEY[:repositories]]
+        repositories.each do |repo_name, repo_cfg|
+          light_repos << LightRepoGenerator.light_repo_with(repo_name, repo_cfg, config_hash)
+        end
+        light_repos
+      end
+
+      def __generate_extra_light_repos(current_hash, previous_hash)
+        return if previous_hash.nil?
+        extra_light_repos = []
+        repositories = current_hash[Constants::CONFIG_KEY[:repositories]]
+        previous_repos = previous_hash[Constants::CONFIG_KEY[:repositories]]
+        extra_keys = previous_repos.keys - repositories.keys
+        extra_keys.each do |repo_name|
+          extra_light_repos << LightRepoGenerator.light_repo_with(repo_name, previous_repos[repo_name], previous_hash)
+        end
+        extra_light_repos
+      end
+
+
+      # 计算配置文件的哈希
+      def __generate_hash_sha1(json_string)
+        begin
+          return Digest::SHA256.hexdigest(json_string)
+        rescue => e
+          terminate!("配置文件哈希计算失败：#{e.message}")
+        end
+      end
+
+      def __merge_manifest_hash(base_hash, attach_hash)
+        dict = base_hash
+        attach_hash.each { |key, value|
+          if key == Constants::CONFIG_KEY[:repositories] && value.is_a?(Hash)
+            dict[key] = {} if dict[key].nil?
+            value.each { |repo_name, config|
+              dict[key][repo_name] = {} if dict[key][repo_name].nil?
+              if config.is_a?(Hash)
+                config.each { |r_key, r_value|
+                  dict[key][repo_name][r_key] = r_value if Constants::REPO_CONFIG_KEY.values.include?(r_key)
+                }
+              end
+            }
+          elsif Constants::CONFIG_KEY.values.include?(key)
+            dict[key] = value
+          end
+        }
+      end
+    end
+  end
+end

data/lib/m-git/manifest/light_repo.rb

@@ -0,0 +1,108 @@
+#coding=utf-8
+
+require_relative 'light_repo_generator'
+
+module MGit
+  class Manifest
+    # @!scope manifest.json 配置的reponsitories 对象
+    # 该类用于配置解析后的初步处理，其字段与配置文件一致，但不保证与本地仓库状态一致。
+    # 而Repo类则会校验本地仓库，其状态与本地仓库状态一致，主要用于执行多仓库操作。
+    #
+    LightRepo = Struct.new(
+        # [String] 仓库名
+        :name,
+
+        # [String] 仓库相对mgit根目录的存放路径（完整路径如：<.mgit所在路径>/path/<repo_name>），或绝对路径（指定abs-dest）
+        # 绝对路径
+        :path,
+
+        # [String] 仓库配置分支
+        :branch,
+
+        # [String] 仓库配置commit id
+        :commit_id,
+
+        # [String] 仓库配置tag
+        :tag,
+
+        # [String] 仓库的git地址
+        :url,
+
+        # [Boolean] 是否纳入mgit管理
+        :mgit_excluded,
+
+        # [Boolean] 是否是占位仓库【2.3.0废弃】
+        :dummy,
+
+        # [Boolean] 是否是配置仓库（包含配置表的仓库），若是，则某些操作如merge，checkout等会优先操作配置仓库，确保配置表最新
+        :is_config_repo,
+
+        # [Boolean] 是否锁定仓库（即任何操作均保证仓库状态与指定配置一致）
+        :lock
+    ) do
+
+      # 根据解析内容拼接一个clone地址
+      #
+      # @param root [String] mgit根目录
+      # @param local_url [String] default: nil 如果从本地clone，可传入一个本地的xxx.git实体地址
+      #
+      # @return [String] clone地址
+      #
+      def clone_url(root, local_url:nil, clone_branch:nil)
+        url = local_url.nil? ? self.url : local_url
+
+        if !clone_branch.nil? && Utils.branch_exist_on_remote?(clone_branch, url)
+          branch_opt = "-b #{clone_branch}"
+        elsif !self.branch.nil? && Utils.branch_exist_on_remote?(self.branch, url)
+          branch_opt = "-b #{self.branch}"
+        else
+          branch_opt = ''
+        end
+
+        "git clone #{branch_opt} -- #{url} #{abs_dest(root)}"
+      end
+
+      # 生成绝对路径
+      #
+      # @param root [String] 多仓库根目录
+      #
+      # @return [String] 仓库绝对路径
+      #
+      def abs_dest(root)
+        Utils.expand_path(self.path, base:root)
+      end
+
+      # 生成.git存储的完整路径
+      #
+      # @param root [String] 多仓库根目录
+      #
+      # @return [String] .git存储的完整路径
+      #
+      def git_store_dir(root)
+        # 替换key值中的‘/’字符，避免和路径混淆
+        name = self.name.gsub(/\//,':')
+
+        # 删除冗余字符
+        url = Utils.normalize_url(self.url)
+
+        git_store = Utils.generate_git_store(root, url)
+        if git_store.nil?
+          git_dir = File.join(root, Constants::PROJECT_DIR[:source_git])
+          git_store = File.join(git_dir, name)
+        end
+
+        git_store
+      end
+
+      # 生成缓存存放完整路径
+      #
+      # @param root [String] 多仓库根目录
+      #
+      # @return [String] 缓存存放完整路径
+      #
+      def cache_store_dir(root)
+        File.join(git_store_dir(root), 'cache')
+      end
+    end
+  end
+end