lg_pod_plugin 1.1.3 → 1.1.4

data/lib/lg_pod_plugin/pod/release-pod.rb

@@ -0,0 +1,158 @@
+require 'cocoapods'
+require 'cocoapods-core'
+require_relative '../config/podspec'
+require_relative '../installer/concurrency'
+
+module LgPodPlugin
+
+  class ReleasePod < ExternalPod
+    def initialize(target, name, hash, spec)
+      @spec = spec
+      @name = name
+      @target = target
+      @released_pod = true
+      @checkout_options = hash
+    end
+
+    def self.check_release_pod_exist(name, requirements, spec, released_pod)
+      is_exist, _, _ = (LCache.new.pod_cache_exist(name, requirements, spec, released_pod))
+      return is_exist
+    end
+
+    def self.resolve_dependencies(lockfile, installer)
+      installer.resolve_dependencies
+      external_pods = LProject.shared.external_pods ||= {}
+      analysis_result = installer.send(:analysis_result)
+      return unless analysis_result
+      root_specs = analysis_result.specifications.map(&:root).uniq
+      root_specs = root_specs.reject! do |spec|
+        spec_name = spec.send(:attributes_hash)["name"]
+        external_pods[spec_name] || external_pods[spec_name.split("/").first]
+      end unless external_pods.empty?
+      return unless root_specs
+      all_installers = Array.new
+      root_specs.sort_by(&:name).each do |spec|
+        attributes_hash = spec.send(:attributes_hash)
+        next unless attributes_hash.is_a?(Hash)
+        pod_name = attributes_hash["name"]
+        source = attributes_hash['source']
+        next unless source.is_a?(Hash)
+        git = source["git"]
+        tag = source["tag"]
+        http = source["http"]
+        checksum = spec.send(:checksum)
+        if http
+          if http.include?("https://github.com") && http.include?("releases/download")
+            http = "https://ghproxy.com/" + http
+            source["http"] = http
+          end
+          version = attributes_hash["version"]
+          requirements = {:http => http, :version => version}
+        elsif git && tag
+          tag = tag.to_s unless LUtils.is_a_string? tag
+          requirements = { :git => git, :tag => tag }
+        else
+          next
+        end
+        pod_exist = check_release_pod_exist(pod_name, requirements, spec, true)
+        if lockfile && checksum
+          internal_data = lockfile.send(:internal_data)
+          lock_checksums = internal_data["SPEC CHECKSUMS"] ||= {}
+          lock_checksum = lock_checksums[pod_name]
+          next if (lock_checksum == checksum) && (pod_exist)
+        else
+          next if pod_exist
+        end
+        LProject.shared.cache_specs[pod_name] = spec
+        lg_spec = LgPodPlugin::PodSpec.form_pod_spec spec
+        release_pod = ReleasePod.new(nil, pod_name, requirements, lg_spec)
+        pod_install = LgPodPlugin::LPodInstaller.new
+        download_params = pod_install.install(release_pod)
+        all_installers.append pod_install if download_params
+      end
+      # 通过 swift 可执行文件进行异步下载任务
+      LgPodPlugin::Concurrency.async_download_pods all_installers
+    end
+
+    def self.dependencies(installer)
+      installer.download_dependencies
+      installer.send(:validate_targets)
+      installation_options = installer.send(:installation_options)
+      skip_pods_project_generation = installation_options.send(:skip_pods_project_generation)
+      if skip_pods_project_generation
+        installer.show_skip_pods_project_generation_message
+      else
+        installer.integrate
+      end
+      installer.send(:write_lockfiles)
+      installer.send(:perform_post_install_actions)
+    end
+
+    def self.lockfile_missing_pods(pods, lockfile)
+      lockfile_roots = lockfile.pod_names.map { |pod| Pod::Specification.root_name(pod) }
+      pods.map { |pod| Pod::Specification.root_name(pod) }.uniq - lockfile_roots
+    end
+
+    # Check if all given pods are installed
+    #
+    def self.verify_pods_are_installed!(pods, lockfile)
+      missing_pods = lockfile_missing_pods(pods, lockfile)
+
+      unless missing_pods.empty?
+        message = if missing_pods.length > 1
+                    "Pods `#{missing_pods.join('`, `')}` are not " \
+                          'installed and cannot be updated'
+                  else
+                    "The `#{missing_pods.first}` Pod is not installed " \
+                          'and cannot be updated'
+                  end
+        raise Pod::Informative, message
+      end
+    end
+
+    def self.verify_lockfile_exists!(lockfile)
+      unless lockfile
+        raise Pod::Informative, "No `Podfile.lock' found in the project directory, run `pod install'."
+      end
+    end
+
+    def self.install_release_pod(update, repo_update, verbose)
+      #切换工作目录到当前工程下, 开始执行pod install
+      workspace = LProject.shared.workspace
+      FileUtils.chdir(workspace)
+      # 安装 release_pod
+      LgPodPlugin.log_blue "Pre-downloading Release Pods"
+      Pod::Config.instance.verbose = verbose
+      pods_path = LProject.shared.workspace.join('Pods')
+      podfile = LProject.shared.podfile
+      lockfile = LProject.shared.lockfile
+      sandbox = Pod::Sandbox.new(pods_path)
+      installer = Pod::Installer.new(sandbox, podfile, lockfile)
+      installer.repo_update = repo_update
+      if update
+        need_update_pods = LProject.shared.need_update_pods ||= Hash.new
+        pods = need_update_pods.keys ||= []
+        begin
+          verify_lockfile_exists!(lockfile)
+          verify_pods_are_installed!(pods, lockfile)
+          if pods.empty?
+            installer.update = true
+          else
+            installer.update = { :pods => pods }
+          end
+        rescue
+          installer.update = false
+        end
+      else
+        installer.update = false
+      end
+      installer.deployment = false
+      installer.clean_install = false
+      installer.prepare
+      resolve_dependencies(lockfile, installer)
+      dependencies(installer)
+    end
+
+  end
+
+end

data/lib/lg_pod_plugin/utils/aes-crypt.rb

@@ -0,0 +1,82 @@
+# -*- encoding: utf-8 -*-
+
+# The encrypt_data and decrypt_data methods are Copyright (c) 2007 Brent Sowers
+# and have been included with prior permission.
+#
+# Copyright (c) 2012 Gurpartap Singh
+# 
+# MIT License
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'openssl'
+
+module AESCrypt
+  def self.encrypt(message, password)
+    Base64.encode64(self.encrypt_data(message.to_s.strip, password, nil, "AES-256-ECB"))
+  end
+
+  def self.decrypt(message, password)
+    base64_decoded = Base64.decode64(message.to_s.strip)
+    self.decrypt_data(base64_decoded, password, nil, "AES-256-ECB")
+  end
+
+  def self.key_digest(password)
+    OpenSSL::Digest::SHA256.new(password).digest
+  end
+
+  # Decrypts a block of data (encrypted_data) given an encryption key
+  # and an initialization vector (iv).  Keys, iv's, and the data 
+  # returned are all binary strings.  Cipher_type should be
+  # "AES-256-CBC", "AES-256-ECB", or any of the cipher types
+  # supported by OpenSSL.  Pass nil for the iv if the encryption type
+  # doesn't use iv's (like ECB).
+  #:return: => String
+  #:arg: encrypted_data => String 
+  #:arg: key => String
+  #:arg: iv => String
+  #:arg: cipher_type => String
+  def self.decrypt_data(encrypted_data, key, iv, cipher_type)
+    aes = OpenSSL::Cipher::Cipher.new(cipher_type)
+    aes.decrypt
+    aes.key = key
+    aes.iv = iv if iv != nil
+    aes.update(encrypted_data) + aes.final  
+  end
+
+  # Encrypts a block of data given an encryption key and an 
+  # initialization vector (iv).  Keys, iv's, and the data returned 
+  # are all binary strings.  Cipher_type should be "AES-256-CBC",
+  # "AES-256-ECB", or any of the cipher types supported by OpenSSL.  
+  # Pass nil for the iv if the encryption type doesn't use iv's (like
+  # ECB).
+  #:return: => String
+  #:arg: data => String 
+  #:arg: key => String
+  #:arg: iv => String
+  #:arg: cipher_type => String  
+  def self.encrypt_data(data, key, iv, cipher_type)
+    aes = OpenSSL::Cipher::Cipher.new(cipher_type)
+    aes.encrypt
+    aes.key = key
+    aes.iv = iv if iv != nil
+    aes.update(data) + aes.final      
+  end
+end

data/lib/lg_pod_plugin/{file_path.rb → utils/file_path.rb}

@@ -10,10 +10,8 @@ module LgPodPlugin
     # 本地下载路径 ~Library/Caches/LgPodPlugin
     def self.download_director
       cache_path = self.cache_director.join("LgPodPlugin")
-      unless cache_path.exist?
-        # pp "文件路径不存在"
-        cache_path.mkdir(0700)
-      end
+      # pp "文件路径不存在, 就创建"
+      cache_path.mkdir(0700) unless cache_path.exist?
       cache_path
     end
 
@@ -21,7 +19,7 @@ module LgPodPlugin
     def self.cache_workspace(root)
       timestamp = "_#{Time.now.to_i}_"
       key = root.to_path + timestamp + "#{(rand * 10000000).to_i}"
-      director = Digest::MD5.hexdigest(key)
+      director = LUtils.md5(key)
       return self.download_director.join(director)
     end
 

data/lib/lg_pod_plugin/utils/l_util.rb

@@ -0,0 +1,133 @@
+require 'json'
+require 'resolv'
+require "ipaddr"
+require 'base64'
+require 'fileutils'
+require_relative 'aes-crypt'
+
+module LgPodPlugin
+
+  class LUtils
+
+    def self.encrypt(message, password)
+      encrypted_data = AESCrypt.encrypt(message, password)
+      encrypted_data.tr("\n", "")
+    end
+
+    def self.decrypt(message, password)
+      AESCrypt.decrypt message, password
+    end
+
+    def self.md5(text)
+      return "" unless text
+      return Digest::MD5.hexdigest(text)
+    end
+
+    def self.base64_encode(text)
+      Base64.encode64(text)
+    end
+
+    def self.base64_decode(text)
+      Base64.decode64(text)
+    end
+
+    #判断对象是不是 String
+    def self.is_a_string?(obj)
+      if "#{obj.class}" == "String"
+        return true
+      else
+        return false
+      end
+    end
+
+    # 通过 git ls-remote获取最新 commit
+    public
+    def self.refs_from_ls_remote(git, branch)
+      cmds = ['git']
+      cmds << "ls-remote"
+      cmds << git
+      cmds << branch if branch
+      cmds_to_s = cmds.join(" ")
+      LgPodPlugin.log_blue cmds_to_s
+      begin
+        return %x(timeout 5 #{cmds_to_s})
+      rescue
+        return %x(#{cmds_to_s})
+      end
+    end
+
+    # 解析git ls-remote结果
+    public
+    def self.sha_from_result(output, branch_name)
+      return nil if branch_name.nil?
+      encoded_branch_name = branch_name.dup.force_encoding(Encoding::ASCII_8BIT)
+      if branch_name == "HEAD"
+        match1 = %r{([a-z0-9]*)\t#{Regexp.quote(encoded_branch_name)}}.match(output)
+        if match1.nil?
+          sha = ""
+        else
+          sha = match1[1]
+        end
+        return [nil, nil] unless sha && !sha.empty?
+        match2 = %r{(#{sha})\trefs\/heads\/([a-z0-9]*)}.match(output)
+        return [nil, nil] if match2.nil?
+        if match2[1] == sha
+          new_branch = match2[2]
+          return [sha, new_branch]
+        else
+          return [nil, nil]
+        end
+      else
+        match = %r{([a-z0-9]*)\trefs\/(heads|tags)\/#{Regexp.quote(encoded_branch_name)}}.match(output)
+        if !match.nil?
+          sha = match[1]
+          branch = match[0].split("refs/heads/").last
+        else
+          sha = nil
+          branch = nil
+        end
+        return [sha, branch]
+      end
+    end
+
+    #截取git-url 拿到项目绝对名称 比如 l-base-ios
+    public
+    def self.get_git_project_name(git)
+      base_url = self.get_gitlab_base_url(git)
+      match = %r{[^/]+$}.match(base_url)
+      return match[0] unless match.nil?
+    end
+
+    # 截取 url
+    public
+    def self.get_gitlab_base_url(git)
+      if git.include?(".git")
+        math = /(.*(?=.git))/.match(git)
+        return math[0] unless math.nil?
+      else
+        return git
+      end
+    end
+
+    public
+    def self.url_encode(url)
+      url.to_s.b.gsub(/[^a-zA-Z0-9_\-.~]/n) { |m| sprintf('%%%02X', m.unpack1('C')) }
+    end
+
+    public
+    def self.pod_real_name(name)
+      math = %r{(.*(?=/))}.match(name)
+      return name unless math
+      return math[0]
+    end
+
+    public
+    def self.is_gitlab_uri(git, hostname)
+      match1 = %r{(github.com|gitee.com|coding.net|code.aliyun.com)}.match(git)
+      match2 = %r{(github.com|gitee.com|coding.net|code.aliyun.com)}.match(hostname)
+      return match1.nil? && match2.nil?
+    end
+
+  end
+
+end

data/lib/lg_pod_plugin/{log.rb → utils/log.rb}

@@ -1,5 +1,5 @@
 
-require_relative 'string'
+require 'cocoapods'
 require 'cocoapods/user_interface'
 
 module LgPodPlugin

data/lib/lg_pod_plugin/version.rb

@@ -1,3 +1,3 @@
 module LgPodPlugin
-  VERSION = "1.1.3"
+  VERSION = "1.1.4"
 end

data/lib/lg_pod_plugin.rb

@@ -1,17 +1,32 @@
-require 'git'
+# require 'git'
 require 'claide'
 require 'cocoapods-downloader'
 require "lg_pod_plugin/version"
-require_relative 'lg_pod_plugin/log'
-require_relative 'lg_pod_plugin/runner'
-require_relative 'lg_pod_plugin/install'
-require_relative 'lg_pod_plugin/request'
-require_relative 'lg_pod_plugin/database'
-require_relative 'lg_pod_plugin/downloader'
-require_relative 'lg_pod_plugin/gitlab_api'
-require_relative 'lg_pod_plugin/gitlab_download'
 require 'cocoapods-core/podfile/target_definition'
 
+require_relative 'lg_pod_plugin/db/database'
+require_relative 'lg_pod_plugin/utils/log'
+require_relative 'lg_pod_plugin/config/target'
+require_relative 'lg_pod_plugin/pod/external_pod'
+require_relative 'lg_pod_plugin/pod/release-pod'
+require_relative 'lg_pod_plugin/installer/project'
+require_relative 'lg_pod_plugin/downloader/l_cache'
+require_relative 'lg_pod_plugin/utils/file_path'
+require_relative 'lg_pod_plugin/config/l_config'
+require_relative 'lg_pod_plugin/installer/main'
+require_relative 'lg_pod_plugin/installer/install'
+require_relative 'lg_pod_plugin/downloader/request'
+require_relative 'lg_pod_plugin/db/database'
+require_relative 'lg_pod_plugin/net/l_uri'
+require_relative 'lg_pod_plugin/utils/l_util'
+require_relative 'lg_pod_plugin/git/gitlab_api'
+require_relative 'lg_pod_plugin/net/net-ping'
+require_relative 'lg_pod_plugin/git/gitlab_archive'
+require_relative 'lg_pod_plugin/config/lockfile_model'
+require_relative 'lg_pod_plugin/downloader/downloader'
+require_relative 'lg_pod_plugin/git/git_download'
+require_relative 'lg_pod_plugin/git/git_clone'
+
 module LgPodPlugin
   autoload :Command, 'command/command'
   class Error < StandardError; end

data/lib/sqlite3-1.5.3-arm64-darwin/API_CHANGES.md

@@ -0,0 +1,49 @@
+# API Changes
+
+* SQLite3::Database#execute only accepts an array for bind parameters.
+
+* SQLite3::ResultSet used to query the database for the first row, regardless
+  of whether the user asked for it or not.  I have removed that so that rows
+  will not be returned until the user asks for them.  This is a subtle but
+  sometimes important change in behavior.
+
+  83882d2208ed189361617d5ab8532a325aaf729d
+
+* SQLite3::Database#trace now takes either a block or an object that responds
+  to "call".  The previous implementation passed around a VALUE that was cast
+  to a void *.  This is dangerous because the value could get garbage collected
+  before the proc was called.  If the user wants data passed around with the
+  block, they should use variables available to the closure or create an
+  object.
+
+* SQLite3::Statement#step automatically converts to ruby types, where before
+  all values were automatically yielded as strings.  This will only be a
+  problem for people who were accessing information about the database that
+  wasn't previously passed through the pure ruby conversion code.
+
+* SQLite3::Database#errmsg no longer takes a parameter to return error
+  messages as UTF-16.  Do people even use that?  I opt for staying UTF-8 when
+  possible.  See test_integration.rb test_errmsg_utf16
+
+* SQLite3::Database#authorize same changes as trace
+
+* test/test_tc_database.rb was removed because we no longer use the Driver
+  design pattern.
+
+# Garbage Collection Strategy
+
+All statements keep pointers back to their respective database connections.
+The @connection instance variable on the Statement handle keeps the database
+connection alive.  Memory allocated for a statement handler will be freed in
+two cases:
+
+* close is called on the statement
+* The SQLite3::Database object gets garbage collected
+
+We can't free the memory for the statement in the garbage collection function
+for the statement handler.  The reason is because there exists a race
+condition.  We cannot guarantee the order in which objects will be garbage
+collected.  So, it is possible that a connection and a statement are up for
+garbage collection.  If the database connection were to be free'd before the
+statement, then boom.  Instead we'll be conservative and free unclosed
+statements when the connection is terminated.