lg_pod_plugin 1.0.8 → 1.0.10

data/lib/lg_pod_plugin/install.rb

@@ -6,7 +6,8 @@ require_relative 'request'
 require_relative 'database'
 require_relative 'git_util'
 require_relative 'downloader.rb'
-
+require 'cocoapods-core/podfile'
+require 'cocoapods-core/podfile/target_definition'
 module LgPodPlugin
 
   class Installer
@@ -14,7 +15,10 @@ module LgPodPlugin
     REQUIRED_ATTRS ||= %i[name version options target real_name workspace].freeze
     attr_accessor(*REQUIRED_ATTRS)
 
-    def initialize(profile, name, *requirements)
+    def initialize(profile, name, requirements)
+      unless name
+        raise StandardError, 'A dependency requires a name.'
+      end
       if name.include?("/")
         self.name = name.split("/").first
       else
@@ -23,26 +27,15 @@ module LgPodPlugin
       self.real_name = name
       self.workspace = profile.send(:defined_in_file).dirname
       self.target = profile.send(:current_target_definition)
-
-      unless requirements && !requirements.empty?
-        LRequest.shared.setup_pod_info(self.name, self.workspace, nil)
-        self.lg_pod(self.real_name, requirements)
+      unless requirements && requirements.is_a?(Hash)
+        LRequest.shared.libs.delete(name)
+        LgPodPlugin.log_red "pod `#{name}`, 缺少必要的 [git|commit|tag|branch] 参数"
         return
       end
-
-      first = requirements[0].first
-      if "#{first.class}" == "String"
-        self.version = first
-      elsif "#{first.class}" == "Hash"
-        self.options = first
-      end
-      hash_map = nil
-      last = requirements[0].last
-      if "#{last.class}" == "Hash"
-        hash_map = last
-      end
+      hash_map = requirements
+      hash_map.delete(:path)
       git = hash_map[:git]
-      if hash_map && git
+      if git
         tag = hash_map[:tag]
         branch = hash_map[:branch]
         commit = hash_map[:commit]
@@ -55,95 +48,88 @@ module LgPodPlugin
         elsif branch
           hash_map.delete(:tag)
           hash_map.delete(:commit)
+        else
+          hash_map.delete(:tag)
+          hash_map.delete(:branch)
+          hash_map.delete(:commit)
         end
       end
       self.options = hash_map
       LRequest.shared.setup_pod_info(self.name, self.workspace, hash_map)
-      self.lg_pod(name, requirements)
+      self.install_remote_pod(name, hash_map)
     end
 
     public
-    def lg_pod(name, *requirements)
-      unless name
-        raise StandardError, 'A dependency requires a name.'
-      end
-
-      # 根据pod name安装, pod 'AFNetworking'
-      unless requirements
-        self.target.store_pod(self.real_name)
-        return
-      end
-      # 根据name, version 安装, pod 'AFNetworking', "1.0.1"
-      if self.version && !self.options
-        self.target.store_pod(self.real_name, self.version)
-        return
-      end
-      # 根据name, version 安装, pod 'AFNetworking', "1.0.1", :configurations => ["Debug"]
-      if self.version && self.options
-        hash_map = self.options
-        # hash_map.delete(:cache)
-        self.target.store_pod(self.real_name, self.version, hash_map)
-        return
-      end
-
-      hash_map = self.options
-      unless hash_map.is_a?(Hash)
-        self.target.store_pod(self.real_name)
-        return
-      end
-
-      path = hash_map[:path]
-      if path
-        self.install_local_pod(name, path, options)
+    def install_remote_pod(name, options = {})
+      if options[:git]
+        LRequest.shared.downloader.pre_download_pod
       else
-        hash_map.delete(:path)
-        self.install_remote_pod(name, hash_map)
+        LRequest.shared.libs.delete(name)
+        LgPodPlugin.log_red "pod `#{name}`, 缺少必要的 [git|commit|tag|branch] 参数"
       end
-
     end
 
     public
-    def install_remote_pod(name, options = {})
-      git = options[:git]
-      if git
-        LRequest.shared.downloader.pre_download_pod
-        self.target.store_pod(self.real_name, options)
+    # 执行pod install/update命令
+    def self.run_pod_install(update, libs, options = {})
+      verbose = options[:verbose]
+      repo_update = options[:repo_update]
+      if update
+        if libs.empty?
+          LgPodPlugin.log_red "no external pod update, you can use `pod update` to update --all pods"
+          # LgPodPlugin.log_green "bundle exec arch -x86_64 pod update #{repo_update ? "--repo-update" : "--no-repo-update"} #{verbose ? "--verbose" : ""} "
+          # system("bundle exec arch -x86_64 pod update #{repo_update ? "--repo-update" : "--no-repo-update"} #{verbose ? "--verbose" : ""} ")
+        else
+          pod_names = libs.join(" ")
+          LgPodPlugin.log_green  libs.join("\n")
+          LgPodPlugin.log_green "bundle exec arch -x86_64 pod update #{repo_update ? "--repo-update" : "--no-repo-update"} #{verbose ? "--verbose" : ""} "
+          system("bundle exec arch -x86_64 pod update #{pod_names} #{repo_update ? "--repo-update" : "--no-repo-update"} #{verbose ? "--verbose" : ""} ")
+        end
       else
-        LgPodPlugin.log_red "pod `#{name}` 的参数 path, git , tag , commit不正确"
+        LgPodPlugin.log_green "bundle exec arch -x86_64 pod install #{repo_update ? "--repo-update" : "--no-repo-update"} #{verbose ? "--verbose" : ""}"
+        system("bundle exec arch -x86_64 pod install #{repo_update ? "--repo-update" : "--no-repo-update"} #{verbose ? "--verbose" : ""}")
       end
     end
 
-    public
-    #安装本地pod
-    def install_local_pod(name, relative_path, options = {})
-      hash_map = options
-      absolute_path = Pathname.new(relative_path).expand_path(self.workspace)
-
-      unless absolute_path.exist?
-        hash_map.delete(:path)
-        self.install_remote_pod(name, hash_map)
+    #执行lg install/update命令
+    def self.run(command, options = {})
+      work_space = Pathname(Dir.pwd)
+      LgPodPlugin.log_green "当前工作目录 #{work_space}"
+      podfile_path = work_space.join("Podfile")
+      unless podfile_path.exist?
+        LgPodPlugin.log_red "no such file `Podfile`"
         return
       end
-
-      if Dir.glob(File.expand_path(".git", absolute_path)).empty?
-        hash_map.delete(:path)
-        self.install_remote_pod(name, hash_map)
-        return
+      podfile = Pod::Podfile.from_file(podfile_path)
+      # LgPodPlugin.log_red "podfile => #{podfile} podfile_path => #{podfile_path}"
+      target = podfile.send(:current_target_definition)
+      children = target.children
+      install_hash_map = {}
+      children.each do |s|
+        internal_hash = s.send(:internal_hash)
+        dependencies = internal_hash["dependencies"]
+        next unless dependencies
+        dependencies.each { |e|
+          next unless e.is_a?(Hash)
+          next if (key = e.keys.first) == nil
+          next if (val = e[key].last) == nil
+          next unless val.is_a?(Hash)
+          install_hash_map[key] = val
+        }
       end
-
-      if Dir.glob(File.expand_path("#{name}.podspec", absolute_path)).empty?
-        hash_map.delete(:path)
-        self.install_remote_pod(name, hash_map)
-        return
+      LRequest.shared.libs = install_hash_map
+      LgPodPlugin.log_red "预下载Pod"
+      install_hash_map.each do |key, val|
+        Installer.new(podfile, key, val)
       end
-      # LRequest.shared.git_util.git_local_pod_check(absolute_path)
-      hash_map.delete(:tag)
-      hash_map.delete(:git)
-      # hash_map.delete(:cache)
-      hash_map.delete(:commit)
-      hash_map.delete(:branch)
-      # 安装本地私有组件库
-      self.target.store_pod(self.real_name, hash_map)
+
+      LgPodPlugin.log_red "开始安装pod"
+      #切换工作目录到当前工程下, 开始执行pod install
+      FileUtils.chdir(podfile_path.dirname)
+      libs = LRequest.shared.libs.keys ||= []
+      # 执行pod install/ update 方法入口
+      update_pod = (command == "update")
+      run_pod_install(update_pod, libs, options)
     end
 
   end

data/lib/lg_pod_plugin/l_cache.rb

@@ -6,16 +6,6 @@ require 'cocoapods/downloader/request'
 
 module LgPodPlugin
 
-  class LCachePodInfo
-    REQUIRED_ATTRS ||= %i[sha tag name path branch timestamp].freeze
-    attr_accessor(*REQUIRED_ATTRS)
-
-    def initialize
-      super
-    end
-
-  end
-
   class LCache
     REQUIRED_ATTRS ||= %i[workspace cache_root].freeze
     attr_accessor(*REQUIRED_ATTRS)
@@ -24,44 +14,15 @@ module LgPodPlugin
       self.workspace = workspace
       self.cache_root = LFileManager.cache_workspace(self.workspace)
     end
-    
-    #根据git branch commit 返回请求参数用来获取缓存 path
-    def get_request_params(git, branch, tag, commit)
-      options = { :git => git }
-      if git && tag
-        options[:tag] = tag
-        options[:commit] = commit
-      elsif git && branch
-        if commit
-          options[:commit] = commit
-        else
-          new_commit_id = LGitUtil.git_ls_remote_refs(git, branch, nil, commit)
-          options[:commit] = new_commit_id
-        end
-      elsif git && commit
-        options[:commit] = commit
-      end
-      options
-    end
+
     #判断缓存是否存在且有效命中缓存
-    def find_pod_cache(name, git, branch, tag, commit, is_update)
-      if is_update
-        hash_map = self.get_request_params(git, branch, tag, commit)
-      else 
-        if LRequest.shared.lock_params
-          lock_tag = LRequest.shared.lock_params[:tag]
-          lock_branch = LRequest.shared.lock_params[:branch]
-          lock_commit = LRequest.shared.lock_params[:commit]
-          hash_map = self.get_request_params(git, lock_branch, lock_tag, lock_commit)
-        else
-          hash_map = self.get_request_params(git, branch, tag, commit)
-        end
-      end
+    def find_pod_cache(name)
+      hash_map = LRequest.shared.get_cache_key_params
       request = LCache.download_request(name, hash_map)
       destination = LCache.path_for_pod(request, {})
       cache_pod_spec = LCache.path_for_spec(request, {})
       if File.exist?(destination) && File.exist?(cache_pod_spec)
-         false
+        false
       else
         true
       end
@@ -112,7 +73,6 @@ module LgPodPlugin
           end
         end
       end
-
       [result, local_specs]
     end
 
@@ -180,16 +140,20 @@ module LgPodPlugin
 
     # 拷贝 pod 缓存文件到 sandbox
     def self.cache_pod(name, target, options = {})
-      request = LCache.download_request(name, options)
+      hash_map = Hash.new.deep_merge(options).reject do |key, val|
+        !key || !val
+      end
+      request = LCache.download_request(name, hash_map)
       result, pods_pecs = get_local_spec(request, target)
       result.location = nil
+      result.checkout_options = hash_map
       pods_pecs.each do |s_name, s_spec|
-        destination = path_for_pod(request, {})
+        destination = path_for_pod(request, :name => name, :params => hash_map)
         unless File.exist?(destination)
           LgPodPlugin.log_green "Copying #{name} from `#{target}` to `#{destination}` "
           copy_and_clean(target, destination, s_spec)
         end
-        cache_pod_spec = path_for_spec(request, {})
+        cache_pod_spec = path_for_spec(request, :name => name, :params => result.checkout_options)
         unless File.exist?(cache_pod_spec)
           write_spec(s_spec, cache_pod_spec)
         end
@@ -201,36 +165,6 @@ module LgPodPlugin
 
     end
 
-    # 根据下载参数生产缓存的路径
-    def get_download_path(name)
-      # hash_map = {:git => git}
-      # if git && tag
-      #   hash_map[:tag] = tag
-      # elsif git && commit
-      #   hash_map[:commit] = commit
-      # elsif git && branch
-      #   hash_map[:commit] = commit
-      # end
-      # request = LCache.download_request(name, hash_map)
-      # self.slug(name, request.params, nil)
-        self.cache_root.join(name)
-    end
-
-    # 根据下载参数生产缓存目录
-    def slug(params, spec)
-      path = ""
-      checksum = spec&.checksum && '-' << spec.checksum[0, 5]
-      opts = params.to_a.sort_by(&:first).map { |k, v| "#{k}=#{v}" }.join('-')
-      digest = Digest::MD5.hexdigest(opts)
-      if digest
-        path += "#{digest}"
-      end
-      if checksum
-        path += "#{checksum}"
-      end
-      path
-    end
-
   end
 
 end

data/lib/lg_pod_plugin/l_util.rb

@@ -1,26 +1,30 @@
 require  'zip'
+require_relative 'log'
 module LgPodPlugin
   class LUtils
     def self.unzip_file (zip_file, dest_dir)
       begin
+        LgPodPlugin.log_green "正在解压`.zip`文件"
         Zip::File.open(zip_file) do |file|
           file.each do |f|
             file_path = File.join(dest_dir, f.name)
             FileUtils.mkdir_p(File.dirname(file_path))
-            next if file_path.include?("Example")
             # next if file_path.include?("LICENSE")
+            next if file_path.include?("Example")
             next if file_path.include?(".gitignore")
             next if file_path.include?("node_modules")
             next if file_path.include?("package.json")
             next if file_path.include?(".swiftlint.yml")
             next if file_path.include?("_Pods.xcodeproj")
             next if file_path.include?("package-lock.json")
+            next if file_path.include?("README.md")
+            next if file_path.include?("commitlint.config.js")
             file.extract(f, file_path)
           end
         end
         return true
       rescue => err
-        puts err
+        LgPodPlugin.log_red "解压zip失败, error => #{err}"
         return false
       end
 

data/lib/lg_pod_plugin/request.rb

@@ -9,7 +9,7 @@ module LgPodPlugin
 
   class LRequest
     include Singleton
-    REQUIRED_ATTRS ||= %i[name options workspace cache downloader git_util lock_info lock_params is_update token].freeze
+    REQUIRED_ATTRS ||= %i[name request_params workspace cache downloader git_util lock_info checkout_options is_update token single_git libs].freeze
     attr_accessor(*REQUIRED_ATTRS)
 
     def is_update_pod
@@ -32,108 +32,117 @@ module LgPodPlugin
       lock_file = self.workspace.join("Podfile.lock")
       if lock_file.exist?
         json = YAML.load_file(lock_file.to_path)
-        json["EXTERNAL SOURCES"]
+        external_source = json["EXTERNAL SOURCES"]
+        checkout_options = json["CHECKOUT OPTIONS"]
+        { "external_source" => external_source, "checkout_options" => checkout_options }
       else
         nil
       end
     end
 
-    def get_lock_params(git, branch, tag, commit)
-      unless self.lock_info
-        return nil
-      end
-      current_pod_info = self.lock_info[name]
-      unless current_pod_info
-        return nil
-      end
-      lock_commit = current_pod_info[:commit]
-      if git && tag
-        lock_tag = current_pod_info[:tag]
-        if lock_tag == tag
-          return { :git => git, :commit => lock_commit, :tag => lock_tag }
-        else
-          return nil
-        end
+    # 获取缓存用的hash_map
+    def get_cache_key_params
+      hash_map = Hash.new
+      git = self.checkout_options[:git] ||= self.request_params[:git]
+      tag = self.checkout_options[:tag] ||= self.request_params[:tag]
+      branch = self.checkout_options[:branch] ||= self.request_params[:branch]
+      commit = self.checkout_options[:commit] ||= self.request_params[:commit]
+      return hash_map unless git
+      hash_map[:git] = git
+      if git && commit
+        hash_map[:commit] = commit
+      elsif git && tag
+        hash_map[:tag] = tag
       elsif git && branch
-        lock_branch = current_pod_info[:branch]
-        if branch == lock_branch
-          return { :git => git, :commit => lock_commit, :branch => lock_branch}
+        if commit
+          hash_map[:commit] = commit
         else
-          return nil
+          _, new_commit_id = LGitUtil.git_ls_remote_refs(git, branch, nil, commit)
+          hash_map[:commit] = new_commit_id if new_commit_id
         end
-      elsif commit == lock_commit
-        return { :git => git, :commit => lock_commit }
       else
-        nil
+        _, new_commit_id = LGitUtil.git_ls_remote_refs(git, branch, nil, commit)
+        hash_map[:commit] = new_commit_id if new_commit_id
       end
+      hash_map
     end
 
-    def setup_pod_info(name, workspace, options = {})
-      self.name = name
-      hash_map = options
-      tag = hash_map[:tag]
-      git = hash_map[:git]
-      path = hash_map[:path]
-      commit = hash_map[:commit]
-      branch = hash_map[:branch]
-      self.workspace = workspace
-      self.is_update = self.is_update_pod
-      if self.lock_info == nil
-        self.lock_info = self.get_lock_info
+    private
+
+    def get_lock_params
+      unless self.lock_info
+        self.lock_info = {"external_source" => {}, "checkout_options" => {}}
       end
-      self.lock_params = self.get_lock_params(git, branch, tag, commit)
+      external_source = self.lock_info["external_source"][self.name] ||= {}
+      checkout_options = self.lock_info["checkout_options"][self.name] ||= {}
+
+      git = self.checkout_options[:git]
+      tag = self.checkout_options[:tag]
+      commit = self.checkout_options[:commit]
+      branch = self.checkout_options[:branch]
+
+      # lock_git = external_source[:git]
+      # lock_tag = external_source[:tag]
+      lock_commit = checkout_options[:commit]
+      lock_branch = external_source[:branch]
+      hash_map = Hash.new
+      hash_map[:git] = git if git
       if git && tag
-        if self.lock_params && !self.is_update
-          lock_tag = self.lock_params[:tag]
-          lock_commit = self.lock_params[:commit]
-          if lock_tag == tag && lock_commit
-            hash_map[:commit] = lock_commit
-          else
-            _, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
-            hash_map[:commit] = new_commit
-          end
-        else
-          _, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag,commit)
-          hash_map[:commit] = new_commit
-        end
-      elsif git && commit
-        if self.lock_params && !self.is_update
-          hash_map[:commit] = commit
-        else
-          new_branch, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
-          if new_commit
-            hash_map[:commit] = new_commit
-          end
-          if new_branch
-            hash_map[:branch] = new_branch
-          end
-        end
+        hash_map[:tag] = tag
+        return hash_map
       elsif git && branch
-        if self.lock_params && !self.is_update
-          lock_branch = self.lock_params[:branch]
-          lock_commit = self.lock_params[:commit]
-          if branch == lock_branch && lock_commit
-            hash_map[:commit] = lock_commit
-          else
-            _, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
-            hash_map[:commit] = new_commit
-          end
+        if branch == lock_branch && !self.is_update
+          hash_map[:branch] = branch if branch
+          hash_map[:commit] = lock_commit if lock_commit
+          return hash_map
         else
+          hash_map[:branch] = branch if branch
           _, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
-          hash_map[:commit] = new_commit
+          hash_map[:commit] = new_commit if new_commit
+          return hash_map
         end
-      elsif !path
+      elsif git && commit
+        hash_map[:commit] = commit if commit
+        return hash_map
+      else
         new_branch, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
-        hash_map[:commit] = new_commit
-        hash_map[:branch] = new_branch
+        hash_map[:commit] = new_commit if new_commit
+        hash_map[:branch] = new_branch if new_branch
+      end
+      hash_map
+    end
+
+    private
+    #获取下载参数
+    def get_request_params
+      self.is_update = self.is_update_pod
+      if self.lock_info == nil
+        self.lock_info = self.get_lock_info
+      end
+      Hash.new.merge!(self.get_lock_params)
+    end
+
+    public
+    def setup_pod_info(name, workspace, options = {})
+      self.name = name
+      tag = options[:tag]
+      git = options[:git]
+      commit = options[:commit]
+      branch = options[:branch]
+      self.workspace = workspace
+      if (git && branch) || (git && commit) || (git && tag)
+        self.single_git = false
+      else
+        self.single_git = true
       end
+      self.checkout_options = Hash.new.deep_merge(options)
+      self.request_params = self.get_request_params
       if self.token == nil
         self.token = self.request_gitlab_token(git)
       end
-      self.options = hash_map
       self.cache = LCache.new(self.workspace)
-      self.git_util = LGitUtil.new(name, hash_map)
-      self.downloader = LDownloader.new(name, hash_map)
+      self.git_util = LGitUtil.new(name, self.checkout_options)
+      self.downloader = LDownloader.new(name, self.checkout_options)
     end
 
     def self.shared
@@ -148,7 +157,7 @@ module LgPodPlugin
         #81.69.242.162
         uri = URI('http://81.69.242.162:8080/v1/member/user/gitlab/token')
         # uri = URI('http://127.0.0.1:8080/v1/member/user/gitlab/token')
-        params = {"url" => git}
+        params = { "url" => git }
         res = Net::HTTP.post_form(uri, params)
         json = JSON.parse(res.body)
       rescue
@@ -157,8 +166,7 @@ module LgPodPlugin
       unless json
         return nil
       end
-      token = json["data"]["token"]
-      return token
+      json["data"]["token"]
     end
 
   end

data/lib/lg_pod_plugin/version.rb

@@ -1,3 +1,3 @@
 module LgPodPlugin
-  VERSION = "1.0.8"
+  VERSION = "1.0.10"
 end

data/lib/lg_pod_plugin.rb

@@ -1,4 +1,5 @@
 require 'git'
+require 'claide'
 require 'cocoapods-downloader'
 require "lg_pod_plugin/version"
 require_relative 'lg_pod_plugin/log'
@@ -10,12 +11,15 @@ require_relative 'lg_pod_plugin/downloader'
 require 'cocoapods-core/podfile/target_definition'
 
 module LgPodPlugin
-
+  autoload :Command, 'command/command'
   class Error < StandardError; end
 
-  public
-  # 对 Profile 方法进行拓展
-  def pod(name, *requirements)
-    Installer.new(self, name, requirements)
+  def self.install(options = {})
+    LgPodPlugin::Installer.run("install", options)
+  end
+
+  def self.update(options = {})
+    LgPodPlugin::Installer.run("update", options)
   end
+
 end