cocoapods-binary-ht 1.0.0

data/lib/cocoapods-binary-ht/helper/lockfile.rb

@@ -0,0 +1,90 @@
+require_relative "checksum"
+
+module PodPrebuild
+  class Lockfile
+    attr_reader :lockfile, :data
+
+    def initialize(lockfile)
+      @lockfile = lockfile
+      @data = lockfile.to_hash
+    end
+
+    def pods
+      @pods ||= (@data["PODS"] || []).map { |v| pod_from(v) }.to_h
+    end
+
+    def external_sources
+      @data["EXTERNAL SOURCES"] || {}
+    end
+
+    def dev_pod_sources
+      @dev_pod_sources ||= external_sources.select { |_, attributes| attributes.key?(:path) } || {}
+    end
+
+    def dev_pod_names
+      # There are 2 types of external sources:
+      # - Development pods: declared with `:path` option in Podfile, corresponding to `:path` in the Lockfile
+      # - External remote pods: declared with `:git` option in Podfile, corresponding to `:git` in the Lockfile
+      # --------------------
+      # EXTERNAL SOURCES:
+      #   ADevPod:
+      #     :path: path/to/dev_pod
+      #   AnExternalRemotePod:
+      #     :git: git@remote_url
+      #     :commit: abc1234
+      # --------------------
+      @dev_pod_names ||= dev_pod_sources.keys.to_set
+    end
+
+    def dev_pods
+      dev_pod_names_ = dev_pod_names
+      @dev_pods ||= pods.select { |name, _| dev_pod_names_.include?(name) }
+    end
+
+    def non_dev_pods
+      dev_pod_names_ = dev_pod_names
+      @non_dev_pods ||= pods.reject { |name, _| dev_pod_names_.include?(name) }
+    end
+
+    def subspec_vendor_pods
+      dev_pod_names_ = dev_pod_names
+      @subspec_vendor_pods ||= subspec_pods.reject { |name, _| dev_pod_names_.include?(name) }
+    end
+
+    # Return content hash (Hash the directory at source path) of a dev_pod
+    # Return nil if it's not a dev_pod
+    def dev_pod_hash(pod_name)
+      dev_pod_hashes_map[pod_name]
+    end
+
+    private
+
+    def subspec_pods
+      @subspec_pods ||= pods.keys
+        .select { |k| k.include?("/") }
+        .group_by { |k| k.split("/")[0] }
+    end
+
+    # Generate a map between a dev_pod and it source hash
+    def dev_pod_hashes_map
+      @dev_pod_hashes_map ||=
+        dev_pod_sources.map { |name, attribs| [name, FolderChecksum.git_checksum(attribs[:path])] }.to_h
+    end
+
+    # Parse an item under `PODS` section of a Lockfile
+    # @param hash_or_string: an item under `PODS` section, could be a Hash (if having dependencies) or a String
+    #   Examples:
+    # --------------------------
+    #   PODS:
+    #     - FrameworkA (0.0.1)
+    #     - FrameworkB (0.0.2):
+    #       - DependencyOfB
+    # -------------------------
+    # @return [framework_name, version] (for ex. ["AFramework", "0.0.1"])
+    def pod_from(hash_or_string)
+      name_with_version = hash_or_string.is_a?(Hash) ? hash_or_string.keys[0] : hash_or_string
+      match = name_with_version.match(/(\S+) \((\S+)\)/)
+      [match[1], match[2]]
+    end
+  end
+end

data/lib/cocoapods-binary-ht/helper/path_utils.rb

@@ -0,0 +1,8 @@
+# Copyright 2019 panda Holdings PTE LTE (panda), All rights reserved.
+# Use of this source code is governed by an MIT-style license that can be found in the LICENSE file
+
+class PathUtils
+  def self.remove_last_path_component(path, num_components = 1)
+    path.split("/")[0...-num_components].join("/")
+  end
+end

data/lib/cocoapods-binary-ht/helper/podspec.rb

@@ -0,0 +1,20 @@
+module Pod
+  class Specification
+    def empty_source_files?
+      unless subspecs.empty?
+        # return early if there are some files in subpec(s) but process the spec itself
+        return false unless subspecs.all?(&:empty_source_files?)
+      end
+
+      check = lambda do |patterns|
+        patterns = [patterns] if patterns.is_a?(String)
+        patterns.reject(&:empty?).all? do |pattern|
+          Xcodeproj::Constants::HEADER_FILES_EXTENSIONS.any? { |ext| pattern.end_with?(ext) }
+        end
+      end
+      available_platforms.all? do |platform|
+        check.call(consumer(platform).source_files)
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/hooks/post_install.rb

@@ -0,0 +1,23 @@
+module PodPrebuild
+  class PostInstallHook
+    def initialize(installer_context)
+      @installer_context = installer_context
+    end
+
+    def run
+      diagnose if PodPrebuild::Env.integration_stage?
+    end
+
+    private
+
+    def diagnose
+      Pod::UI.title("Diagnosing cocoapods-binary-ht") do
+        PodPrebuild::Diagnosis.new(
+          cache_validation: PodPrebuild.state.cache_validation,
+          standard_sandbox: @installer_context.sandbox,
+          specs: @installer_context.umbrella_targets.map(&:specs).flatten
+        ).run
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/hooks/pre_install.rb

@@ -0,0 +1,121 @@
+module PodPrebuild
+  class PreInstallHook
+    include ObjectSpace
+
+    attr_reader :installer_context, :podfile, :prebuild_sandbox, :standard_sandbox, :cache_validation
+
+    def initialize(installer_context)
+      @installer_context = installer_context
+      @podfile = installer_context.podfile
+      @pod_install_options = {}
+      @prebuild_sandbox = nil
+      @standard_sandbox = installer_context.sandbox
+      @cache_validation = nil
+    end
+
+    def run
+      return if @installer_context.sandbox.is_a?(Pod::PrebuildSandbox)
+
+      log_section "🚀  Prebuild frameworks"
+      ensure_valid_podfile
+      save_installation_states
+      create_prebuild_sandbox
+      Pod::UI.title("Detect implicit dependencies") { detect_implicit_dependencies }
+      Pod::UI.title("Validate prebuilt cache") { validate_cache }
+      prebuild! if PodPrebuild.config.prebuild_job?
+
+      PodPrebuild::Env.next_stage!
+      prepare_for_integration
+      log_section "🤖  Resume pod installation"
+      require_relative "../pod-binary/integration"
+    end
+
+    private
+
+    def save_installation_states
+      save_pod_install_options
+    end
+
+    def save_pod_install_options
+      # Fetch original installer (which is running this pre-install hook) options,
+      # then pass them to our installer to perform update if needed
+      # Looks like this is the most appropriate way to figure out that something should be updated
+      @original_installer = ObjectSpace.each_object(Pod::Installer).first
+      @pod_install_options[:update] = @original_installer.update
+      @pod_install_options[:repo_update] = @original_installer.repo_update
+    end
+
+    def ensure_valid_podfile
+      podfile.target_definition_list.each do |target_definition|
+        next if target_definition.explicit_prebuilt_pod_names.empty?
+        raise "cocoapods-binary-ht requires `use_frameworks!`" unless target_definition.uses_frameworks?
+      end
+    end
+
+    def create_prebuild_sandbox
+      @prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sandbox)
+      Pod::UI.message "Create prebuild sandbox at #{@prebuild_sandbox.root}"
+    end
+
+    def detect_implicit_dependencies
+      @original_installer.resolve_dependencies
+      all_specs = @original_installer.analysis_result.specifications
+      pods_with_empty_source_files = all_specs
+        .group_by { |spec| spec.name.split("/")[0] }
+        .select { |_, specs| specs.all?(&:empty_source_files?) }
+        .keys
+      PodPrebuild.config.update_detected_excluded_pods!(pods_with_empty_source_files)
+      PodPrebuild.config.update_detected_prebuilt_pod_names!(@original_installer.prebuilt_pod_names)
+      Pod::UI.puts "Exclude pods with empty source files: #{pods_with_empty_source_files.to_a}"
+    end
+
+    def validate_cache
+      prebuilt_lockfile = Pod::Lockfile.from_file(prebuild_sandbox.root + "Manifest.lock")
+      @cache_validation = PodPrebuild::CacheValidator.new(
+        podfile: podfile,
+        pod_lockfile: installer_context.lockfile,
+        prebuilt_lockfile: prebuilt_lockfile,
+        validate_prebuilt_settings: PodPrebuild.config.validate_prebuilt_settings,
+        generated_framework_path: prebuild_sandbox.generate_framework_path,
+        sandbox_root: prebuild_sandbox.root,
+        ignored_pods: PodPrebuild.config.excluded_pods,
+        prebuilt_pod_names: PodPrebuild.config.prebuilt_pod_names
+      ).validate
+      path_to_save_cache_validation = PodPrebuild.config.save_cache_validation_to
+      @cache_validation.update_to(path_to_save_cache_validation) unless path_to_save_cache_validation.nil?
+      cache_validation.print_summary
+      PodPrebuild.state.update(:cache_validation => cache_validation)
+    end
+
+    def prebuild!
+      binary_installer = Pod::PrebuildInstaller.new(
+        sandbox: prebuild_sandbox,
+        podfile: podfile,
+        lockfile: installer_context.lockfile,
+        cache_validation: cache_validation
+      )
+      binary_installer.update = @pod_install_options[:update]
+      binary_installer.repo_update = @pod_install_options[:repo_update]
+
+      Pod::UI.title("Prebuilding...") do
+        binary_installer.clean_delta_file
+        binary_installer.install!
+      end
+    end
+
+    def prepare_for_integration
+      # Remove local podspec of external sources so that it downloads sources correctly.
+      # Otherwise, with incremental pod installation, CocoaPods downloads the sources
+      # based on the `s.source` declaration in the podspecs which are sometimes incorrect.
+      PodPrebuild.config.prebuilt_pod_names.each do |name|
+        @standard_sandbox.remove_local_podspec(name) if @standard_sandbox.checkout_sources.key?(name)
+      end
+    end
+
+    def log_section(message)
+      Pod::UI.puts "-----------------------------------------"
+      Pod::UI.puts message
+      Pod::UI.puts "-----------------------------------------"
+    end
+  end
+end

data/lib/cocoapods-binary-ht/main.rb

@@ -0,0 +1,21 @@
+# Copyright 2019 panda Holdings PTE LTE (panda), All rights reserved.
+# Use of this source code is governed by an MIT-style license that can be found in the LICENSE file
+
+require_relative "ui"
+require_relative "dependencies_graph/dependencies_graph"
+require_relative "cache/all"
+require_relative "helper/benchmark_show"
+require_relative "helper/json"
+require_relative "helper/lockfile"
+require_relative "helper/path_utils"
+require_relative "helper/podspec"
+require_relative "env"
+require_relative "state_store"
+require_relative "hooks/post_install"
+require_relative "hooks/pre_install"
+require_relative "pod-binary/prebuild_dsl"
+require_relative "pod-binary/prebuild_hook"
+require_relative "pod-binary/prebuild"
+require_relative "prebuild_output/metadata"
+require_relative "prebuild_output/output"
+require_relative "diagnosis/diagnosis"

data/lib/cocoapods-binary-ht/pod-binary/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2018 leavez <gaojiji@gmail.com>
+
+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.

data/lib/cocoapods-binary-ht/pod-binary/helper/build.rb

@@ -0,0 +1,37 @@
+require_relative "../../pod-rome/xcodebuild_raw"
+require_relative "../../pod-rome/xcodebuild_command"
+
+  module PodPrebuild
+  def self.build(options)
+    targets = options[:targets] || []
+    return if targets.empty?
+
+    options[:sandbox] = Pod::Sandbox.new(Pathname(options[:sandbox])) unless options[:sandbox].is_a?(Pod::Sandbox)
+    options[:build_dir] = build_dir(options[:sandbox].root)
+
+    case targets[0].platform.name
+    when :ios, :tvos, :watchos
+      PodPrebuild::XcodebuildCommand.new(options).run
+    when :osx
+      xcodebuild(
+        sandbox: options[:sandbox],
+        targets: targets,
+        configuration: options[:configuration],
+        sdk: "macosx",
+        args: options[:args]
+      )
+    else
+      raise "Unsupported platform for '#{targets[0].name}': '#{targets[0].platform.name}'"
+    end
+    raise "The build directory was not found in the expected location" unless options[:build_dir].directory?
+  end
+
+  def self.remove_build_dir(sandbox_root)
+    path = build_dir(sandbox_root)
+    path.rmtree if path.exist?
+  end
+
+  def self.build_dir(sandbox_root)
+    sandbox_root.parent + "build"
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/helper/detected_prebuilt_pods/installer.rb

@@ -0,0 +1,25 @@
+module Pod
+  class Installer
+    # Returns the names of pod targets detected as prebuilt, including
+    # those declared in Podfile and their dependencies
+    def prebuilt_pod_names
+      prebuilt_pod_targets.map(&:name).to_set
+    end
+
+    # Returns the pod targets detected as prebuilt, including
+    # those declared in Podfile and their dependencies
+    def prebuilt_pod_targets
+      @prebuilt_pod_targets ||= begin
+        explicit_prebuilt_pod_names = aggregate_targets
+          .flat_map { |target| target.target_definition.explicit_prebuilt_pod_names }
+          .uniq
+
+        targets = pod_targets.select { |target| explicit_prebuilt_pod_names.include?(target.pod_name) }
+        dependencies = targets.flat_map(&:recursive_dependent_targets) # Treat dependencies as prebuilt pods
+        all = (targets + dependencies).uniq
+        all = all.reject { |target| sandbox.local?(target.pod_name) } unless PodPrebuild.config.dev_pods_enabled?
+        all
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/helper/detected_prebuilt_pods/target_definition.rb

@@ -0,0 +1,29 @@
+module Pod
+  class Podfile
+    class TargetDefinition
+      def detect_prebuilt_pod(name, requirements)
+        @explicit_prebuilt_pod_names ||= []
+        options = requirements.last || {}
+        @explicit_prebuilt_pod_names << Specification.root_name(name) if options.is_a?(Hash) && options[:binary]
+        options.delete(:binary) if options.is_a?(Hash)
+        requirements.pop if options.empty?
+      end
+
+      # Returns the names of pod targets explicitly declared as prebuilt in Podfile using `:binary => true`.
+      def explicit_prebuilt_pod_names
+        names = @explicit_prebuilt_pod_names || []
+        names += parent.explicit_prebuilt_pod_names if !parent.nil? && parent.is_a?(TargetDefinition)
+        names
+      end
+
+      # ---- patch method ----
+      # We want modify `store_pod` method, but it's hard to insert a line in the
+      # implementation. So we patch a method called in `store_pod`.
+      original_parse_inhibit_warnings = instance_method(:parse_inhibit_warnings)
+      define_method(:parse_inhibit_warnings) do |name, requirements|
+        detect_prebuilt_pod(name, requirements)
+        original_parse_inhibit_warnings.bind(self).call(name, requirements)
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/helper/names.rb

@@ -0,0 +1,27 @@
+# ABOUT NAMES
+#
+# There are many kinds of name in cocoapods. Two main names are widely used in this plugin.
+# - root_spec.name (spec.root_name, targe.pod_name):
+#   aka "pod_name"
+#   the name we use in podfile. the concept.
+#
+# - target.name:
+#   aka "target_name"
+#   the name of the final target in xcode project. the final real thing.
+#
+# One pod may have multiple targets in xcode project, due to one pod can be used in mutiple
+# platform simultaneously. So one `root_spec.name` may have multiple coresponding `target.name`s.
+# Therefore, map a spec to/from targets is a little complecated. It's one to many.
+#
+
+# Tool to transform Pod_name to target efficiently
+module Pod
+  def self.fast_get_targets_for_pod_name(pod_name, targets, cache)
+    pod_name = pod_name.split("/")[0] # Look for parent spec instead of subspecs
+    if cache.empty?
+      targets.select { |target| target.name == pod_name }
+    else
+      cache.first[pod_name] || []
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/helper/podfile_options.rb

@@ -0,0 +1,2 @@
+require_relative "detected_prebuilt_pods/target_definition"
+require_relative "detected_prebuilt_pods/installer"

data/lib/cocoapods-binary-ht/pod-binary/helper/prebuild_sandbox.rb

@@ -0,0 +1,71 @@
+require_relative "names"
+
+module Pod
+  class PrebuildSandbox < Sandbox
+    # [String] standard_sandbox_path
+    def self.from_standard_sandbox_path(path)
+      prebuild_sandbox_path = Pathname.new(path).realpath + ".." + PodPrebuild.config.prebuild_sandbox_path
+      new(prebuild_sandbox_path)
+    end
+
+    def self.from_standard_sandbox(sandbox)
+      from_standard_sandbox_path(sandbox.root)
+    end
+
+    def standard_sanbox_path
+      root.parent
+    end
+
+    def generate_framework_path
+      root + "GeneratedFrameworks"
+    end
+
+    # @param name [String] pass the target.name (may containing platform suffix)
+    # @return [Pathname] the folder containing the framework file.
+    def framework_folder_path_for_target_name(name)
+      generate_framework_path + name
+    end
+
+    def exsited_framework_target_names
+      existed_framework_name_pairs.map { |pair| pair[0] }.uniq
+    end
+
+    def exsited_framework_pod_names
+      existed_framework_name_pairs.map { |pair| pair[1] }.uniq
+    end
+
+    def existed_target_names_for_pod_name(pod_name)
+      existed_framework_name_pairs.select { |pair| pair[1] == pod_name }.map { |pair| pair[0] }
+    end
+
+    def save_pod_name_for_target(target)
+      folder = framework_folder_path_for_target_name(target.name)
+      return unless folder.exist?
+
+      flag_file_path = folder + "#{target.pod_name}.pod_name"
+      File.write(flag_file_path.to_s, "")
+    end
+
+    private
+
+    def pod_name_for_target_folder(target_folder_path)
+      name = Pathname.new(target_folder_path).children.find do |child|
+        child.to_s.end_with? ".pod_name"
+      end
+      name = name.basename(".pod_name").to_s unless name.nil?
+      name ||= Pathname.new(target_folder_path).basename.to_s # for compatibility with older version
+      name
+    end
+
+    # Array<[target_name, pod_name]>
+    def existed_framework_name_pairs
+      return [] unless generate_framework_path.exist?
+
+      generate_framework_path.children.map do |framework_path|
+        if framework_path.directory? && !framework_path.children.empty?
+          [framework_path.basename.to_s, pod_name_for_target_folder(framework_path)]
+        end
+      end.reject(&:nil?).uniq
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/helper/sandbox.rb

@@ -0,0 +1,9 @@
+require_relative "prebuild_sandbox"
+
+module Pod
+  class Sandbox
+    def prebuild_sandbox
+      @prebuild_sandbox ||= Pod::PrebuildSandbox.from_standard_sandbox(self)
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/helper/target_checker.rb

@@ -0,0 +1,42 @@
+module Pod
+  class Prebuild
+    # Check the targets, for the current limitation of the plugin
+    #
+    # @param [Array<PodTarget>] prebuilt_targets
+    def self.check_one_pod_should_have_only_one_target(prebuilt_targets)
+      targets_have_different_platforms = prebuilt_targets.reject { |t| t.pod_name == t.name }
+      return unless targets_have_different_platforms.empty?
+
+      names = targets_have_different_platforms.map(&:pod_name)
+      raw_names = targets_have_different_platforms.map(&:name)
+      message = "Oops, you came across a limitation of cocoapods-binary.
+
+The plugin requires that one pod should have ONLY ONE target in the 'Pod.xcodeproj'. There are mainly 2 situations \
+causing this problem:
+
+1. One pod integrates in 2 or more different platforms' targets. e.g.
+    ```
+    target 'iphoneApp' do
+      pod 'A', :binary => true
+    end
+    target 'watchApp' do
+      pod 'A'
+    end
+    ```
+
+2. Use different subspecs in multiple targets. e.g.
+    ```
+    target 'iphoneApp' do
+      pod 'A/core'
+      pod 'A/network'
+    end
+    target 'iphoneAppTest' do
+      pod 'A/core'
+    end
+    ```
+
+Related pods: #{names}, target names: #{raw_names}"
+      raise Informative, message
+    end
+  end
+end