lg_pod_plugin 1.1.3 → 1.1.4

data/lib/lg_pod_plugin/downloader/downloader.rb

@@ -0,0 +1,156 @@
+
+require 'cocoapods-core'
+require_relative '../git/http_download'
+require_relative '../git/git_download'
+
+module LgPodPlugin
+
+  class LDownloader
+    attr_accessor :request
+
+    def initialize(pod)
+      self.request = LRequest.new(pod)
+    end
+
+    # 预下载处理
+    def pre_download_pod
+      name = self.request.name
+      if self.request.lg_spec
+        podspec = self.request.lg_spec.spec
+      else
+        podspec = nil
+      end
+      checkout_options = Hash.new.merge!(self.request.checkout_options)
+      http = checkout_options[:http]
+      git = checkout_options[:git]
+      tag = checkout_options[:tag]
+      branch = checkout_options[:branch]
+      checkout_options[:name] = name if name
+      checkout_options[:spec] = self.request.lg_spec if podspec
+      unless branch
+        branch = self.request.params[:branch] if self.request.params[:branch]
+        checkout_options[:branch] = branch if branch
+      end
+      commit = checkout_options[:commit]
+      unless commit
+        commit = self.request.params[:commit] if self.request.params[:commit]
+        checkout_options[:commit] = commit if commit
+      end
+      if branch
+        LgPodPlugin.log_green "Using `#{name}` (#{branch})"
+      elsif tag
+        LgPodPlugin.log_green "Using `#{name}` (#{tag})"
+      elsif commit
+        LgPodPlugin.log_green "Using `#{name}` (#{commit})"
+      elsif http
+        version = checkout_options[:version]
+        LgPodPlugin.log_green "Using `#{name}` (#{version})"
+      else
+        LgPodPlugin.log_green "Using `#{name}`"
+      end
+      hash_map = self.request.get_cache_key_params
+      # 发现本地有缓存, 不需要更新缓存
+      if self.request.single_git
+        pod_is_exist, destination, cache_pod_spec = LCache.new.pod_cache_exist(name, hash_map, podspec, self.request.released_pod)
+      else
+        pod_is_exist, destination, cache_pod_spec = LCache.new.pod_cache_exist(name, hash_map, podspec, self.request.released_pod)
+      end
+      if pod_is_exist
+        is_delete = self.request.params["is_delete"] ||= false
+        LProject.shared.need_update_pods.delete(name) if is_delete
+        self.request.checkout_options.delete(:branch) if commit
+        self.request.checkout_options[:commit] = commit if commit
+        LgPodPlugin.log_green "find the cache of `#{name}`, you can use it now."
+         nil
+      else
+        LgPodPlugin.log_green "find the new commit of `#{name}`, Git downloading now."
+        # 本地 git 下载 pod 目录
+        download_params = self.pre_download_git_repository(checkout_options)
+        if download_params && download_params.is_a?(Hash)
+          download_params["destination"] = destination
+          download_params["cache_pod_spec_path"] = cache_pod_spec
+          podspec = download_params["podspec"]
+          podspec_content = download_params["podspec_content"]
+          if podspec
+            podspec_json = podspec.to_pretty_json
+            download_params["podspec_json"] = podspec_json if podspec
+            download_params["prepare_command"] = podspec.prepare_command if podspec
+            download_params.delete("podspec")
+            unless self.request.lg_spec
+              self.request.lg_spec = podspec
+            end
+          elsif podspec_content
+            path = download_params["path"]
+            podspec_path = path + "/#{name}.podspec"
+            begin
+              File.open(podspec_path,"w+") do|f|
+                f.write podspec_content
+              end
+            end
+            if File.exist?(podspec_path)
+              lg_spec = LgPodPlugin::PodSpec.form_file podspec_path
+              if lg_spec
+                self.request.lg_spec = lg_spec
+                download_params["podspec_json"] = lg_spec.to_pretty_json
+                download_params["source_files"] = lg_spec.source_files.keys
+                download_params["prepare_command"] = lg_spec.prepare_command if lg_spec.prepare_command
+                download_params.delete("podspec_content")
+              else
+                download_params["source_files"] = ["All"]
+                download_params["prepare_command"] = nil
+                download_params["podspec_json"] = podspec_content
+                download_params.delete("podspec_content")
+              end
+            end
+            FileUtils.rm_rf podspec_path
+          end
+          return download_params
+        elsif File.exist?(download_params.to_s) && download_params
+          FileUtils.chdir download_params
+          LgPodPlugin::LCache.cache_pod(name, download_params.to_path, { :git => git }, podspec, self.request.released_pod) if self.request.single_git
+          LgPodPlugin::LCache.cache_pod(name, download_params.to_path, self.request.get_cache_key_params,podspec, self.request.released_pod)
+          FileUtils.chdir(LFileManager.download_director)
+          FileUtils.rm_rf(download_params)
+          self.request.checkout_options.delete(:branch) if commit
+          self.request.checkout_options[:commit] = commit if commit
+        end
+        nil
+      end
+
+    end
+
+    def pre_download_git_repository(checkout_options = {})
+      lg_pod_path = LFileManager.cache_workspace(LProject.shared.workspace)
+      lg_pod_path.mkdir(0700) unless lg_pod_path.exist?
+      download_repository_strategy(lg_pod_path, checkout_options)
+    end
+
+    # 根据不同 git 源 选择下载策略
+    def download_repository_strategy(path, checkout_options = {})
+      FileUtils.chdir(path)
+      git = checkout_options[:git]
+      http = checkout_options[:http]
+      if http
+        begin
+          checkout_options[:path] = path
+          http_download = LgPodPlugin::HTTPDownloader.new(checkout_options)
+          http_download.download
+        rescue => exception
+          LgPodPlugin.log_red "异常信息: #{$!}"
+          LgPodPlugin.log_yellow " 异常位置: #{$@}"
+          return nil
+        end
+      elsif git
+        checkout_options[:path] = path
+        checkout_options[:config] = self.request.config if self.request.config
+        git_download = LgPodPlugin::GitDownloader.new(checkout_options)
+        return git_download.download
+      else
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/lg_pod_plugin/{l_cache.rb → downloader/l_cache.rb}

@@ -1,4 +1,4 @@
-require 'git'
+# require 'git'
 require 'cocoapods/downloader'
 require 'cocoapods/downloader/cache'
 require 'cocoapods/downloader/response'
@@ -7,25 +7,32 @@ require 'cocoapods/downloader/request'
 module LgPodPlugin
 
   class LCache
-    REQUIRED_ATTRS ||= %i[workspace cache_root].freeze
-    attr_accessor(*REQUIRED_ATTRS)
 
-    def initialize(workspace)
-      self.workspace = workspace
-      self.cache_root = LFileManager.cache_workspace(self.workspace)
+    def initialize
+    end
+
+    public
+    def pod_cache_exist(name, options, spec = nil, released_pod = false)
+      destination, cache_pod_spec = self.find_pod_cache name, options, spec, released_pod
+      target = LProject.shared.workspace.join("Pods").join(name)
+      if (File.exist?(destination) && !destination.children.empty?) && File.exist?(target) && !target.children.empty?
+        [true, destination, cache_pod_spec]
+      else
+        [false, destination, cache_pod_spec]
+      end
     end
 
     #判断缓存是否存在且有效命中缓存
-    def find_pod_cache(name, options)
+    public
+    def find_pod_cache(name, options, spec = nil, released_pod = false)
       hash_map = Hash.new.merge!(options)
-      request = LCache.download_request(name, hash_map)
+      if hash_map.has_key?(:version)
+        hash_map.delete(:version)
+      end
+      request = LCache.download_request(name, hash_map, spec, released_pod)
       destination = LCache.path_for_pod(request, {})
       cache_pod_spec = LCache.path_for_spec(request, {})
-      if (File.exist?(destination) && File.exist?(cache_pod_spec))
-        false
-      else
-        true
-      end
+      [destination, cache_pod_spec]
     end
 
     def self.root_path
@@ -33,10 +40,12 @@ module LgPodPlugin
       Pathname(path)
     end
 
-    def self.download_request(name, params)
-      spec = LRequest.shared.checkout_options[:spec] ||= nil
-      released_pod = LRequest.shared.checkout_options[:release_pod] ||= false
-      Pod::Downloader::Request.new(spec: spec, released: released_pod, name: name, params: params)
+    def self.download_request(name, params, spec = nil, released_pod = false)
+      if released_pod
+        Pod::Downloader::Request.new(spec: spec, released: true , name: name, params: params)
+      else
+        Pod::Downloader::Request.new(spec: nil, released: false , name: name, params: params)
+      end
     end
 
     def self.path_for_pod(request, slug_opts = {})
@@ -100,6 +109,14 @@ module LgPodPlugin
       end
     end
 
+    def self.clean_pod_unused_files(destination, spec)
+      specs_by_platform = group_sub_specs_by_platform(spec)
+      self.write_lock(destination) do
+        Pod::Installer::PodSourcePreparer.new(spec, destination).prepare!
+        Pod::Sandbox::PodDirCleaner.new(destination, specs_by_platform).clean!
+      end
+    end
+
     def self.write_lock(location, &block)
       self.lock(location, File::LOCK_EX, &block)
     end
@@ -133,6 +150,7 @@ module LgPodPlugin
       false
     end
 
+    public
     def self.write_spec(spec, path)
       path.dirname.mkpath
       Pod::Downloader::Cache.write_lock(path) do
@@ -143,15 +161,16 @@ module LgPodPlugin
     end
 
     # 拷贝 pod 缓存文件到 sandbox
-    def self.cache_pod(name, target, options = {})
+    public
+    def self.cache_pod(name, target, options = {}, spec = nil, released_pod = false)
       checkout_options = Hash.new.deep_merge(options).reject do |key, val|
         !key || !val
       end
-      request = LCache.download_request(name, checkout_options)
-      result, pods_pecs = get_local_spec(request, target)
-      pods_pecs.each do |s_name, s_spec|
+      request = LCache.download_request(name, checkout_options, spec, released_pod)
+      _, pods_pecs = get_local_spec(request, target)
+      pods_pecs.each do |_, s_spec|
         destination = path_for_pod(request, :name => name, :params => checkout_options)
-        unless File.exist?(destination)
+        if !File.exist?(destination) || destination.children.empty?
           LgPodPlugin.log_green "Copying #{name} from `#{target}` to `#{destination}` "
           copy_and_clean(target, destination, s_spec)
         end

data/lib/lg_pod_plugin/downloader/request.rb

@@ -0,0 +1,233 @@
+require 'net/http'
+# require 'singleton'
+require 'cocoapods-core'
+
+module LgPodPlugin
+
+  class LRequest
+    attr_reader :target
+    attr_reader :name
+    attr_accessor :lg_spec
+    attr_reader :released_pod
+    attr_accessor :single_git
+    attr_accessor :config
+    attr_accessor :net_ping
+    attr_accessor :params
+    attr_accessor :lockfile
+    attr_accessor :checkout_options
+    def initialize(pod)
+      @name = pod.name
+      @target = pod.target
+      @released_pod = pod.released_pod
+      @checkout_options = pod.checkout_options
+      if pod.spec
+        @lg_spec = pod.spec
+      end
+      self.preprocess_request
+    end
+
+    def preprocess_request
+      http = self.checkout_options[:http]
+      if http
+        self.config = nil
+        self.net_ping = nil
+        self.single_git = false
+        self.params = Hash.new
+      else
+        tag = self.checkout_options[:tag]
+        git = self.checkout_options[:git]
+        commit = self.checkout_options[:commit]
+        branch = self.checkout_options[:branch]
+        if (git && branch) || (git && commit) || (git && tag)
+          self.single_git = false
+        else
+          self.single_git = true
+        end
+        self.net_ping = Ping.new(git)
+        self.config = LConfig.get_config(git, self.net_ping.uri)
+        self.params = self.get_request_params
+      end
+    end
+
+    public
+    def get_lockfile
+      self.lockfile = LgPodPlugin::LockfileModel.from_file
+    end
+
+    # 获取缓存用的hash_map
+    public
+    def get_cache_key_params
+      options = Hash.new.merge!(self.checkout_options)
+      hash_map = Hash.new
+      http = options[:http]
+      if http
+        hash_map[:http] = http
+        return hash_map
+      end
+      git = options[:git] ||= self.params[:git]
+      tag = options[:tag] ||= self.params[:tag]
+      branch = options[:branch] ||= self.params[:branch]
+      commit = options[:commit] ||= self.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 && commit
+        hash_map[:commit] = commit
+      end
+      hash_map
+    end
+
+    public
+    def get_lock_params
+      begin
+        _release_pods = self.lockfile.release_pods ||= []
+        _external_source = (self.lockfile.external_sources_data[self.name])
+        _external_source = {} unless _external_source
+        _checkout_options = self.lockfile.checkout_options_for_pod_named(self.name)
+      rescue
+        _release_pods = {}
+        _external_source = {}
+        _checkout_options = {}
+      end
+
+      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] ||= _checkout_options[:git]
+      lock_tag = _external_source[:tag] ||= _release_pods[self.name]
+      lock_branch = _external_source[:branch] ||= ""
+      lock_commit = _checkout_options[:commit] ||= ""
+
+      hash_map = Hash.new
+      hash_map[:git] = git if git
+      if git && tag
+        hash_map[:tag] = tag
+        if tag != lock_tag
+          hash_map["is_delete"] = false
+        else
+          hash_map["is_delete"] = true
+        end
+        return hash_map
+      elsif git && branch
+        hash_map[:branch] = branch
+        if lock_commit && !lock_commit.empty? && !LProject.shared.update
+          pod_info = LSqliteDb.shared.query_branch_with_sha(self.name, git, lock_commit)
+          lock_branch = pod_info[:branch] if lock_branch.empty?
+          new_commit = pod_info[:sha] ||= ""
+          if lock_branch == branch && new_commit == lock_commit
+            hash_map[:commit] = lock_commit
+            hash_map["is_delete"] = true
+            return hash_map
+          end
+        end
+        _, new_commit = git_ls_remote_refs(self.name, git, branch)
+        if new_commit && !new_commit.empty?
+          hash_map[:commit] = new_commit
+        elsif lock_commit && !lock_commit.empty?
+          hash_map[:commit] = lock_commit
+        end
+        if !new_commit || !lock_commit || new_commit.empty? || lock_commit.empty?
+          hash_map["is_delete"] = false
+        elsif new_commit != lock_commit
+          hash_map["is_delete"] = false
+        else
+          hash_map["is_delete"] = true
+        end
+      elsif git && commit
+        if commit != lock_commit
+          hash_map["is_delete"] = false
+        else
+          hash_map["is_delete"] = true
+        end
+        hash_map[:commit] = commit
+        return hash_map
+      else
+        if lock_git && !LProject.shared.update
+          id = LPodLatestRefs.get_pod_id(self.name, git)
+          pod_info = LSqliteDb.shared.query_pod_refs(id)
+          if pod_info&.commit
+            if pod_info
+              new_commit = pod_info.commit
+            else
+              new_commit = nil
+            end
+            if pod_info
+              new_branch = pod_info.branch
+            else
+              new_branch = nil
+            end
+            if new_commit
+              hash_map[:commit] = new_commit
+            end
+            if new_branch
+              hash_map[:branch] = new_branch
+            end
+            hash_map["is_delete"] = true
+            return hash_map
+          end
+        end
+        new_branch, new_commit = git_ls_remote_refs(self.name, git, nil)
+        hash_map[:branch] = new_branch if new_branch
+        if new_commit && !new_commit.empty?
+          hash_map[:commit] = new_commit
+        end
+        if !new_commit || new_commit.empty?
+          hash_map["is_delete"] = true
+        else
+          hash_map["is_delete"] = false
+        end
+      end
+      hash_map
+    end
+
+    public
+
+    #获取下载参数
+    def get_request_params
+      unless self.lockfile
+        self.lockfile = self.get_lockfile
+      end
+      Hash.new.merge!(self.get_lock_params)
+    end
+
+    # 获取最新的一条 commit 信息
+    def git_ls_remote_refs(name, git, branch)
+      ip = self.net_ping.ip
+      network_ok = self.net_ping.network_ok
+      return [nil, nil] unless (ip && network_ok)
+      if branch
+        new_commit, _ = GitLabAPI.request_github_refs_heads git, branch, self.net_ping.uri
+        unless new_commit
+          id = LPodLatestRefs.get_pod_id(name, git)
+          pod_info = LSqliteDb.shared.query_pod_refs(id)
+          new_commit = pod_info ? pod_info.commit : nil
+          return [branch, new_commit]
+        end
+        if new_commit
+          LSqliteDb.shared.insert_pod_refs(name, git, branch, nil, new_commit)
+        end
+        [branch, new_commit]
+      else
+        new_commit, new_branch = GitLabAPI.request_github_refs_heads git, nil, self.net_ping.uri
+        unless new_commit
+          id = LPodLatestRefs.get_pod_id(name, git)
+          pod_info = LSqliteDb.shared.query_pod_refs(id)
+          new_commit = pod_info ? pod_info.commit : nil
+          new_branch = pod_info ? pod_info.branch : nil
+          return [new_branch, new_commit]
+        end
+        if new_commit
+          LSqliteDb.shared.insert_pod_refs(name, git, new_branch, nil, new_commit)
+        end
+        [new_branch, new_commit]
+      end
+    end
+
+  end
+
+end

data/lib/lg_pod_plugin/git/git_clone.rb

@@ -0,0 +1,85 @@
+require 'uri'
+require_relative '../utils/l_util'
+
+module LgPodPlugin
+
+  class GitRepository
+    private
+    attr_reader :checkout_options
+    public
+    REQUIRED_ATTRS ||= %i[git tag name commit branch config path].freeze
+    attr_accessor(*REQUIRED_ATTRS)
+    def initialize(checkout_options = {})
+      self.git = checkout_options[:git]
+      self.tag = checkout_options[:tag]
+      self.name = checkout_options[:name]
+      self.path = checkout_options[:path]
+      self.config = checkout_options[:config]
+      self.commit = checkout_options[:commit]
+      self.branch = checkout_options[:branch]
+      @checkout_options = checkout_options
+    end
+
+    def download
+      if self.git && self.tag
+        self.git_clone_by_tag(self.path, "lg_temp_pod")
+      elsif self.git && self.branch
+        self.git_clone_by_branch self.path, "lg_temp_pod", self.branch
+      elsif self.git && self.commit
+        self.git_clone_by_commit self.path, "lg_temp_pod"
+      end
+    end
+
+    def git_clone_by_branch(path, temp_name, branch = nil)
+      new_branch = branch ? branch : nil
+      download_temp_path = path.join(temp_name)
+      if self.git && new_branch
+        git_download_command(temp_name, self.git, new_branch, nil)
+      else
+        git_download_command(temp_name, self.git, nil, nil)
+        if File.exist?(temp_name)
+          system("git -C #{download_temp_path.to_path} rev-parse HEAD")
+        end
+      end
+      download_temp_path
+    end
+
+    def git_clone_by_tag(path, temp_name)
+      git_download_command(temp_name, self.git, nil, self.tag)
+      path.join(temp_name)
+    end
+
+    # git clone commit
+    def git_clone_by_commit(path, temp_name)
+      Git.init(temp_name)
+      FileUtils.chdir(temp_name)
+      LgPodPlugin.log_blue "git clone #{self.git}"
+      system("git remote add origin #{self.git}")
+      system("git fetch origin #{self.commit}")
+      system("git reset --hard FETCH_HEAD")
+      path.join(temp_name)
+    end
+
+    # 封装 git clone命令
+    def git_download_command(temp_name, git, branch, tag)
+      cmds = ['git']
+      cmds << "clone"
+      cmds << "#{git}"
+      cmds << "#{temp_name} "
+      cmds << "--template="
+      cmds << "--single-branch --depth 1"
+      if branch
+        cmds << "--branch"
+        cmds << branch
+      elsif tag
+        cmds << "--branch"
+        cmds << tag
+      end
+      cmds_to_s = cmds.join(" ")
+      LgPodPlugin.log_blue cmds_to_s
+      system(cmds_to_s)
+    end
+
+  end
+
+end

data/lib/lg_pod_plugin/git/git_download.rb

@@ -0,0 +1,53 @@
+require_relative 'git_clone'
+require_relative 'gitlab_api'
+require_relative 'gitlab_archive'
+require_relative 'github_archive'
+require_relative '../config/l_config'
+require_relative '../downloader/request'
+
+module  LgPodPlugin
+  class GitDownloader
+    attr_accessor :git
+    attr_accessor :config
+    attr_accessor :checkout_options
+    def initialize(checkout_options = {})
+      self.git = checkout_options[:git]
+      self.config = checkout_options[:config]
+      self.checkout_options = checkout_options
+    end
+
+    #开始下载
+    public
+    def download
+      begin
+        if self.is_use_gitlab_archive_file(self.git)
+          git_archive = GitLabArchive.new(self.checkout_options)
+          return git_archive.download
+        elsif self.git.include?("https://github.com")
+          github_archive = GitHubArchive.new(self.checkout_options)
+          return github_archive.download
+        else
+          git_clone = GitRepository.new(checkout_options)
+          return git_clone.download
+        end
+      rescue
+        LgPodPlugin.log_red "异常信息: #{$!}"
+        LgPodPlugin.log_yellow " 异常位置: #{$@}"
+        git_clone = GitRepository.new(checkout_options)
+        return  git_clone.download
+      end
+    end
+
+    # 是否能够使用 gitlab 下载 zip 文件
+    public
+    def is_use_gitlab_archive_file(git)
+      return false unless self.config&.access_token
+      return true if self.config.project
+      project_name = LUtils.get_git_project_name(git)
+      self.config.project = GitLabAPI.request_project_info(config.host, project_name, config.access_token, git)
+      (self.config.project != nil)
+    end
+
+
+  end
+end