如何根据 Podfile.lock 生成依赖图

前言:

可以三步走，

• 文本解析，抽取信息

• 整理出依赖图的层次

• 绘制出来

这一篇介绍了，函数式编程来解析，抽取信息

函数式编程与文本解析，review octree/pretty

本文介绍，面向过程，使用正则表达式，解析文本，

还有第二步，整理出依赖图

有参考 octree/pretty

第 1 步，文本解析，抽取信息

面向过程，亲切友好，清晰易懂，没有函数式那么多的范型

代码比函数式还少

可能，pretty 里面，函数式编程用的, 需要提高下

从文本中，得到字典 [ 父 lib : [子 lib ] ]

struct Parser {
    
    func parse(_ content: String) -> [String: [String]]?{
        
        struct Tag{
            // 必然这个打头
            let pageStart = "PODS:\n"
            // 换行
            let lineEnd: Character = "\n"
            // 到结尾了
            let pageEnd: String
            // 父 lib
            let itemStart = String(repeating: " ", count: 2)
            // 子 lib
            let subItemStart = String(repeating: " ", count: 4)
            init() {
                pageEnd = String(repeating: "\(lineEnd)", count: 2)
            }
        }
        
        let tag = Tag()
        guard content.hasPrefix(tag.pageStart) else {
            return nil
        }
        let info = content.rm(header: tag.pageStart)
        guard let temp = info.components(separatedBy: tag.pageEnd).first else{
            return nil
        }
        var result = [String: [String]]()
        let list = temp.split(separator: tag.lineEnd)
        // 把信息，拆分出来了
        var key = ""
        var vals = [String]()
        var started = false
        for item in list{
            let tmp = String(item)
            if tmp.hasPrefix(tag.subItemStart){
                // 子 lib
                vals.append(tmp.rm(header: tag.subItemStart).rmRegexHeader.regexExtract)
            }
            else if tmp.hasPrefix(tag.itemStart){
                if started{
                    result[key] = vals
                }
                // 父 lib
                vals.removeAll()
                started = true
                key = tmp.rm(header: tag.itemStart).rmRegexHeader.regexExtract
            }
            
        }
        
        if result.isEmpty{
            return nil
        }
        else{
            return result
        }
    }
}

辅助方法

extension String{
    // 去除头部几个字符
    func rm(header str: String) -> String{
        return String(dropFirst(str.count))
    }

    // 去除头部识别到的几个字符
    var rmRegexHeader: String{
        if let tmp = match(regex: #"- "?"#){
            return String(dropFirst(tmp.count))
        }
        else{
            return self
        }
    }
    
    // 抽取头部识别到的几个字符
    var regexExtract: String{
        if let tmp = match(regex: #"[^\s]+"#){
            return tmp
        }
        else{
            return self
        }
    }
    
    func match(regex: String) -> String? {
        guard let regex = try? NSRegularExpression(pattern: regex) else {
            return nil
        }
        let results = regex.matches(in: self, range: NSRange(location: 0, length: utf8.count))
        let nsString = self as NSString
        if let first = results.first{
            return nsString.substring(with: first.range)
        }
        else{
            return nil
        }
    }
}

优化

下面这段，逻辑不够流畅，

for 循环中，先走处理子模块的逻辑，再走处理父 lib 的逻辑

var result = [String: [String]]()
        let list = temp.split(separator: tag.lineEnd)
        // 把信息，拆分出来了
        var key = ""
        var vals = [String]()
        var started = false
        for item in list{
            let tmp = String(item)
            if tmp.hasPrefix(tag.subItemStart){
                // 子 lib
                vals.append(tmp.rm(header: tag.subItemStart).rmRegexHeader.regexExtract)
            }
            else if tmp.hasPrefix(tag.itemStart){
                if started{
                    result[key] = vals
                }
                // 父 lib
                vals.removeAll()
                started = true
                key = tmp.rm(header: tag.itemStart).rmRegexHeader.regexExtract
            }
            
        }

可调整为，先处理父 lib, 再处理子 lib, 与实际的数据逻辑一致

var result = [String: [String]]()
        let list = temp.split(separator: tag.lineEnd)
        let cnt = list.count
        var i = 0
        while i < cnt {
            var tmp = String(list[i])
            var key: String?
            var vals = [String]()
            // 处理父 lib
            if tmp.isItem{
                key = tmp.rm(header: tag.itemStart).word
                i += 1
            }
            // 处理子 lib
            var stay = true
            while stay, i < cnt {
                tmp = String(list[i])
                if tmp.isSubitem{
                    vals.append(tmp.rm(header: tag.subItemStart).word)
                    i += 1
                }
                else{
                    stay = false
                }
            }
            if let k = key{
                result[k] = vals
            }
            else{
                return nil
            }
        }

辅助方法

extension String{
    
    var isItem: Bool{
        let tag = Tag()
        return hasPrefix(tag.itemStart) && (hasPrefix(tag.subItemStart) == false)
    }
    
    var isSubitem: Bool{
        let tag = Tag()
        return hasPrefix(tag.subItemStart)
    }
    
    
    var word: String{
        rmRegexHeader.regexExtract
    }
}

第 2 步，整理出依赖图的层次

从字典 [ 父 lib : [子 lib ] ]

得到辅助字典， [ 子 lib : [父 lib ] ]

private func parentNode(_ dependency: [String: [String]]) -> [String: [String]] {
    
    var pMap = [String: [String]]()
    for (key, sons) in dependency {
        for name in sons {
            var parents = pMap[name] ?? []
            parents.append(key)
            pMap[name] = parents
            //  这一行，很好理解
            //  pMap[name] = key
            //  剩下的，就是把 key 添加进之前收集到的信息
        }
    }
    
    return pMap
}

依赖图分层，建立 [ top libs info, seccond libs info , ... ]

先把没有父 lib 的顶部 lib 拎出来，

再从剩下的 lib 中，把没有 父 lib 的 lib 拎出来，如此往复

/// 根据 lib 的 depth 进行分组

func groupPodDependency(_ dependency: [String: [String]]) -> [[String: [String]]] {
    
    let reversed = parentNode(dependency)
    // 这里的 dependency.keys 的信息，与 Set(dependency.keys) 的信息一致
    // 这里使用 Set , 是为了下面便于 remove 元素
    var names = Set(dependency.keys)
    
    var lastDepthNames = [String]()
    var groups = [[String: [String]]]()
    while names.count > 0 {
        
        var group = [String: [String]]()
        let copyedNames = names
        // copyedNames, 第一轮， 是指对于每一个 lib
        // 以后轮，就是剩下的其中，每一个 lib
        for name in copyedNames {
            // 第一轮 ， lastDepthNames []
            // 对于没有父 lib 的顶部 lib ，
            // reversed[name] = []
            // 对于以后轮，必须全部包含，无一遗漏
            if lastDepthNames.contains(reversed[name] ?? []) {
                names.remove(name)
                // 筛选出来，添加子 lib 的信息
                group[name] = dependency[name]
            }
        }
        lastDepthNames.append(contentsOf: group.keys)
        groups.append(group)
    }
    
    return groups
}

绘制出来

拿到了 [[String: [String]]] ,

其每一个元素 [String: [String]]， 是每一层的信息

其元素 [String: [String]]，的 keys 是一层的 lib ,

其中 key 对应的 values, 是该 lib 与子 lib 的连线

• 绘制出来，见 github repo

github repo