lg_pod_plugin 1.1.7.4 → 1.1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4b61db7b5001df6188133eaf111f4570d0580fe4e71bc3e89863f2245d9c3ff
-  data.tar.gz: 14afb884ec6e4247b37f95b0002c2dd19098c75cf464fe07d3c79565f83916a0
+  metadata.gz: 64cfe9f5818b1ad35a426e047a1639889db338c028923af2e2cbc9c4e31556da
+  data.tar.gz: ce53c502a2bbbeb261dfe3dc048a8e423848f7f29633956447c0abe1b474712d
 SHA512:
-  metadata.gz: b2ee449bb57c15cc6d9cd7d5566aa91af414c34a3c2aabc1a2e858650447b93df9bba3d705d248beffed8bee615b31cfc2db935c525b6eed2178658f7ab2a655
-  data.tar.gz: c3f587b3ed1ccb1ca27a902db900346767bb012e082f45a6f1aa8a60b17d6da913fa6cf926645b966020fc813517470a1b85d621f51a3849b255683da87bdcde
+  metadata.gz: 6a6f5bc095f471f44cb2effd225be4bcf1c10622374adbe7f00d2b7953f0be3b09f763307ba167456169ba862e629e0cdf3e5596228f093461ee98fb35c3b21d
+  data.tar.gz: e081fa09f5ba85d7a9a581b30a8fabf9e83ce89c200bd020b3a9bdc0a8b6b955cf61b01fd1c0279ea2dbec406f77b6b790fd42397a2989632a3eb8fa918c5f28

data/lib/lg_pod_plugin/db/database.rb

@@ -1,6 +1,6 @@
 require 'singleton'
-# arch = %x(ruby -v)
 require 'sqlite3'
+
 module LgPodPlugin
 
   class ProjectModel

data/lib/lg_pod_plugin/downloader/downloader.rb

@@ -15,27 +15,18 @@ module LgPodPlugin
     # 预下载处理
     def pre_download_pod
       name = self.request.name
-      if self.request.lg_spec
-        podspec = self.request.lg_spec.spec
-      else
-        podspec = nil
-      end
+      podspec = self.request.podspec
       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
@@ -49,10 +40,13 @@ module LgPodPlugin
         LgPodPlugin.log_green "Using `#{name}`"
       end
       hash_map = self.request.get_cache_key_params
-      # self.request.checkout_options.delete(:branch) if commit
-      # self.request.checkout_options[:commit] = commit if commit
-      # 发现本地有缓存, 不需要更新缓存
-      pod_is_exist, destination, cache_pod_spec = LCache.new.pod_cache_exist(name, hash_map, podspec, self.request.released_pod)
+      if request.single_git
+        commit = hash_map[:commit] unless commit
+        checkout_options[:commit] = commit if commit
+        pod_is_exist, destination, cache_pod_spec = LCache.new.pod_cache_exist(name, {:git => git}, 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
         LgPodPlugin.log_green "find the cache of `#{name}`, you can use it now."
         return nil
@@ -62,42 +56,9 @@ module LgPodPlugin
         # 本地 git 下载 pod 目录
         download_params = self.pre_download_git_repository(checkout_options)
         if download_params && download_params.is_a?(Hash)
+          download_params["dirname"] = destination.dirname
           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
-          end
           return download_params
         elsif File.exist?(download_params.to_s) && download_params
           FileUtils.chdir download_params

data/lib/lg_pod_plugin/downloader/l_cache.rb

@@ -1,4 +1,4 @@
-# require 'git'
+
 require 'cocoapods/downloader'
 require 'cocoapods/downloader/cache'
 require 'cocoapods/downloader/response'
@@ -12,32 +12,34 @@ module LgPodPlugin
     end
 
     public
+
     def pod_cache_exist(name, options, spec = nil, released_pod = false)
       # 参数为空不执行下载任务, 交给 cocoapods 处理下载
       if options.nil?
-        return   [true, nil, nil]
+        return [true, nil, nil]
       end
-
       destination, cache_pod_spec = self.find_pod_cache name, options, spec, released_pod
-      lock_temp_file = destination.to_path+ ".lock"
+      lock_temp_file = destination.to_path + ".lock"
       if File.exist?(lock_temp_file)
         FileUtils.rm_rf lock_temp_file
       end
-      if (File.exist?(destination) && !destination.children.empty?) && cache_pod_spec.exist?
+      if destination && destination.exist? && !destination.children.empty?
         return [true, destination, cache_pod_spec]
       else
         return [false, destination, cache_pod_spec]
       end
     end
 
-    #判断缓存是否存在且有效命中缓存
+    # 判断缓存是否存在且有效命中缓存
+
     public
+
     def find_pod_cache(name, options, spec = nil, released_pod = false)
       hash_map = Hash.new.merge!(options)
       if hash_map.has_key?(:version)
         hash_map.delete(:version)
       end
-      request = LCache.download_request(name, hash_map, spec, released_pod)
+      request = LCache.create_download_request(name, hash_map, spec, released_pod)
       destination = LCache.path_for_pod(request)
       cache_pod_spec = LCache.path_for_spec(request)
       [destination, cache_pod_spec]
@@ -48,32 +50,50 @@ module LgPodPlugin
       Pathname(path)
     end
 
-    def self.download_request(name, params, spec = nil, released_pod = false)
+    def self.create_download_request(name, params, spec = nil, released_pod = false)
       if released_pod
-        Pod::Downloader::Request.new(spec: spec, released: true , name: name, params: params)
+        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.create_downloader_manager(request, target)
+      result = Pod::Downloader::Response.new
+      result.checkout_options = request.params
+      result.location = target
+
+      if request.released_pod?
+        result.spec = request.spec
+        podspecs = { request.name => request.spec }
       else
-        Pod::Downloader::Request.new(spec: nil, released: false , name: name, params: params)
+        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
+          end
+        end
       end
+
+      [result, podspecs]
     end
-    #MARK - 缓存方法
+
+    def self.root_cache
+      cache_path = LFileManager.cache_root_path
+      return Pod::Downloader::Cache.new(cache_path)
+    end
+
+    # MARK - 缓存方法
     def self.path_for_pod(request, slug_opts = {})
-      root = self.root_path
-      root + request.slug(**slug_opts)
+      root_path + 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')
+      path = root_path + 'Specs' + request.slug(**slug_opts)
+      return 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
@@ -95,62 +115,29 @@ module LgPodPlugin
       [result, local_specs]
     end
 
-    def self.group_subspecs_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_subspecs_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.clean_pod_unused_files(destination, spec)
-      specs_by_platform = group_subspecs_by_platform(spec)
-      destination.parent.mkpath
-      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)
-      Pod::Downloader::Cache.lock(location, File::LOCK_SH, &block)
+      return self.root_cache.copy_and_clean(source, destination, spec)
     end
 
     public
+
     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
+      self.root_cache.write_spec(spec, path)
     end
 
     # 拷贝 pod 缓存文件到 sandbox
+
     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, 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)
-        if !File.exist?(destination) || destination.children.empty?
+      request = create_download_request(name, checkout_options, spec, released_pod)
+      result, pods_pecs = create_downloader_manager(request, target)
+      pods_pecs.each do |name, s_spec|
+        destination = path_for_pod request, { :name => name, :params => checkout_options }
+        if !destination.exist? || destination.children.empty?
           LgPodPlugin.log_green "Copying #{name} from `#{target}` to `#{destination}` "
           copy_and_clean(target, destination, s_spec)
         end
@@ -158,8 +145,13 @@ module LgPodPlugin
         unless File.exist?(cache_pod_spec)
           write_spec(s_spec, cache_pod_spec)
         end
+        if request.name == name
+          result.location = destination
+        end
       end
 
+      result
+
     end
 
   end

data/lib/lg_pod_plugin/downloader/overload_cache.rb

@@ -1,6 +1,3 @@
-# frozen_string_literal: true
-
-require 'cocoapods'
 require 'fileutils'
 require 'tmpdir'
 
@@ -10,155 +7,9 @@ module Pod
     # them in a cache directory.
     #
     class Cache
-      # @return [Pathname] The root directory where this cache store its
-      #         downloads.
-      #
-      attr_reader :root
-
-      # Initialize a new instance
-      #
-      # @param  [Pathname,String] root
-      #         see {#root}
-      #
-      def initialize(root)
-        @root = Pathname(root)
-        ensure_matching_version
-      end
-
-      # Downloads the Pod from the given `request`
-      #
-      # @param  [Request] request
-      #         the request to be downloaded.
-      #
-      # @return [Response] the response from downloading `request`
-      #
-      def download_pod(request)
-        cached_pod(request) || uncached_pod(request)
-      rescue Informative
-        raise
-      rescue
-        UI.puts("\n[!] Error installing #{request.name}".red)
-        raise
-      end
-
-      # @return [Hash<String, Hash<Symbol, String>>]
-      #         A hash whose keys are the pod name
-      #         And values are a hash with the following keys:
-      #         :spec_file : path to the spec file
-      #         :name      : name of the pod
-      #         :version   : pod version
-      #         :release   : boolean to tell if that's a release pod
-      #         :slug      : the slug path where the pod cache is located
-      #
-      def cache_descriptors_per_pod
-        specs_dir = root + 'Specs'
-        release_specs_dir = specs_dir + 'Release'
-        return {} unless specs_dir.exist?
-
-        spec_paths = specs_dir.find.select { |f| f.fnmatch('*.podspec.json') }
-        spec_paths.reduce({}) do |hash, spec_path|
-          spec = Specification.from_file(spec_path)
-          hash[spec.name] ||= []
-          is_release = spec_path.to_s.start_with?(release_specs_dir.to_s)
-          request = Downloader::Request.new(:spec => spec, :released => is_release)
-          hash[spec.name] << {
-            :spec_file => spec_path,
-            :name => spec.name,
-            :version => spec.version,
-            :release => is_release,
-            :slug => root + request.slug,
-          }
-          hash
-        end
-      end
 
-      # Convenience method for acquiring a shared lock to safely read from the
-      # cache. See `Cache.lock` for more details.
-      #
-      # @param  [Pathname] location
-      #         the path to require a lock for.
-      #
-      # @param  [block] &block
-      #         the block to execute inside the lock.
-      #
-      # @return [void]
-      #
-      def self.read_lock(location, &block)
-        Cache.lock(location, File::LOCK_SH, &block)
-      end
-
-      # Convenience method for acquiring an exclusive lock to safely write to
-      # the cache. See `Cache.lock` for more details.
-      #
-      # @param  [Pathname] location
-      #         the path to require a lock for.
-      #
-      # @param  [block] &block
-      #         the block to execute inside the lock.
-      #
-      # @return [void]
-      #
-      def self.write_lock(location, &block)
-        Cache.lock(location, File::LOCK_EX, &block)
-      end
-
-      # Creates a .lock file at `location`, aquires a lock of type
-      # `lock_type`, checks that it is valid, and executes passed block while
-      # holding on to that lock. Afterwards, the .lock file is deleted, which is
-      # why validation of the lock is necessary, as you might have a lock on a
-      # file that doesn't exist on the filesystem anymore.
-      #
-      # @param  [Pathname] location
-      #         the path to require a lock for.
-      #
-      # @param  [locking_constant] lock_type
-      #         the type of lock, either exclusive (File::LOCK_EX) or shared
-      #         (File::LOCK_SH).
-      #
-      # @return [void]
-      #
-      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 Cache.valid_lock?(f, lockfile)
-        end
-        begin
-          yield location
-        ensure
-          if lock_type == File::LOCK_SH
-            f.flock(File::LOCK_EX)
-            File.delete(lockfile) if Cache.valid_lock?(f, lockfile)
-          else
-            File.delete(lockfile)
-          end
-          f.close
-        end
-      end
-
-      # Checks that the lock is on a file that still exists on the filesystem.
-      #
-      # @param  [File] file
-      #         the actual file that we have a lock for.
-      #
-      # @param  [String] filename
-      #         the filename of the file that we have a lock for.
-      #
-      # @return [Boolean]
-      #         true if `filename` still exists and is the same file as `file`
-      #
-      def self.valid_lock?(file, filename)
-        file.stat.ino == File.stat(filename).ino
-      rescue Errno::ENOENT
-        false
-      end
 
       private
-
       # Ensures the cache on disk was created with the same CocoaPods version as
       # is currently running.
       #
@@ -178,152 +29,31 @@ module Pod
         end
       end
 
-      # @param  [Request] request
-      #         the request to be downloaded.
-      #
-      # @param  [Hash<Symbol,String>] slug_opts
-      #         the download options that should be used in constructing the
-      #         cache slug for this request.
-      #
-      # @return [Pathname] The path for the Pod downloaded from the given
-      #         `request`.
-      #
-      def path_for_pod(request, slug_opts = {})
-        root + request.slug(**slug_opts)
-      end
-
-      # @param  [Request] request
-      #         the request to be downloaded.
-      #
-      # @param  [Hash<Symbol,String>] slug_opts
-      #         the download options that should be used in constructing the
-      #         cache slug for this request.
-      #
-      # @return [Pathname] The path for the podspec downloaded from the given
-      #         `request`.
-      #
-      def path_for_spec(request, slug_opts = {})
-        path = root + 'Specs' + request.slug(**slug_opts)
-        Pathname.new(path.to_path + '.podspec.json')
-      end
-
-      # @param  [Request] request
-      #         the request to be downloaded.
-      #
-      # @return [Response] The download response for the given `request` that
-      #         was found in the download cache.
-      #
-      def cached_pod(request)
-        cached_spec = cached_spec(request)
-        path = path_for_pod(request)
-
-        return unless cached_spec && path.directory?
-        spec = request.spec || cached_spec
-        Response.new(path, spec, request.params)
-      end
-
-      # @param  [Request] request
-      #         the request to be downloaded.
-      #
-      # @return [Specification] The cached specification for the given
-      #         `request`.
-      #
-      def cached_spec(request)
-        path = path_for_spec(request)
-        path.file? && Specification.from_file(path)
-      rescue JSON::ParserError
-        nil
-      end
-
-      # @param  [Request] request
-      #         the request to be downloaded.
-      #
-      # @return [Response] The download response for the given `request` that
-      #         was not found in the download cache.
-      #
-      def uncached_pod(request)
-        in_tmpdir do |target|
-          result, podspecs = download(request, target)
-          result.location = nil
-
-          podspecs.each do |name, spec|
-            destination = path_for_pod(request, :name => name, :params => result.checkout_options)
-            copy_and_clean(target, destination, spec)
-            write_spec(spec, path_for_spec(request, :name => name, :params => result.checkout_options))
-            if request.name == name
-              result.location = destination
-            end
-          end
-
-          result
-        end
-      end
-
-      def download(request, target)
-        Downloader.download_request(request, target)
-      end
-
-      # Performs the given block inside a temporary directory,
-      # which is removed at the end of the block's scope.
-      #
-      # @return [Object] The return value of the given block
-      #
-      def in_tmpdir(&blk)
-        tmpdir = Pathname(Dir.mktmpdir)
-        blk.call(tmpdir)
-      ensure
-        FileUtils.remove_entry(tmpdir, :force => true) if tmpdir && tmpdir.exist?
-      end
-
-      # Copies the `source` directory to `destination`, cleaning the directory
-      # of any files unused by `spec`.
-      #
-      # @param  [Pathname] source
-      #
-      # @param  [Pathname] destination
-      #
-      # @param  [Specification] spec
-      #
-      # @return [Void]
-      #
+      public
       def copy_and_clean(source, destination, spec)
+        attributes_hash = spec.send(:attributes_hash) || {}
+        name = attributes_hash["name"] ||= ""
         specs_by_platform = group_subspecs_by_platform(spec)
         destination.parent.mkpath
-        Cache.write_lock(destination) do
-          FileUtils.rm_rf(destination)
-          FileUtils.cp_r(source, destination)
-          Pod::Installer::PodSourcePreparer.new(spec, destination).prepare!
-          Sandbox::PodDirCleaner.new(destination, specs_by_platform).clean!
-        end
-      end
-
-      def group_subspecs_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
+        Pod::Downloader::Cache.write_lock(destination) do
+          if source && source.exist? && !source.children.empty?
+            FileUtils.rm_rf(destination)
+            FileUtils.cp_r(source, destination)
           end
+          LgPodPlugin.log_green "-> Copy #{name} from #{source} to #{destination}"
+          Pod::Installer::PodSourcePreparer.new(spec, destination).prepare!
+          Pod::Sandbox::PodDirCleaner.new(destination, specs_by_platform).clean!
         end
-        specs_by_platform
       end
 
-      # Writes the given `spec` to the given `path`.
-      #
-      # @param  [Specification] spec
-      #         the specification to be written.
-      #
-      # @param  [Pathname] path
-      #         the path the specification is to be written to.
-      #
-      # @return [Void]
-      #
+      public
       def write_spec(spec, path)
         path.dirname.mkpath
-        Cache.write_lock(path) do
+        Pod::Downloader::Cache.write_lock(path) do
           path.open('w') { |f| f.write spec.to_pretty_json }
         end
       end
+
     end
   end
-end
+end

data/lib/lg_pod_plugin/downloader/request.rb

@@ -6,7 +6,7 @@ module LgPodPlugin
   class LRequest
     attr_reader :target
     attr_reader :name
-    attr_accessor :lg_spec
+    attr_accessor :podspec
     attr_reader :released_pod
     attr_accessor :single_git
     attr_accessor :config
@@ -16,12 +16,10 @@ module LgPodPlugin
     attr_accessor :checkout_options
     def initialize(pod)
       @name = pod.name
+      @podspec = pod.spec
       @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