lg_pod_plugin 1.1.3 → 1.1.4

data/lib/lg_pod_plugin/l_util.rb

@@ -1,145 +0,0 @@
-require 'resolv'
-require "ipaddr"
-require 'archive/zip'
-require_relative 'log'
-require_relative 'l_config'
-
-module LgPodPlugin
-  class LUtils
-
-    #判断对象是不是 String
-    def self.is_string(obj)
-      if "#{obj.class}" == "String"
-        return true 
-      else 
-        return false 
-      end
-    end
-
-    # 解压文件
-    def self.unzip_file (zip_file, dest_dir)
-      begin
-        Archive::Zip.extract(
-          zip_file,
-          dest_dir,
-          :symlinks => true
-        )
-        return true
-      rescue => err
-        return false
-      end
-
-    end
-
-    # 下载 zip 格式文件
-    def self.download_gitlab_zip_file(download_url, token, file_name)
-      cmds = ['curl']
-      cmds << "--header \"Authorization: Bearer #{token}\"" if token
-      # cmds << "--progress-bar"
-      cmds << "-o #{file_name}"
-      cmds << "--connect-timeout 15"
-      cmds << "--retry 3"
-      cmds << download_url
-      cmds_to_s = cmds.join(" ")
-      system(cmds_to_s)
-    end
-
-    # gitlab 下载压缩文件
-    def self.download_github_zip_file(download_url, file_name)
-      cmds = ['curl']
-      cmds << "-o #{file_name}"
-      cmds << "--connect-timeout 15"
-      cmds << "--retry 3"
-      cmds << download_url
-      cmds_to_s = cmds.join(" ")
-      system(cmds_to_s)
-    end
-
-    def self.git_to_uri(git)
-      begin
-        uri = URI(git)
-      rescue
-        if git.include?("git@") && git.include?(":")
-          uri = URI("http://" + git[4...git.length].split(":").first)
-        else
-          return nil
-        end
-      end
-    end
-
-    def self.commit_from_ls_remote(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)
-        sha = match1[1] unless match1.nil?
-        refs = output.split("\n")
-        return [sha, nil] unless refs.is_a?(Array)
-        refs.each do |element|
-          next if element.include?("HEAD") || element.include?("refs/tags")
-          next unless element.include?(sha)
-          find_branch = element.split("refs/heads/").last
-          return [sha, find_branch]
-        end
-      else
-        match = %r{([a-z0-9]*)\trefs\/(heads|tags)\/#{Regexp.quote(encoded_branch_name)}}.match(output)
-        sha = match[1] unless match.nil?
-        ref = match[0].split("refs/heads/").last unless match.nil?
-        return [sha, ref]
-      end
-
-    end
-
-    #截取git-url 拿到项目绝对名称 比如 l-base-ios
-    def self.get_git_project_name(git)
-      self.get_gitlab_base_url(git).split("/").last
-    end
-
-    # 是否能够使用 gitlab 下载 zip 文件
-    def self.is_use_gitlab_archive_file(git)
-      return false if git.include?("https://github.com") || git.include?("https://gitee.com")
-      config = LRequest.shared.config
-      return false if (!config || !config.access_token)
-      return true if project = config.project
-      project_name = self.get_git_project_name(git)
-      LRequest.shared.config.project = GitLabAPI.request_project_info(config.host, project_name, config.access_token, git)
-      return true if LRequest.shared.config.project
-    end
-
-    # 截取 url
-    def self.get_gitlab_base_url(git)
-      if git.include?(".git")
-        base_url = git.split(".git").first
-      else
-        base_url = git
-      end
-    end
-
-    # 根据参数生成下载 url
-    def self.get_gitlab_download_url(base_url, branch, tag, commit, project_name)
-      if base_url.include?("http:") || base_url.include?("https:")
-        if branch
-          return base_url + "/-/archive/" + branch + "/#{project_name}-#{branch}.zip"
-        elsif tag
-          return base_url + "/-/archive/" + tag + "/#{project_name}-#{tag}.zip"
-        elsif commit
-          return base_url + "/-/archive/" + commit + "/#{project_name}-#{commit}.zip"
-        else
-          return nil
-        end
-      end
-      return nil unless base_url.include?("ssh://git@gitlab") || base_url.include?("git@")
-      project = LRequest.shared.config.project
-      if project && project.web_url && project.web_url.include?("http")
-        self.get_gitlab_download_url(project.web_url, branch, tag, commit, project_name)
-      else
-        return nil
-      end
-    end
-
-    def self.url_encode(url)
-      url.to_s.b.gsub(/[^a-zA-Z0-9_\-.~]/n) { |m| sprintf('%%%02X', m.unpack1('C')) }
-    end
-
-  end
-end

data/lib/lg_pod_plugin/net-ping.rb

@@ -1,41 +0,0 @@
-require 'uri'
-require 'resolv'
-require "ipaddr"
-require_relative 'l_util'
-
-module LgPodPlugin
-
-  class Ping
-    attr_accessor :uri
-    attr_accessor :ip
-    attr_accessor :network_ok
-    def initialize(url)
-      self.uri = LUtils.git_to_uri(url)
-    end
-
-    def ping
-      return false unless self.uri
-      result = %x(ping #{uri.host} -t 1)
-      if result.include?("timeout")
-        return false
-      end
-      if result && result.include?("(") && result.include?("):")
-        ip_address = result.split("(").last.split(")").first
-        begin
-          if IPAddr.new ip_address
-            self.ip = ip_address
-            return  true
-          else
-            return false
-          end
-        rescue
-          return false
-        end
-      else
-        return false
-      end
-    end
-
-  end
-
-end

data/lib/lg_pod_plugin/podspec.rb

@@ -1,156 +0,0 @@
-require 'cocoapods'
-require 'cocoapods-core'
-
-module LgPodPlugin
-
-  class PodSpec
-    attr_accessor :source_files
-    def self.form_file(path)
-      spec = Pod::Specification.from_file(path)
-      return PodSpec.new(spec)
-    end
-
-    def initialize(spec)
-      set = Set[]
-      attributes_hash = spec.send(:attributes_hash)
-      return nil unless attributes_hash.is_a?(Hash)
-      license = attributes_hash["license"]
-      if license.is_a?(Hash)
-        license_file = license["file"]
-        set.add(license_file) if license_file
-      else
-        set.add("LICENSE")
-      end
-      # 解析主模块依赖信息
-      set.merge(parse_subspec_with(attributes_hash))
-      subspecs = spec.subspecs
-      unless subspecs.is_a?(Array)
-        self.source_files = set
-        return
-      end
-      subspecs.each do |sub_spec|
-        next unless sub_attributes_hash = sub_spec.send(:attributes_hash)
-        next unless sub_attributes_hash.is_a?(Hash)
-        sub_set = self.parse_subspec_with(sub_attributes_hash)
-        next if sub_set.empty?
-        set.merge(sub_set)
-      end
-      self.source_files = set
-    end
-
-    # 公共解析解析subspec
-    def parse_subspec_with(hash)
-      set = Set[]
-      source_files = self.parse_source_files(hash["source_files"])
-      set.merge(source_files) unless source_files.empty?
-      resources = self.parse_resource_files(hash["resource"] ||= hash["resources"])
-      set.merge(resources) unless resources.empty?
-      resource_bundles = self.parse_resource_bundles(hash["resource_bundle"] ||= hash["resource_bundles"])
-      set.merge(resource_bundles) unless resource_bundles.empty?
-      project_header_files = self.parse_project_header_files(hash["project_header_files"])
-      set.merge(resource_bundles) unless project_header_files.empty?
-      private_header_files = self.parse_private_header_files(hash["private_header_files"])
-      set.merge(private_header_files) unless private_header_files.empty?
-      vendored_frameworks = self.parse_vendored_frameworks(hash["vendored_frameworks"])
-      set.merge(vendored_frameworks) unless vendored_frameworks.empty?
-      vendored_library = self.parse_vendored_library(hash["vendored_library"] ||= hash["vendored_libraries"])
-      set.merge(vendored_library) unless vendored_library.empty?
-      #parse_preserve_path
-      preserve_paths = self.parse_preserve_path(hash["preserve_path"] ||= hash["preserve_paths"])
-      set.merge(preserve_paths) unless preserve_paths.empty?
-      module_map = self.parse_module_map(hash["module_map"])
-      set.merge(module_map) unless module_map.empty?
-      return set
-    end
-
-    # 公共解析文件路径的方法
-    def parse_public_source_filse(source_files)
-      return [] unless source_files
-      array = []
-      if LUtils.is_string(source_files)
-        if source_files.include?("/")
-          array.append(source_files.split("/").first)
-        else
-          array.append(source_files)
-        end
-      elsif source_files.is_a?(Array)
-        source_files.each do |element|
-          next unless LUtils.is_string(element)
-          if element.include?("/")
-            array.append(element.split("/").first)
-          else
-            array.append(element)
-          end
-        end
-      elsif source_files.is_a?(Hash)
-        source_files.each do |key,val|
-          if LUtils.is_string(val)
-            if val.include?("/")
-              array.append(val.split("/").first)
-            else
-              array.append(val)
-            end
-          elsif val.is_a?(Array)
-            val.each do |element|
-              next unless LUtils.is_string(element)
-              if element.include?("/")
-                array.append(element.split("/").first)
-              else
-                array.append(element)
-              end
-            end
-          end
-        end
-      end
-      return array
-    end
-
-    # 解析source_fils路径
-    def parse_source_files(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-
-    # 解析 resource所在路径
-    def parse_resource_files(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-
-    # 解析public_header_files字段的值
-    def parse_public_header_files(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-    # 解析 parse_resource_bundles
-    def parse_resource_bundles(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-    # 解析 project_header_files
-    def parse_project_header_files(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-
-    # 解析 private_header_files
-    def parse_private_header_files(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-    # 解析 vendored_frameworks
-    def parse_vendored_frameworks(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-    # 解析 parse_vendored_library
-    def parse_vendored_library(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-
-    # 解析 parse_preserve_path
-    def parse_preserve_path(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-
-    # 解析 module_map
-    def parse_module_map(source_files)
-      return self.parse_public_source_filse(source_files)
-    end
-
-  end
-
-end

data/lib/lg_pod_plugin/release-pod.rb

@@ -1,90 +0,0 @@
-require 'cocoapods'
-require 'cocoapods-core'
-require_relative 'l_util'
-require_relative 'l_cache'
-
-module LgPodPlugin
-
-  class ReleasePod
-
-    def self.resolve_dependencies(work_space, podfile, lockfile, installer, external_pods)
-      installer.resolve_dependencies
-      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
-      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"]
-        checksum = spec.send(:checksum)
-        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
-        end
-        pod_version = attributes_hash["version"]
-        source = attributes_hash['source']
-        next unless source.is_a?(Hash)
-        git = source["git"]
-        tag = source["tag"]
-        next unless (git && tag) && (git.include?("https://github.com"))
-        requirements = { :git => git, :tag => tag, :release_pod => true, :spec => spec}
-        LRequest.shared.checkout_options = requirements
-        next unless LCache.new(work_space).find_pod_cache(pod_name, { :git => git, :tag => tag })
-        LgPodPlugin::Installer.new(podfile, pod_name, requirements)
-      end
-
-    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.install_release_pod(work_space, podfile, repo_update, update, external_pods, local_pods)
-      #切换工作目录到当前工程下, 开始执行pod install
-      FileUtils.chdir(work_space)
-      # 安装 relase_pod
-      LgPodPlugin.log_green "Pre-downloading Release Pods"
-      Pod::Config.instance.verbose = true
-      pods_path = work_space.join('Pods')
-      lockfile_path = work_space.join("Podfile.lock")
-      lock_file = Pod::Lockfile.from_file(lockfile_path) if lockfile_path.exist?
-      sandobx = Pod::Sandbox.new(pods_path)
-      installer = Pod::Installer.new(sandobx, podfile, lock_file)
-      installer.repo_update = repo_update
-      if update
-        if external_pods.empty?
-          installer.update = true
-        else
-          pods =  LRequest.shared.libs.merge!(local_pods)
-          installer.update = { :pods => pods.keys}
-        end
-      else
-        installer.update = false
-      end
-      installer.deployment = false
-      installer.clean_install = false
-      installer.prepare
-      resolve_dependencies(work_space, podfile, lock_file, installer, external_pods)
-      dependencies(installer)
-    end
-
-  end
-
-end

data/lib/lg_pod_plugin/request.rb

@@ -1,221 +0,0 @@
-require 'net/http'
-require 'singleton'
-require 'cocoapods-core'
-require_relative 'l_config'
-require_relative 'l_cache'
-require_relative 'net-ping'
-require_relative 'downloader'
-require_relative 'gitlab_download'
-module LgPodPlugin
-
-  class LRequest
-    include Singleton
-    # pod name
-    attr_accessor :name
-    # 当前token
-    attr_accessor :token
-    # 缓存
-    attr_accessor :cache
-    # 配置
-    attr_accessor :config
-    # 是否更新
-    attr_accessor :is_update
-    # 工作目录
-    attr_accessor :workspace
-    # 是否是还有 git 地址参数
-    attr_accessor :single_git
-    # git 工具类
-    attr_accessor :git_util
-    # 需要更新的 pod 集合
-    attr_accessor :libs
-    # 下载类
-    attr_accessor :downloader
-    # lock_info
-    attr_accessor :lock_info
-    # 实际下载请求参数
-    attr_accessor :request_params
-    # 传入的请求参数
-    attr_accessor :checkout_options
-    # 网络ip 信息
-    attr_accessor :net_ping
-
-    public
-    def get_lock_info
-      lock_file_path = self.workspace.join("Podfile.lock")
-      if lock_file_path.exist?
-        lock_file = Pod::Lockfile.from_file(lock_file_path)
-        internal_data = lock_file.send(:internal_data)
-        release_pods = Hash.new
-        pods = internal_data["PODS"] ||= {}
-        pods.each do |key, val|
-          if LUtils.is_string(key)
-            pod_name = key.split(" ").first if key.include?(" ")
-            tag = key[/(?<=\().*?(?=\))/]
-            release_pods[pod_name] = tag
-          elsif key.is_a?(Hash)
-            key_name = key.keys.first
-            next unless key_name
-            pod_name = key_name.split(" ").first if key_name.include?(" ")
-            tag = key_name[/(?<=\().*?(?=\))/]
-            release_pods[pod_name] = tag
-          else
-            next
-          end
-        end
-        external_source = internal_data["EXTERNAL SOURCES"] ||= {}
-        checkout_options = internal_data["CHECKOUT OPTIONS"] ||= {}
-        { "external_source" => external_source, "checkout_options" => checkout_options, "release_pods" => release_pods }
-      else
-        { "external_source" => {}, "checkout_options" => {}, "release_pods" => {} }
-      end
-    end
-
-    # 获取缓存用的hash_map
-    public
-    def get_cache_key_params
-      hash_map = Hash.new
-      git = self.checkout_options[:git] ||= self.request_params[:git]
-      tag = self.checkout_options[:tag] ||= self.request_params[:tag]
-      branch = self.checkout_options[:branch] ||= self.request_params[:branch]
-      commit = self.checkout_options[:commit] ||= self.request_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.lock_info["release_pods"] ||= {}
-        _external_source = self.lock_info["external_source"][self.name] ||= {}
-        _checkout_options = self.lock_info["checkout_options"][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 branch == lock_branch && !self.is_update
-          if lock_commit && !lock_commit.empty?
-            hash_map[:commit] = lock_commit
-          end
-          hash_map["is_delete"] = true
-          return hash_map
-        else
-          _, new_commit = LGitUtil.git_ls_remote_refs(self.name ,git, branch, nil, nil)
-          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
-        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 && !self.is_update
-          id = LPodLatestRefs.get_pod_id(self.name, git)
-          pod_info = LSqliteDb.shared.query_pod_refs(id)
-          if pod_info && pod_info.commit
-            new_commit = pod_info.commit if pod_info
-            new_branch = pod_info.branch if pod_info
-            hash_map[:commit] = new_commit if new_commit
-            hash_map[:branch] = new_branch if new_branch
-            hash_map["is_delete"] = true
-            return hash_map
-          end
-        end
-        new_branch, new_commit = LGitUtil.git_ls_remote_refs(self.name, git, nil, nil, 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
-      if self.lock_info == nil
-        self.lock_info = self.get_lock_info
-      end
-      Hash.new.merge!(self.get_lock_params)
-    end
-
-    public
-    def setup_pod_info(name, workspace, options = {})
-      self.name = name
-      tag = options[:tag]
-      git = options[:git]
-      commit = options[:commit]
-      branch = options[:branch]
-      self.workspace = workspace
-      if (git && branch) || (git && commit) || (git && tag)
-        self.single_git = false
-      else
-        self.single_git = true
-      end
-      self.net_ping = Ping.new(git)
-      self.net_ping.network_ok = self.net_ping.ping
-      self.checkout_options = Hash.new.deep_merge(options)
-      self.request_params = self.get_request_params
-      self.config = LConfig.getConfig(git)
-      self.cache = LCache.new(self.workspace)
-      self.git_util = LGitUtil.new(name, self.checkout_options)
-      self.downloader = LDownloader.new(name, self.checkout_options)
-    end
-
-    def self.shared
-      return LRequest.instance
-    end
-
-  end
-
-end