lg_pod_plugin 1.0.3 → 1.0.6

data/lib/lg_pod_plugin/l_cache.rb

@@ -0,0 +1,236 @@
+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(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
+      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
+      else
+        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 = {}
+        pods_pecs = Pod::Sandbox::PodspecFinder.new(target).podspecs
+        pods_pecs[request.name] = request.spec if request.spec
+        pods_pecs.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, {})
+        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, {})
+        unless 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(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

@@ -0,0 +1,39 @@
+require  'zip'
+module LgPodPlugin
+  class LUtils
+    def self.unzip_file (zip_file, dest_dir)
+      begin
+        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?(".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")
+            file.extract(f, file_path)
+          end
+        end
+        return true
+      rescue => err
+        puts err
+        return false
+      end
+
+    end
+
+    def self.aes_decrypt(key, data)
+      de_cipher = OpenSSL::Cipher::Cipher.new("AES-128-CBC")
+      de_cipher.decrypt
+      de_cipher.key = [key].pack('H*')
+      # de_cipher.iv = [iv].pack('H*');
+      puts de_cipher.update([data].pack('H*')) << de_cipher.final
+    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,140 @@
+require 'singleton'
+require 'yaml'
+require_relative 'l_cache'
+require_relative 'git_util'
+require_relative 'downloader.rb'
+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)
+        json["EXTERNAL SOURCES"]
+      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
+      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
+        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_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
+      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
+        else
+          _, new_commit = LGitUtil.git_ls_remote_refs(git, branch, tag, commit)
+          hash_map[:commit] = new_commit
+        end
+      elsif !path
+        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.6"
 end

data/lib/lg_pod_plugin.rb

@@ -1,75 +1,21 @@
 require 'git'
-require 'sqlite3'
+require 'cocoapods-downloader'
+require 'cocoapods-core/podfile/target_definition'
 require "lg_pod_plugin/version"
-require 'cocoapods/user_interface'
+require_relative 'lg_pod_plugin/log'
+require_relative 'lg_pod_plugin/install'
+require_relative 'lg_pod_plugin/request'
 require_relative 'lg_pod_plugin/database'
-require_relative 'lg_pod_plugin/download'
+require_relative 'lg_pod_plugin/downloader.rb'
 require_relative 'lg_pod_plugin/git_util'
-require_relative 'lg_pod_plugin/pod_spec'
-require_relative 'lg_pod_plugin/install'
-require 'cocoapods-core/podfile/target_definition'
 
 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
-
   class Error < StandardError; end
 
-  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
-
   public
   # 对 Profile 方法进行拓展
   def pod(name, *requirements)
     Installer.new(self, name, requirements)
   end
-
-
 end
-