cocoapods-binary-cache 0.1.1

data/lib/cocoapods-binary-cache/gem_version.rb

@@ -0,0 +1,6 @@
+# Copyright 2019 Grabtaxi Holdings PTE LTE (GRAB), All rights reserved.
+# Use of this source code is governed by an MIT-style license that can be found in the LICENSE file
+
+module CocoapodsBinaryCache
+  VERSION = "0.1.1".freeze
+end

data/lib/cocoapods-binary-cache/helper/benchmark_show.rb

@@ -0,0 +1,11 @@
+# Copyright 2019 Grabtaxi Holdings PTE LTE (GRAB), All rights reserved.
+# Use of this source code is governed by an MIT-style license that can be found in the LICENSE file
+
+require "benchmark"
+
+class BenchmarkShow
+  def self.benchmark
+    time = Benchmark.measure { yield }
+    Pod::UI.puts "🕛 Time elapsed: #{time}"
+  end
+end

data/lib/cocoapods-binary-cache/helper/checksum.rb

@@ -0,0 +1,12 @@
+# Copyright 2019 Grabtaxi Holdings PTE LTE (GRAB), All rights reserved.
+# Use of this source code is governed by an MIT-style license that can be found in the LICENSE file
+
+require "digest/md5"
+
+class FolderChecksum
+  def self.checksum(dir)
+    files = Dir["#{dir}/**/*"].reject { |f| File.directory?(f) }
+    content = files.map { |f| File.read(f) }.join
+    Digest::MD5.hexdigest(content).to_s
+  end
+end

data/lib/cocoapods-binary-cache/helper/json.rb

@@ -0,0 +1,37 @@
+require "json"
+
+module PodPrebuild
+  class JSONFile
+    attr_reader :path
+    attr_reader :data
+
+    def initialize(path)
+      @path = path
+      @data = load_json
+    end
+
+    def empty?
+      @data.empty?
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def save!
+      File.open(@path, "w") { |f| f.write(JSON.pretty_generate(@data)) }
+    end
+
+    private
+
+    def load_json
+      File.open(@path) { |f| JSON.parse(f.read) }
+    rescue
+      {}
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+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_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 ||= external_sources.select { |_, attributes| attributes.key?(:path) }.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_pods
+      pods.keys
+        .select { |k| k.include?("/") }
+        .group_by { |k| k.split("/")[0] }
+    end
+
+    private
+
+    # 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-cache/helper/path_utils.rb

@@ -0,0 +1,8 @@
+# Copyright 2019 Grabtaxi Holdings PTE LTE (GRAB), 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-cache/helper/podspec.rb

@@ -0,0 +1,17 @@
+module Pod
+  class Specification
+    def empty_source_files?
+      return subspecs.all?(&:empty_source_files?) unless subspecs.empty?
+
+      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-cache/hooks/post_install.rb

@@ -0,0 +1,16 @@
+module PodPrebuild
+  class PostInstallHook
+    def initialize(installer_context)
+      @installer_context = installer_context
+    end
+
+    def run
+      return unless Pod::Podfile::DSL.dev_pods_enabled && @installer_context.sandbox.instance_of?(Pod::PrebuildSandbox)
+
+      # Modify pods scheme to support code coverage
+      # If we don't prebuild dev pod -> no need to care about this in Pod project
+      # because we setup in the main project (ex. DriverCI scheme)
+      SchemeEditor.edit_to_support_code_coverage(@installer_context.sandbox) if Pod.is_prebuild_stage
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module PodPrebuild
+  class PreInstallHook
+    include ObjectSpace
+
+    attr_reader :installer_context, :podfile, :prebuild_sandbox, :cache_validation
+
+    def initialize(installer_context)
+      @installer_context = installer_context
+      @podfile = installer_context.podfile
+      @pod_install_options = {}
+      @prebuild_sandbox = nil
+      @cache_validation = nil
+    end
+
+    def run
+      require_relative "../pod-binary/helper/feature_switches"
+      return if Pod.is_prebuild_stage
+
+      log_section "🚀  Prebuild frameworks"
+      ensure_valid_podfile
+      save_installation_states
+      prepare_environment
+      create_prebuild_sandbox
+      Pod::UI.section("Detect implicit dependencies") { detect_implicit_dependencies }
+      Pod::UI.section("Validate prebuilt cache") { validate_cache }
+      prebuild! if Pod::Podfile::DSL.prebuild_job?
+      reset_environment
+      log_section "🤖  Resume pod installation"
+      require_relative "../pod-binary/integration"
+    end
+
+    private
+
+    def save_installation_states
+      save_pod_install_options
+      save_states_from_dsl
+    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-cache requires `use_frameworks!`" unless target_definition.uses_frameworks?
+      end
+    end
+
+    def prepare_environment
+      Pod::UI.puts "Prepare environment"
+      Pod.is_prebuild_stage = true
+      Pod::Podfile::DSL.enable_prebuild_patch true  # enable sikpping for prebuild targets
+      Pod::Installer.force_disable_integration true # don't integrate targets
+      Pod::Config.force_disable_write_lockfile true # disbale write lock file for perbuild podfile
+      Pod::Installer.disable_install_complete_message true # disable install complete message
+    end
+
+    def reset_environment
+      Pod::UI.puts "Reset environment"
+      Pod.is_prebuild_stage = false
+      Pod::Installer.force_disable_integration false
+      Pod::Podfile::DSL.enable_prebuild_patch false
+      Pod::Config.force_disable_write_lockfile false
+      Pod::Installer.disable_install_complete_message false
+      Pod::UserInterface.warnings = [] # clean the warning in the prebuild step, it's duplicated.
+    end
+
+    def save_states_from_dsl
+      # Note: DSL is reloaded when creating an installer (Pod::Installer.new).
+      # Any mutation to DSL is highly discouraged
+      # --> Rather, perform mutation on PodPrebuild::StateStore instead
+      PodPrebuild::StateStore.excluded_pods += Pod::Podfile::DSL.excluded_pods
+    end
+
+    def create_prebuild_sandbox
+      standard_sandbox = installer_context.sandbox
+      @prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sandbox)
+      Pod::UI.puts "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::StateStore.excluded_pods += pods_with_empty_source_files
+      Pod::UI.puts "Exclude pods with empty source files: #{pods_with_empty_source_files.to_a}"
+
+      # TODO (thuyen): Detect dependencies of a prebuilt pod and treat them as prebuilt pods as well
+    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: Pod::Podfile::DSL.validate_prebuilt_settings,
+        generated_framework_path: prebuild_sandbox.generate_framework_path,
+        sandbox_root: prebuild_sandbox.root,
+        ignored_pods: PodPrebuild::StateStore.excluded_pods,
+        prebuilt_pod_names: @original_installer.prebuilt_pod_names
+      ).validate
+      path_to_save_cache_validation = Pod::Podfile::DSL.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::StateStore.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 log_section(message)
+      Pod::UI.puts "-----------------------------------------"
+      Pod::UI.puts message
+      Pod::UI.puts "-----------------------------------------"
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# Copyright 2019 Grabtaxi Holdings PTE LTE (GRAB), 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 "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_cache"
+require_relative "prebuild_output/metadata"
+require_relative "prebuild_output/output"
+require_relative "scheme_editor"

data/lib/cocoapods-binary-cache/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-cache/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)
+    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 Podfile::DSL.dev_pods_enabled?
+        all
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Pod
+  class Podfile
+    class TargetDefinition
+      def detect_prebuilt_pod(name, requirements)
+        @explicit_prebuilt_pod_names ||= []
+        options = requirements.last
+        if Pod::Podfile::DSL.prebuild_all?
+          @explicit_prebuilt_pod_names << Specification.root_name(name)
+        elsif options.is_a?(Hash) && options[:binary]
+          @explicit_prebuilt_pod_names << Specification.root_name(name)
+        end
+        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`.
+      # In case `prebuild_all` is ON via `config_cocoapods_binary_cache`, returns the
+      # name of all pod targets
+      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-cache/pod-binary/helper/feature_switches.rb

@@ -0,0 +1,90 @@
+require_relative "../tool/tool"
+require_relative "prebuild_sandbox"
+
+module Pod
+
+  # a flag that indicate stages
+  class_attr_accessor :is_prebuild_stage
+
+  # a switch for the `pod` DSL to make it only valid for ':binary => true'
+  class Podfile
+    module DSL
+      @@enable_prebuild_patch = false
+
+      # when enable, `pod` function will skip all pods without 'prebuild => true'
+      def self.enable_prebuild_patch(value)
+        @@enable_prebuild_patch = value
+      end
+
+      # --- patch ---
+      old_method = instance_method(:pod)
+
+      define_method(:pod) do |name, *args|
+        if !@@enable_prebuild_patch
+          old_method.bind(self).(name, *args)
+          return
+        end
+
+        # patched content
+        should_prebuild = Pod::Podfile::DSL.prebuild_all
+        local = false
+
+        options = args.last
+        if options.is_a?(Hash) and options[Pod::Prebuild.keyword] != nil
+          should_prebuild = options[Pod::Prebuild.keyword]
+          local = (options[:path] != nil)
+        end
+
+        old_method.bind(self).call(name, *args) if should_prebuild && (!local || Podfile::DSL.dev_pods_enabled)
+      end
+    end
+  end
+
+  # a force disable option for integral
+  class Installer
+    def self.force_disable_integration(value)
+      @@force_disable_integration = value
+    end
+
+    old_method = instance_method(:integrate_user_project)
+    define_method(:integrate_user_project) do
+      if @@force_disable_integration
+        return
+      end
+      old_method.bind(self).()
+    end
+  end
+
+  # a option to disable install complete message
+  class Installer
+    def self.disable_install_complete_message(value)
+      @@disable_install_complete_message = value
+    end
+
+    old_method = instance_method(:print_post_install_message)
+    define_method(:print_post_install_message) do
+      if @@disable_install_complete_message
+        return
+      end
+      old_method.bind(self).()
+    end
+  end
+
+  # option to disable write lockfiles
+  class Config
+    @@force_disable_write_lockfile = false
+    def self.force_disable_write_lockfile(value)
+      @@force_disable_write_lockfile = value
+    end
+
+    old_method = instance_method(:lockfile_path)
+    define_method(:lockfile_path) do
+      if @@force_disable_write_lockfile
+        # As config is a singleton, sandbox_root refer to the standard sandbox.
+        return PrebuildSandbox.from_standard_sanbox_path(sandbox_root).root + "Manifest.lock.tmp"
+      else
+        return old_method.bind(self).()
+      end
+    end
+  end
+end