lg_pod_plugin 1.0.3 → 1.0.4

data/lib/lg_pod_plugin/install.rb

@@ -3,16 +3,16 @@ require 'git'
 require 'cgi'
 require 'sqlite3'
 require 'cocoapods'
+require_relative 'request'
 require_relative 'database'
 require_relative 'download'
 require_relative 'git_util'
-require_relative 'pod_spec'
 
 module LgPodPlugin
 
   class Installer
 
-    REQUIRED_ATTRS ||= %i[name version options profile target real_name downloader git_util].freeze
+    REQUIRED_ATTRS ||= %i[name version options target real_name workspace].freeze
     attr_accessor(*REQUIRED_ATTRS)
 
     def initialize(profile, name, *requirements)
@@ -22,12 +22,11 @@ module LgPodPlugin
         self.name = name
       end
       self.real_name = name
-      self.profile = profile
-      self.git_util = GitUtil.new
-      self.downloader = Downloader.new
+      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)
         return
       end
@@ -38,38 +37,52 @@ module LgPodPlugin
       elsif "#{first.class}" == "Hash"
         self.options = first
       end
-
-      hash_map = requirements[0].last
-      if "#{hash_map.class}" == "Hash"
-        self.options = hash_map
+      hash_map = nil
+      last = requirements[0].last
+      if "#{last.class}" == "Hash"
+        hash_map = last
+      end
+      git = hash_map[:git]
+      if hash_map && git
+        tag = hash_map[:tag]
+        branch = hash_map[:branch]
+        commit = hash_map[:commit]
+        if tag
+          hash_map.delete(:branch)
+          hash_map.delete(:commit)
+        elsif commit
+          hash_map.delete(:tag)
+          hash_map.delete(:branch)
+        elsif branch
+          hash_map.delete(:tag)
+          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)
-
     end
 
     public
-    # @param [Object] name
-    # @param [Hash] options
-    # @return [Object] nil
     def lg_pod(name, *requirements)
       unless name
         raise StandardError, 'A dependency requires a name.'
       end
 
+      # 根据pod name安装, pod 'AFNetworking'
       if !requirements
         self.target.store_pod(self.real_name)
         return
       end
-
+      # 根据name, verison 安装, pod 'AFNetworking', "1.0.1"
       if self.version && !self.options
         self.target.store_pod(self.real_name, self.version)
         return
       end
-
+      # 根据name, verison 安装, pod 'AFNetworking', "1.0.1", :configurations => ["Debug"]
       if self.version && self.options
         hash_map = self.options
-        hash_map.delete(:depth)
+        # hash_map.delete(:cache)
         self.target.store_pod(self.real_name, self.version, hash_map)
         return
       end
@@ -80,85 +93,47 @@ module LgPodPlugin
         return
       end
 
-      real_path = nil
-      tag = hash_map[:tag]
-      url = hash_map[:git]
       path = hash_map[:path]
-      commit = hash_map[:commit]
-      branch = hash_map[:branch]
-      is_cache = options[:depth]
       if path
-        profile_path = self.profile.send(:defined_in_file).dirname
-        real_path = Pathname.new(path).expand_path(profile_path)
-      end
-      # 找到本地组件库 执行 git pull
-      if real_path && File.directory?(real_path)
-        hash_map[:path] = real_path
-        hash_map.delete(:depth)
-        self.install_local_pod(self.name, hash_map)
+        self.install_local_pod(name, path, options)
         return
       end
-
-      # 根据tag, commit下载文件
       hash_map.delete(:path)
-      if (tag && url) || (commit && url)
-        hash_map.delete(:depth)
-        hash_map.delete(:branch)
+      git = hash_map[:git]
+      # 根据git_url 下载远程仓库
+      if git
+        LRequest.shared.downloader.pre_download_pod
+        # hash_map.delete(:cache)
         self.target.store_pod(self.real_name, hash_map)
-        return
-      end
-
-      # 根据 branch 下载代码
-      if url
-        hash_map.delete(:tag)
-        hash_map.delete(:commit)
-        self.downloader.download_init(self.name, hash_map)
-        self.downloader.pre_download_pod(self.git_util)
-        hash_map.delete(:depth)
+      else
+        #hash_map.delete(:cache)
         self.target.store_pod(self.real_name, hash_map)
       end
 
-
     end
 
     public
-    def install_form_specs(spec_path = nil)
-      spec_path ||= './Specs'
-      path = File.expand_path(spec_path, Dir.pwd)
-      file_objects = Dir.glob(File.expand_path("*.rb", path)).map do |file_path|
-        #读取 xxx.rb文件
-        Spec.form_file(file_path)
-      end
-      # 便利出每一个pod对安装信息
-      file_objects.each do |file|
-        if file.install
-          options = file.pod_requirements
-          self.lg_pod(file.name, options)
-        end
-      end
-
-    end
-
-    public
-    def install_local_pod(name, options = {})
+    #安装本地pod
+    def install_local_pod(name, relative_path, options = {})
       hash_map = options
-      local_path = options[:path]
       branch = options[:branch]
-      unless Dir.glob(File.expand_path(".git", local_path)).count > 0
-        LgPodPlugin.log_red("pod `#{name}` at path => #{local_path} 找不到.git目录")
+      absolute_path = Pathname.new(relative_path).expand_path(self.workspace)
+      unless absolute_path.exist?
+        LgPodPlugin.log_red("pod `#{name}` at path => #{relative_path} 找不到")
         return
       end
-      unless Dir.glob(File.expand_path("#{name}.podspec", local_path)).count > 0
-        LgPodPlugin.log_red("pod `#{name}` at path => #{local_path} 找不到#{name}.podspec文件")
+      unless Dir.glob(File.expand_path(".git", absolute_path)).count > 0
+        LgPodPlugin.log_red("pod `#{name}` at path => #{absolute_path} 找不到.git目录")
         return
       end
-
-      self.git_util.git_init(name, :branch => branch, :path => local_path)
-      self.git_util.git_local_pod_check(local_path)
-      hash_map[:path] = local_path.to_path
+      unless Dir.glob(File.expand_path("#{name}.podspec", absolute_path)).count > 0
+        LgPodPlugin.log_red("pod `#{name}` at path => #{absolute_path} 找不到#{name}.podspec文件")
+        return
+      end
+      LRequest.shared.git_util.git_local_pod_check(absolute_path)
       hash_map.delete(:tag)
       hash_map.delete(:git)
-      hash_map.delete(:depth)
+      # hash_map.delete(:cache)
       hash_map.delete(:commit)
       hash_map.delete(:branch)
       # 安装本地私有组件库

data/lib/lg_pod_plugin/l_cache.rb

@@ -0,0 +1,237 @@
+require 'git'
+require 'cocoapods/downloader'
+require 'cocoapods/downloader/cache'
+require 'cocoapods/downloader/response'
+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)
+
+    def initialize(workspace)
+      self.workspace = workspace
+      self.cache_root = LFileManager.cache_workspace(self.workspace)
+    end
+    
+    #根据git branch commit 返回请求参数用来获取缓存 path
+    def get_request_params(name, 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
+      return options
+    end
+    #判断缓存是否存在且有效命中缓存
+    def find_pod_cache(name, git, branch, tag, commit, is_update)
+      hash_map = nil 
+      if is_update
+        hash_map = self.get_request_params(name, 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(name, git, lock_branch, lock_tag, lock_commit)
+        else
+          hash_map = self.get_request_params(name, git, branch, tag, commit)
+        end
+      end
+      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)
+        return false
+      else
+        return true
+      end
+    end
+
+    def self.root_path
+      path = File.join(Dir.home, "Library/Caches/CocoaPods/Pods")
+      Pathname(path)
+    end
+
+    def self.download_request(name, params)
+      Pod::Downloader::Request.new(spec: nil, released: false, name: name, params: params)
+    end
+
+    def self.path_for_pod(request, slug_opts = {})
+      root = self.root_path
+      root + request.slug(**slug_opts)
+    end
+
+    def self.path_for_spec(request, slug_opts = {})
+      root = self.root_path
+      path = root + 'Specs' + request.slug(**slug_opts)
+      Pathname.new(path.to_path + '.podspec.json')
+    end
+
+    def self.cached_spec(request)
+      path = path_for_spec(request)
+      path.file? && Specification.from_file(path)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def self.get_local_spec(request, target)
+      result = Pod::Downloader::Response.new
+      result.location = target
+      if request.released_pod?
+        result.spec = request.spec
+        local_specs = { request.name => request.spec }
+        return [request, local_specs]
+      else
+        local_specs = {}
+        podspecs = Pod::Sandbox::PodspecFinder.new(target).podspecs
+        podspecs[request.name] = request.spec if request.spec
+        podspecs.each do |name, spec|
+          if request.name == name
+            result.spec = spec
+            local_specs[request.name] = spec
+          end
+        end
+      end
+
+      [result, local_specs]
+    end
+
+    def self.group_sub_specs_by_platform(spec)
+      specs_by_platform = {}
+      [spec, *spec.recursive_subspecs].each do |ss|
+        ss.available_platforms.each do |platform|
+          specs_by_platform[platform] ||= []
+          specs_by_platform[platform] << ss
+        end
+      end
+      specs_by_platform
+    end
+
+    def self.copy_and_clean(source, destination, spec)
+      specs_by_platform = group_sub_specs_by_platform(spec)
+      destination.parent.mkpath
+      self.write_lock(destination) do
+        FileUtils.rm_rf(destination)
+        FileUtils.cp_r(source, destination)
+        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
+
+    def self.lock(location, lock_type)
+      raise ArgumentError, 'no block given' unless block_given?
+      lockfile = "#{location}.lock"
+      f = nil
+      loop do
+        f.close if f
+        f = File.open(lockfile, File::CREAT, 0o644)
+        f.flock(lock_type)
+        break if self.valid_lock?(f, lockfile)
+      end
+      begin
+        yield location
+      ensure
+        if lock_type == File::LOCK_SH
+          f.flock(File::LOCK_EX)
+          File.delete(lockfile) if self.valid_lock?(f, lockfile)
+        else
+          File.delete(lockfile)
+        end
+        f.close
+      end
+    end
+
+    def self.valid_lock?(file, filename)
+      file.stat.ino == File.stat(filename).ino
+    rescue Errno::ENOENT
+      false
+    end
+
+    def self.write_spec(spec, path)
+      path.dirname.mkpath
+      Pod::Downloader::Cache.write_lock(path) do
+        path.open('w') { |f| f.write spec.to_pretty_json }
+      end
+    end
+
+    # 拷贝 pod 缓存文件到 sandbox
+    def self.cache_pod(name, target, options = {})
+      request = LCache.download_request(name, options)
+      result, pods_pecs = get_local_spec(request, target)
+      result.location = nil
+      pods_pecs.each do |s_name, s_spec|
+        destination = path_for_pod(request, {})
+        if !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, {})
+        if !File.exist?(cache_pod_spec)
+          write_spec(s_spec, cache_pod_spec)
+        end
+        if request.name == s_name
+          result.location = destination
+        end
+
+      end
+
+    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(name, 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/log.rb

@@ -0,0 +1,26 @@
+
+require_relative 'string'
+require 'cocoapods/user_interface'
+
+module LgPodPlugin
+
+  def self.log_red(msg)
+    Pod::CoreUI.puts msg.red
+  end
+
+  def self.log_blue(msg)
+    Pod::CoreUI.puts msg.blue
+  end
+
+  def self.log_green(msg)
+    Pod::CoreUI.puts msg.green
+  end
+
+  def self.log_yellow(msg)
+    Pod::CoreUI.puts msg.yellow
+  end
+
+  def self.log(msg)
+    Pod::CoreUI.puts msg
+  end
+end

data/lib/lg_pod_plugin/request.rb

@@ -0,0 +1,141 @@
+require 'singleton'
+require 'yaml'
+require_relative 'l_cache'
+require_relative 'git_util'
+require_relative 'download'
+module LgPodPlugin
+
+  class LRequest
+    include Singleton
+    REQUIRED_ATTRS ||= %i[name options workspace cache downloader git_util lock_info lock_params is_update].freeze
+    attr_accessor(*REQUIRED_ATTRS)
+
+    def is_update_pod
+      cgi = CGI.new
+      command_keys = cgi.keys
+      unless command_keys.count > 0
+        return false
+      end
+      first_key = command_keys[0].to_s ||= ""
+      if first_key.include?("install")
+        false
+      elsif first_key.include?("update")
+        true
+      else
+        false
+      end
+    end
+
+    def get_lock_info
+      lock_file = self.workspace.join("Podfile.lock")
+      if lock_file.exist?
+        json = YAML.load_file(lock_file.to_path)
+        external_sources = json["EXTERNAL SOURCES"]
+        return external_sources
+      else
+        return 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
+      elsif git && branch
+        lock_branch = current_pod_info[:branch]
+        if branch == lock_branch
+          return { :git => git, :commit => lock_commit, :branch => lock_branch}
+        else
+          return nil
+        end
+      elsif commit == lock_commit
+        return { :git => git, :commit => lock_commit }
+      else
+        return nil
+      end
+    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
+      end
+      self.lock_params = self.get_lock_params(git, branch, tag, commit)
+      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_branch, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag,commit)
+            hash_map[:commit] = new_commit
+          end
+        else
+          new_branch, 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
+      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_branch, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
+            hash_map[:commit] = new_commit
+          end
+        else
+          new_branch, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
+          hash_map[:commit] = new_commit
+        end
+      else
+        new_branch, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
+        hash_map[:commit] = new_commit
+        hash_map[:branch] = new_branch
+      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)
+    end
+
+    def self.shared
+      return LRequest.instance
+    end
+
+  end
+
+end

data/lib/lg_pod_plugin/string.rb

@@ -0,0 +1,33 @@
+module LgPodPlugin
+
+  class String
+    # colorization
+    def colorize(color_code)
+      "\e[#{color_code}m#{self}\e[0m"
+    end
+
+    def red
+      colorize(31)
+    end
+
+    def green
+      colorize(32)
+    end
+
+    def yellow
+      colorize(33)
+    end
+
+    def blue
+      colorize(34)
+    end
+
+    def pink
+      colorize(35)
+    end
+
+    def light_blue
+      colorize(36)
+    end
+  end
+end

data/lib/lg_pod_plugin/version.rb

@@ -1,3 +1,3 @@
 module LgPodPlugin
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end