cocoapods 1.5.3 → 1.6.0.beta.1

data/lib/cocoapods/generator/copy_resources_script.rb

@@ -38,6 +38,12 @@ module Pod
         File.chmod(0755, pathname.to_s)
       end
 
+      # @return [String] The contents of the copy resources script.
+      #
+      def generate
+        script
+      end
+
       private
 
       # @!group Private Helpers

data/lib/cocoapods/generator/dummy_source.rb

@@ -8,13 +8,22 @@ module Pod
         @class_name = "PodsDummy_#{validated_class_name_identifier}"
       end
 
+      # @return [String] the string contents of the dummy source file.
+      #
+      def generate
+        result = <<-source.strip_heredoc
+          #import <Foundation/Foundation.h>
+          @interface #{class_name} : NSObject
+          @end
+          @implementation #{class_name}
+          @end
+        source
+        result
+      end
+
       def save_as(pathname)
         pathname.open('w') do |source|
-          source.puts '#import <Foundation/Foundation.h>'
-          source.puts "@interface #{class_name} : NSObject"
-          source.puts '@end'
-          source.puts "@implementation #{class_name}"
-          source.puts '@end'
+          source.write(generate)
         end
       end
     end

data/lib/cocoapods/generator/embed_frameworks_script.rb

@@ -27,6 +27,12 @@ module Pod
         File.chmod(0755, pathname.to_s)
       end
 
+      # @return [String] The contents of the embed frameworks script.
+      #
+      def generate
+        script
+      end
+
       private
 
       # @!group Private Helpers
@@ -84,8 +90,13 @@ module Pod
             local basename
             basename="$(basename -s .framework "$1")"
             binary="${destination}/${basename}.framework/${basename}"
+
             if ! [ -r "$binary" ]; then
               binary="${destination}/${basename}"
+            elif [ -L "${binary}" ]; then
+              echo "Destination binary is symlinked..."
+              dirname="$(dirname "${binary}")"
+              binary="${dirname}/$(readlink "${binary}")"
             fi
 
             # Strip invalid architectures so "fat" simulator / device frameworks work on device
@@ -138,8 +149,8 @@ module Pod
 
           # Signs a framework with the provided identity
           code_sign_if_enabled() {
-            if [ -n "${EXPANDED_CODE_SIGN_IDENTITY}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
-              # Use the current code_sign_identitiy
+            if [ -n "${EXPANDED_CODE_SIGN_IDENTITY:-}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
+              # Use the current code_sign_identity
               echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
               local code_sign_cmd="/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS:-} --preserve-metadata=identifier,entitlements '$1'"
 

data/lib/cocoapods/generator/header.rb

@@ -17,7 +17,7 @@ module Pod
 
       # @return [Array<String>] The list of the modules to import.
       #
-      attr_accessor :module_imports
+      attr_reader :module_imports
 
       # Initialize a new instance
       #

data/lib/cocoapods/generator/info_plist_file.rb

@@ -18,16 +18,22 @@ module Pod
       #
       attr_reader :bundle_package_type
 
+      # @return [Hash] any additional entries to include in this Info.plist
+      #
+      attr_reader :additional_entries
+
       # Initialize a new instance
       #
-      # @param  [Version] version @see version
-      # @param  [Platform] platform @see platform
-      # @param  [Symbol] bundle_package_type @see bundle_package_type
+      # @param  [Version] version @see #version
+      # @param  [Platform] platform @see #platform
+      # @param  [Symbol] bundle_package_type @see #bundle_package_type
+      # @param  [Hash] additional_entries @see #additional_entries
       #
-      def initialize(version, platform, bundle_package_type = :fmwk)
+      def initialize(version, platform, bundle_package_type = :fmwk, additional_entries = {})
         @version = version
         @platform = platform
         @bundle_package_type = bundle_package_type
+        @additional_entries = additional_entries
       end
 
       # Generates and saves the Info.plist to the given path.
@@ -109,6 +115,8 @@ module Pod
         info['CFBundleVersion'] = '1' if bundle_package_type == :bndl
         info['NSPrincipalClass'] = 'NSApplication' if bundle_package_type == :appl && platform == :osx
 
+        info.merge!(additional_entries)
+
         info
       end
     end

data/lib/cocoapods/generator/prefix_header.rb

@@ -15,10 +15,10 @@ module Pod
       # Initialize a new instance
       #
       # @param  [Array<FileAccessor>] file_accessors
-      #         @see file_accessors
+      #         @see #file_accessors
       #
       # @param  [Platform] platform
-      #         @see platform
+      #         @see Header#platform
       #
       def initialize(file_accessors, platform)
         @file_accessors = file_accessors

data/lib/cocoapods/hooks_manager.rb

@@ -76,6 +76,20 @@ module Pod
         @registrations[hook_name] << Hook.new(hook_name, plugin_name, block)
       end
 
+      # Returns all the hooks to run for the given event name
+      # and set of whitelisted plugins
+      #
+      # @see #run
+      #
+      # @return [Array<Hook>] the hooks to run
+      #
+      def hooks_to_run(name, whitelisted_plugins = nil)
+        return [] unless registrations
+        hooks = registrations.fetch(name, [])
+        return hooks unless whitelisted_plugins
+        hooks.select { |hook| whitelisted_plugins.key?(hook.plugin_name) }
+      end
+
       # Runs all the registered blocks for the hook with the given name.
       #
       # @param  [Symbol] name
@@ -94,23 +108,20 @@ module Pod
         raise ArgumentError, 'Missing name' unless name
         raise ArgumentError, 'Missing options' unless context
 
-        if registrations
-          hooks = registrations[name]
-          if hooks
-            UI.message "- Running #{name.to_s.tr('_', ' ')} hooks" do
-              hooks.each do |hook|
-                next if whitelisted_plugins && !whitelisted_plugins.key?(hook.plugin_name)
-                UI.message "- #{hook.plugin_name} from " \
-                           "`#{hook.block.source_location.first}`" do
-                  block = hook.block
-                  if block.arity > 1
-                    user_options = whitelisted_plugins[hook.plugin_name]
-                    user_options = user_options.with_indifferent_access if user_options
-                    block.call(context, user_options)
-                  else
-                    block.call(context)
-                  end
-                end
+        hooks = hooks_to_run(name, whitelisted_plugins)
+        return if hooks.empty?
+
+        UI.message "- Running #{name.to_s.tr('_', ' ')} hooks" do
+          hooks.each do |hook|
+            UI.message "- #{hook.plugin_name} from " \
+                        "`#{hook.block.source_location.first}`" do
+              block = hook.block
+              if block.arity > 1
+                user_options = whitelisted_plugins[hook.plugin_name]
+                user_options = user_options.with_indifferent_access if user_options
+                block.call(context, user_options)
+              else
+                block.call(context)
               end
             end
           end

data/lib/cocoapods/installer.rb

@@ -61,13 +61,13 @@ module Pod
 
     # Initialize a new instance
     #
-    # @param  [Sandbox]  sandbox     @see sandbox
-    # @param  [Podfile]  podfile     @see podfile
-    # @param  [Lockfile] lockfile    @see lockfile
+    # @param  [Sandbox]  sandbox     @see #sandbox
+    # @param  [Podfile]  podfile     @see #podfile
+    # @param  [Lockfile] lockfile    @see #lockfile
     #
     def initialize(sandbox, podfile, lockfile = nil)
-      @sandbox  = sandbox
-      @podfile  = podfile
+      @sandbox  = sandbox || raise(ArgumentError, 'Missing required argument `sandbox`')
+      @podfile  = podfile || raise(ArgumentError, 'Missing required argument `podfile`')
       @lockfile = lockfile
 
       @use_default_plugins = true
@@ -97,6 +97,12 @@ module Pod
     attr_accessor :use_default_plugins
     alias_method :use_default_plugins?, :use_default_plugins
 
+    # @return [Boolean] Whether installation should verify that there are no
+    #                   Podfile or Lockfile changes. Defaults to false.
+    #
+    attr_accessor :deployment
+    alias_method :deployment?, :deployment
+
     # Installs the Pods.
     #
     # The installation process is mostly linear with a few minor complications
@@ -155,12 +161,17 @@ module Pod
         validate_build_configurations
         clean_sandbox
       end
+
+      UI.section 'Verifying no changes' do
+        verify_no_podfile_changes!
+        verify_no_lockfile_changes!
+      end if deployment?
+
       analyzer
     end
 
     def download_dependencies
       UI.section 'Downloading dependencies' do
-        create_file_accessors
         install_pod_sources
         run_podfile_pre_install_hooks
         clean_pod_sources
@@ -174,14 +185,14 @@ module Pod
     private
 
     def create_generator
-      Xcode::PodsProjectGenerator.new(aggregate_targets, sandbox, pod_targets, analysis_result, installation_options, config)
+      Xcode::PodsProjectGenerator.new(sandbox, aggregate_targets, pod_targets, analysis_result, installation_options, config)
     end
 
     # Generate the 'Pods/Pods.xcodeproj' project.
     #
     def generate_pods_project(generator = create_generator)
       UI.section 'Generating Pods project' do
-        generator.generate!
+        @target_installation_results = generator.generate!
         @pods_project = generator.project
         run_podfile_post_install_hooks
         generator.write
@@ -201,13 +212,14 @@ module Pod
     #
     attr_reader :analysis_result
 
-    # @return [Pod::Project] the `Pods/Pods.xcodeproj` project.
+    # @return [Array<Hash{String, TargetInstallationResult}>] the installation results produced by the pods project
+    #         generator
     #
-    attr_reader :pods_project
+    attr_reader :target_installation_results
 
-    # @return [Array<String>] The Pods that should be installed.
+    # @return [Pod::Project] the `Pods/Pods.xcodeproj` project.
     #
-    attr_reader :names_of_pods_to_install
+    attr_reader :pods_project
 
     # @return [Array<AggregateTarget>] The model representations of an
     #         aggregation of pod targets generated for a target definition
@@ -218,13 +230,9 @@ module Pod
     # @return [Array<PodTarget>] The model representations of pod targets
     #         generated as result of the analyzer.
     #
-    def pod_targets
-      aggregate_target_pod_targets = aggregate_targets.flat_map(&:pod_targets)
-      test_dependent_targets = aggregate_target_pod_targets.flat_map(&:test_dependent_targets)
-      (aggregate_target_pod_targets + test_dependent_targets).uniq
-    end
+    attr_reader :pod_targets
 
-    # @return [Array<Specification>] The specifications that where installed.
+    # @return [Array<Specification>] The specifications that were installed.
     #
     attr_accessor :installed_specs
 
@@ -239,15 +247,14 @@ module Pod
     # @return [void]
     #
     def analyze(analyzer = create_analyzer)
-      analyzer.update = update
       @analysis_result = analyzer.analyze
-      @aggregate_targets = analyzer.result.targets
+      @aggregate_targets = @analysis_result.targets
+      @pod_targets = @analysis_result.pod_targets
     end
 
     def create_analyzer(plugin_sources = nil)
-      Analyzer.new(sandbox, podfile, lockfile, plugin_sources).tap do |analyzer|
+      Analyzer.new(sandbox, podfile, lockfile, plugin_sources, has_dependencies?, update).tap do |analyzer|
         analyzer.installation_options = installation_options
-        analyzer.has_dependencies = has_dependencies?
       end
     end
 
@@ -302,11 +309,26 @@ module Pod
       end
     end
 
-    # @return [void] In this step we create the file accessors for the pod
-    #                targets.
+    # @raise [Informative] If there are any Podfile changes
     #
-    def create_file_accessors
-      sandbox.create_file_accessors(pod_targets)
+    def verify_no_podfile_changes!
+      return unless analysis_result.podfile_needs_install?
+
+      changed_state = analysis_result.podfile_state.to_s(:states => %i(added deleted changed))
+      raise Informative, "There were changes to the podfile in deployment mode:\n#{changed_state}"
+    end
+
+    # @raise [Informative] If there are any Lockfile changes
+    #
+    def verify_no_lockfile_changes!
+      new_lockfile = generate_lockfile
+      return if new_lockfile == lockfile
+
+      diff = Xcodeproj::Differ.hash_diff(lockfile.to_hash, new_lockfile.to_hash, :key_1 => 'Old Lockfile', :key_2 => 'New Lockfile')
+      pretty_diff = YAMLHelper.convert_hash(diff, Lockfile::HASH_KEY_ORDER, "\n\n")
+      pretty_diff.gsub!(':diff:', 'diff:'.yellow)
+
+      raise Informative, "There were changes to the lockfile in deployment mode:\n#{pretty_diff}"
     end
 
     # Downloads, installs the documentation and cleans the sources of the Pods
@@ -327,7 +349,7 @@ module Pod
             current_repo = analysis_result.specs_by_source.detect { |key, values| break key if values.map(&:name).include?(spec.name) }
             current_repo &&= current_repo.url || current_repo.name
             previous_spec_repo = sandbox.manifest.spec_repo(spec.name)
-            has_changed_repo = !previous_spec_repo.nil? && current_repo && (current_repo != previous_spec_repo)
+            has_changed_repo = !previous_spec_repo.nil? && current_repo && !current_repo.casecmp(previous_spec_repo).zero?
             title = "Installing #{spec.name} #{spec.version}"
             title << " (was #{previous_version} and source changed to `#{current_repo}` from `#{previous_spec_repo}`)" if has_changed_version && has_changed_repo
             title << " (was #{previous_version})" if has_changed_version && !has_changed_repo
@@ -355,7 +377,13 @@ module Pod
         end
       end
 
-      raise Informative, "Could not install '#{pod_name}' pod. There is no target that supports it." if specs_by_platform.empty?
+      if specs_by_platform.empty?
+        requiring_targets = pod_targets.select { |pt| pt.recursive_dependent_targets.any? { |dt| dt.pod_name == pod_name } }
+        message = "Could not install '#{pod_name}' pod"
+        message += ", dependended upon by #{requiring_targets.to_sentence}" unless requiring_targets.empty?
+        message += '. There is either no platform to build for, or no target to build.'
+        raise StandardError, message
+      end
 
       @pod_installers ||= []
       pod_installer = PodSourceInstaller.new(sandbox, specs_by_platform, :can_cache => installation_options.clean?)
@@ -429,11 +457,9 @@ module Pod
     # @return [void]
     #
     def perform_post_install_actions
-      unlock_pod_sources
       run_plugins_post_install_hooks
       warn_for_deprecations
       warn_for_installed_script_phases
-      lock_pod_sources
       print_post_install_message
     end
 
@@ -451,8 +477,21 @@ module Pod
     # Runs the registered callbacks for the plugins post install hooks.
     #
     def run_plugins_post_install_hooks
-      context = PostInstallHooksContext.generate(sandbox, aggregate_targets)
-      HooksManager.run(:post_install, context, plugins)
+      # This short-circuits because unlocking pod sources is expensive
+      if any_plugin_post_install_hooks?
+        unlock_pod_sources
+
+        context = PostInstallHooksContext.generate(sandbox, aggregate_targets)
+        HooksManager.run(:post_install, context, plugins)
+      end
+
+      lock_pod_sources
+    end
+
+    # @return [Boolean] whether there are any plugin post-install hooks to run
+    #
+    def any_plugin_post_install_hooks?
+      HooksManager.hooks_to_run(:post_install, plugins).any?
     end
 
     # Runs the registered callbacks for the source provider plugin hooks.
@@ -550,16 +589,20 @@ module Pod
       end
     end
 
-    # Writes the Podfile and the lock files.
+    # @return [Lockfile] The lockfile to write to disk.
     #
-    # @todo   Pass the checkout options to the Lockfile.
+    def generate_lockfile
+      external_source_pods = analysis_result.podfile_dependency_cache.podfile_dependencies.select(&:external_source).map(&:root_name).uniq
+      checkout_options = sandbox.checkout_sources.select { |root_name, _| external_source_pods.include? root_name }
+      Lockfile.generate(podfile, analysis_result.specifications, checkout_options, analysis_result.specs_by_source)
+    end
+
+    # Writes the Podfile and the lock files.
     #
     # @return [void]
     #
     def write_lockfiles
-      external_source_pods = analysis_result.podfile_dependency_cache.podfile_dependencies.select(&:external_source).map(&:root_name).uniq
-      checkout_options = sandbox.checkout_sources.select { |root_name, _| external_source_pods.include? root_name }
-      @lockfile = Lockfile.generate(podfile, analysis_result.specifications, checkout_options, analysis_result.specs_by_source)
+      @lockfile = generate_lockfile
 
       UI.message "- Writing Lockfile in #{UI.path config.lockfile_path}" do
         @lockfile.write_to_disk(config.lockfile_path)
@@ -579,11 +622,6 @@ module Pod
     #
     # @return [void]
     #
-    # @todo   [#397] The libraries should be cleaned and the re-added on every
-    #         installation. Maybe a clean_user_project phase should be added.
-    #         In any case it appears to be a good idea store target definition
-    #         information in the lockfile.
-    #
     def integrate_user_project
       UI.section "Integrating client #{'project'.pluralize(aggregate_targets.map(&:user_project_path).uniq.count)}" do
         installation_root = config.installation_root
@@ -684,5 +722,28 @@ module Pod
     end
 
     #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Convenience Methods
+
+    def self.targets_from_sandbox(sandbox, podfile, lockfile)
+      raise Informative, 'You must run `pod install` to be able to generate target information' unless lockfile
+
+      new(sandbox, podfile, lockfile).instance_exec do
+        plugin_sources = run_source_provider_hooks
+        analyzer = create_analyzer(plugin_sources)
+        analyze(analyzer)
+        if analysis_result.podfile_needs_install?
+          raise Pod::Informative, 'The Podfile has changed, you must run `pod install`'
+        elsif analysis_result.sandbox_needs_install?
+          raise Pod::Informative, 'The `Pods` directory is out-of-date, you must run `pod install`'
+        end
+
+        aggregate_targets
+      end
+    end
+
+    #-------------------------------------------------------------------------#
   end
 end