cocoapods-binary-cache 0.1.1

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

@@ -0,0 +1,36 @@
+# 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
+    pod_name_to_targets_hash = nil
+    if cache.empty?
+      pod_name_to_targets_hash = targets.reduce({}) do |sum, target|
+        array = sum[target.pod_name] || []
+        array << target
+        sum[target.pod_name] = array
+        sum
+      end
+      cache << pod_name_to_targets_hash
+    else
+      pod_name_to_targets_hash = cache.first
+    end
+
+    pod_name_to_targets_hash[pod_name] || []
+  end
+end

data/lib/cocoapods-binary-cache/pod-binary/helper/passer.rb

@@ -0,0 +1,25 @@
+require_relative "../tool/tool"
+
+module Pod
+  class Prebuild
+    # Pass the data between the 2 steps
+    #
+    # At step 2, the normal pod install, it needs some info of the
+    # prebuilt step. So we store it here.
+    #
+    class Passer
+      # indicate the add/remove/update of prebuit pods
+      # @return [Analyzer::SpecsState]
+      #
+      class_attr_accessor :prebuild_pods_changes
+
+      # Some pod won't be build in prebuild stage even if it have `binary=>true`.
+      # The targets of this pods have `oshould_build? == true`.
+      # We should skip integration (patch spec) for this pods
+      #
+      # @return [Array<String>]
+      class_attr_accessor :target_names_to_skip_integration_framework
+      self.target_names_to_skip_integration_framework = []
+    end
+  end
+end

data/lib/cocoapods-binary-cache/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-cache/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_sanbox_path(path)
+      prebuild_sandbox_path = Pathname.new(path).realpath + "_Prebuild"
+      self.new(prebuild_sandbox_path)
+    end
+
+    def self.from_standard_sandbox(sandbox)
+      self.from_standard_sanbox_path(sandbox.root)
+    end
+
+    def standard_sanbox_path
+      self.root.parent
+    end
+
+    def generate_framework_path
+      self.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)
+      self.generate_framework_path + name
+    end
+
+    def exsited_framework_target_names
+      exsited_framework_name_pairs.map { |pair| pair[0] }.uniq
+    end
+
+    def exsited_framework_pod_names
+      exsited_framework_name_pairs.map { |pair| pair[1] }.uniq
+    end
+
+    def existed_target_names_for_pod_name(pod_name)
+      exsited_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
+    end
+
+    # Array<[target_name, pod_name]>
+    def exsited_framework_name_pairs
+      return [] unless generate_framework_path.exist?
+      generate_framework_path.children().map do |framework_path|
+        if framework_path.directory? && (not framework_path.children.empty?)
+          [framework_path.basename.to_s, pod_name_for_target_folder(framework_path)]
+        else
+          nil
+        end
+      end.reject(&:nil?).uniq
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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.select { |t| t.pod_name != t.name }
+
+      if targets_have_different_platforms.count > 0
+        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
+end

data/lib/cocoapods-binary-cache/pod-binary/integration.rb

@@ -0,0 +1,12 @@
+require_relative "helper/podfile_options"
+require_relative "helper/prebuild_sandbox"
+require_relative "helper/passer"
+require_relative "helper/names"
+require_relative "helper/target_checker"
+require_relative "integration/alter_specs"
+require_relative "integration/remove_target_files"
+require_relative "integration/source_installer"
+require_relative "integration/validation"
+require_relative "integration/patch/embed_framework_script"
+require_relative "integration/patch/resolve_dependencies"
+require_relative "integration/patch/source_installation"

data/lib/cocoapods-binary-cache/pod-binary/integration/alter_specs.rb

@@ -0,0 +1,93 @@
+module Pod
+  class Installer
+    def alter_specs_for_prebuilt_pods
+      cache = []
+      analysis_result.specifications
+        .select { |spec| should_integrate_prebuilt_pod?(spec.root.name) }
+        .each { |spec| alter_spec(spec, cache) }
+    end
+
+    def alter_spec(spec, cache)
+      targets = Pod.fast_get_targets_for_pod_name(spec.root.name, pod_targets, cache)
+      targets.each do |target|
+        # Use the prebuild framworks as vendered frameworks.
+        # The framework_file_path rule is decided in `install_for_prebuild`,
+        # as to compitable with older version and be less wordy.
+        framework_file_path = target.framework_name
+        framework_file_path = target.name + "/" + framework_file_path if targets.count > 1
+        add_vendered_framework(spec, target.platform.name.to_s, framework_file_path)
+      end
+
+      platforms = targets.map { |target| target.platform.name.to_s }.uniq
+      empty_source_files(spec, platforms)
+      tweak_resources_for_xib(spec, platforms)
+      tweak_resources_for_resource_bundles(spec, platforms)
+      empty_liscence(spec) # to avoid the warning of missing license
+    end
+
+    def tweak_resources_for_xib(spec, platforms)
+      # This is a workaround for prebuilt static framework that has `*.xib` files in the resources
+      # (declared by `spec.resources = ...`)
+      # ---------------------------------------------------------------
+      # In the prebuild stage, a XIB file is compiled as a NIB file in the framework.
+      # In the integration stage, this file is added to the script `Pods-<Target>-resources.sh`:
+      #   - If it's a XIB, it's installed to the target bundle by `ibtool`
+      #   - If it's a NIB, it's copied directly to the target bundle
+      # Since the one embedded in the prebuilt framework is a NIB (already compiled)
+      # --> We need to alter the spec so that this file will be copied to the target bundle
+      change_xib_to_nib = ->(path) { path.sub(".xib", ".nib") }
+      update_resources = lambda do |resources|
+        if resources.is_a?(String)
+          change_xib_to_nib.call(resources)
+        elsif resources.is_a?(Array)
+          resources.map { |item| change_xib_to_nib.call(item) }
+        end
+      end
+      spec.attributes_hash["resources"] = update_resources.call(spec.attributes_hash["resources"])
+      platforms.each do |platform|
+        next if spec.attributes_hash[platform].nil?
+
+        platform_resources = spec.attributes_hash[platform]["resources"]
+        spec.attributes_hash[platform]["resources"] = update_resources.call(platform_resources)
+      end
+    end
+
+    def tweak_resources_for_resource_bundles(spec, platforms)
+      add_resource_bundles_to_resources = lambda do |attributes|
+        return if attributes.nil?
+
+        resource_bundles = attributes["resource_bundles"] || {}
+        resource_bundle_names = resource_bundles.keys
+        attributes["resource_bundles"] = nil
+        attributes["resources"] ||= []
+        attributes["resources"] = [attributes["resources"]] if attributes["resources"].is_a?(String)
+        attributes["resources"] += resource_bundle_names.map { |n| n + ".bundle" }
+      end
+
+      add_resource_bundles_to_resources.call(spec.attributes_hash)
+      platforms.each do |platform|
+        add_resource_bundles_to_resources.call(spec.attributes_hash[platform])
+      end
+    end
+
+    def add_vendered_framework(spec, platform, added_framework_file_path)
+      spec.attributes_hash[platform] = {} if spec.attributes_hash[platform].nil?
+      vendored_frameworks = spec.attributes_hash[platform]["vendored_frameworks"] || []
+      vendored_frameworks = [vendored_frameworks] if vendored_frameworks.is_a?(String)
+      vendored_frameworks += [added_framework_file_path]
+      spec.attributes_hash[platform]["vendored_frameworks"] = vendored_frameworks
+    end
+
+    def empty_source_files(spec, platforms)
+      spec.attributes_hash["source_files"] = []
+      platforms.each do |platform|
+        spec.attributes_hash[platform]["source_files"] = [] unless spec.attributes_hash[platform].nil?
+      end
+    end
+
+    def empty_liscence(spec)
+      spec.attributes_hash["license"] = {}
+      spec.root.attributes_hash["license"] = {}
+    end
+  end
+end

data/lib/cocoapods-binary-cache/pod-binary/integration/patch/embed_framework_script.rb

@@ -0,0 +1,36 @@
+# A fix in embeded frameworks script.
+#
+# The framework file in pod target folder is a symblink. The EmbedFrameworksScript use `readlink`
+# to read the read path. As the symlink is a relative symlink, readlink cannot handle it well. So
+# we override the `readlink` to a fixed version.
+#
+module Pod
+  module Generator
+    class EmbedFrameworksScript
+      old_method = instance_method(:script)
+      define_method(:script) do
+        script = old_method.bind(self).()
+        patch = <<-SH.strip_heredoc
+          #!/bin/sh
+          # ---- this is added by cocoapods-binary ---
+          # Readlink cannot handle relative symlink well, so we override it to a new one
+          # If the path isn't an absolute path, we add a realtive prefix.
+          old_read_link=`which readlink`
+          readlink () {
+            path=`$old_read_link $1`;
+            if [ $(echo "$path" | cut -c 1-1) = '/' ]; then
+              echo $path;
+            else
+              echo "`dirname $1`/$path";
+            fi
+          }
+          # ---
+        SH
+
+        # patch the rsync for copy dSYM symlink
+        script = script.gsub "rsync --delete", "rsync --copy-links --delete"
+        patch + script
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-cache/pod-binary/integration/patch/resolve_dependencies.rb

@@ -0,0 +1,23 @@
+# Let cocoapods use the prebuild framework files in install process.
+#
+# the code only effect the second pod install process.
+#
+module Pod
+  class Installer
+    # Modify specification to use only the prebuild framework after analyzing
+    original_resolve_dependencies = instance_method(:resolve_dependencies)
+    define_method(:resolve_dependencies) do
+      # Remove the old target files. Otherwise, it will not notice file changes.
+      # This call is to make sure subsequent pod installations function properly
+      remove_target_files_if_needed
+      original_resolve_dependencies.bind(self).call
+
+      # check the pods
+      # Although we have did it in prebuild stage, it's not sufficient.
+      # Same pod may appear in another target in form of source code.
+      # Prebuild.check_one_pod_should_have_only_one_target(prebuilt_pod_targets)
+      validate_every_pod_only_have_one_form
+      alter_specs_for_prebuilt_pods
+    end
+  end
+end

data/lib/cocoapods-binary-cache/pod-binary/integration/patch/source_installation.rb

@@ -0,0 +1,28 @@
+module Pod
+  class Installer
+    # Override the download step to skip download and prepare file in target folder
+    define_method(:install_source_of_pod) do |pod_name|
+      pod_installer = create_pod_installer(pod_name)
+      # Injected code
+      # ------------------------------------------
+      if should_integrate_prebuilt_pod?(pod_name)
+        pod_installer.install_for_prebuild!(sandbox)
+      else
+        pod_installer.install!
+      end
+      # ------------------------------------------
+      @installed_specs.concat(pod_installer.specs_by_platform.values.flatten.uniq)
+    end
+
+    def should_integrate_prebuilt_pod?(name)
+      if Pod::Podfile::DSL.prebuild_job?
+        # In a prebuild job, at the integration stage, all prebuilt frameworks should be
+        # ready for integration regardless of whether there was any cache miss or not.
+        # Those that are missed were prebuilt in the prebuild stage.
+        PodPrebuild::StateStore.cache_validation.include?(name)
+      else
+        PodPrebuild::StateStore.cache_validation.hit?(name)
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-cache/pod-binary/integration/remove_target_files.rb

@@ -0,0 +1,29 @@
+module Pod
+  class Installer
+    # Remove the old target files if prebuild frameworks changed
+    def remove_target_files_if_needed
+      changes = Pod::Prebuild::Passer.prebuild_pods_changes
+      updated_names = []
+      if changes.nil?
+        updated_names = PrebuildSandbox.from_standard_sandbox(sandbox).exsited_framework_pod_names
+      else
+        added = changes.added
+        changed = changes.changed
+        deleted = changes.deleted
+        updated_names = added + changed + deleted
+      end
+
+      updated_names.each do |name|
+        root_name = Specification.root_name(name)
+        next if !Pod::Podfile::DSL.dev_pods_enabled && sandbox.local?(root_name)
+
+        UI.puts "Delete cached files: #{root_name}"
+        target_path = sandbox.pod_dir(root_name)
+        target_path.rmtree if target_path.exist?
+
+        support_path = sandbox.target_support_files_dir(root_name)
+        support_path.rmtree if support_path.exist?
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-cache/pod-binary/integration/source_installer.rb

@@ -0,0 +1,111 @@
+# NOTE:
+# This file will only be loaded on normal pod install step
+# so there's no need to check is_prebuild_stage
+
+# Provide a special "download" process for prebuilded pods.
+#
+# As the frameworks is already exsited in local folder. We
+# just create a symlink to the original target folder.
+#
+module Pod
+  class Installer
+    class PodSourceInstaller
+      def install_for_prebuild!(standard_sanbox)
+        return if !Podfile::DSL.dev_pods_enabled && standard_sanbox.local?(name)
+
+        # make a symlink to target folder
+        prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sanbox)
+        # if spec used in multiple platforms, it may return multiple paths
+        target_names = prebuild_sandbox.existed_target_names_for_pod_name(self.name)
+
+        def walk(path, &action)
+          return unless path.exist?
+          path.children.each do |child|
+            result = action.call(child, &action)
+            if child.directory?
+              walk(child, &action) if result
+            end
+          end
+        end
+
+        def make_link(source, target)
+          source = Pathname.new(source)
+          target = Pathname.new(target)
+          target.parent.mkpath unless target.parent.exist?
+          relative_source = source.relative_path_from(target.parent)
+          FileUtils.ln_sf(relative_source, target)
+        end
+
+        def mirror_with_symlink(source, basefolder, target_folder)
+          target = target_folder + source.relative_path_from(basefolder)
+          make_link(source, target)
+        end
+
+        target_names.each do |name|
+
+          # symbol link copy all substructure
+          real_file_folder = prebuild_sandbox.framework_folder_path_for_target_name(name)
+
+          # If have only one platform, just place int the root folder of this pod.
+          # If have multiple paths, we use a sperated folder to store different
+          # platform frameworks. e.g. AFNetworking/AFNetworking-iOS/AFNetworking.framework
+
+          target_folder = standard_sanbox.pod_dir(self.name)
+          if target_names.count > 1
+            target_folder += real_file_folder.basename
+          end
+
+          if !standard_sanbox.local?(name)
+            target_folder.rmtree if target_folder.exist?
+            target_folder.mkpath
+          else
+            system "find #{target_folder} -type l -delete" # Only clean up symlink, keep source code for local pod
+          end
+
+          walk(real_file_folder) do |child|
+            source = child
+            # only make symlink to file and `.framework` folder
+            if child.directory? and [".framework", ".dSYM"].include? child.extname
+              if child.extname == ".framework"
+                mirror_with_symlink(source, real_file_folder, target_folder)
+              else
+                # Ignore dsym here to avoid cocoapods from adding install_dsym to buildphase-script
+                # That can cause duplicated output files error in Xcode 11 (warning in Xcode 10)
+                # We need more setup to support local debuging with prebuilt dSYM
+              end
+              next false  # return false means don't go deeper
+            elsif child.file?
+              mirror_with_symlink(source, real_file_folder, target_folder)
+              next true
+            else
+              next true
+            end
+          end
+
+          # symbol link copy resource for static framework
+          metadata = PodPrebuild::Metadata.in_dir(real_file_folder)
+          next unless metadata.static_framework?
+
+          metadata.resources.each do |path|
+            target_file_path = path.sub("${PODS_ROOT}", sandbox.root.to_path)
+                                   .sub("${PODS_CONFIGURATION_BUILD_DIR}", sandbox.root.to_path)
+            real_file_path = real_file_folder + metadata.framework_name + File.basename(path)
+            case File.extname(path)
+            when ".xib"
+              # https://github.com/grab/cocoapods-binary-cache/issues/7
+              # When ".xib" files are compiled in a framework, it becomes ".nib" files
+              # --> We need to correct the path extension
+              real_file_path = real_file_path.sub_ext(".nib")
+              target_file_path = target_file_path.sub(".xib", ".nib")
+            when ".bundle"
+              next if metadata.resource_bundles.include?(File.basename(path))
+
+              real_file_path = real_file_folder + File.basename(path) unless real_file_path.exist?
+            end
+            make_link(real_file_path, target_file_path)
+          end
+        end
+      end
+    end
+  end
+end