cocoapods 0.35.0 → 0.36.0.beta.1

data/lib/cocoapods/installer.rb

@@ -89,6 +89,7 @@ module Pod
       prepare
       resolve_dependencies
       download_dependencies
+      determine_dependency_product_types
       generate_pods_project
       integrate_user_project if config.integrate_targets?
       perform_post_install_actions
@@ -97,6 +98,7 @@ module Pod
     def prepare
       UI.message 'Preparing' do
         sandbox.prepare
+        ensure_plugins_are_installed!
         Migrator.migrate(sandbox)
       end
     end
@@ -310,6 +312,21 @@ module Pod
       @pod_installers.each(&:clean!)
     end
 
+    # Determines if the dependencies need to be built as dynamic frameworks or
+    # if they can be built as static libraries by checking for the Swift source
+    # presence. Therefore it is important that the file accessors of the
+    # #pod_targets are created.
+    #
+    # @return [void]
+    #
+    def determine_dependency_product_types
+      aggregate_targets.each do |aggregate_target|
+        aggregate_target.pod_targets.each do |pod_target|
+          pod_target.host_requires_frameworks = aggregate_target.requires_frameworks?
+        end
+      end
+    end
+
     # Performs any post-installation actions
     #
     # @return [void]
@@ -323,7 +340,23 @@ module Pod
     #
     def run_plugins_post_install_hooks
       context = HooksContext.generate(sandbox, aggregate_targets)
-      HooksManager.run(:post_install, context)
+      HooksManager.run(:post_install, context, podfile.plugins)
+    end
+
+    # Ensures that all plugins specified in the {#podfile} are loaded.
+    #
+    # @return [void]
+    #
+    def ensure_plugins_are_installed!
+      require 'claide/command/plugin_manager'
+
+      loaded_plugins = Command::PluginManager.specifications.map(&:name)
+
+      podfile.plugins.keys.each do |plugin|
+        unless loaded_plugins.include? plugin
+          raise Informative, "Your Podfile requires that the plugin `#{plugin}` be installed. Please install it and try installation again."
+        end
+      end
     end
 
     # Prints a warning for any pods that are deprecated
@@ -418,16 +451,32 @@ module Pod
         pod_targets.sort_by(&:name).each do |pod_target|
           pod_target.file_accessors.each do |file_accessor|
             file_accessor.spec_consumer.frameworks.each do |framework|
-              pod_target.native_target.add_system_framework(framework)
+              if pod_target.should_build?
+                pod_target.native_target.add_system_framework(framework)
+              end
             end
           end
         end
       end
     end
 
+    # Adds a target dependency for each pod spec to each aggregate target and
+    # links the pod targets among each other.
+    #
+    # @return [void]
+    #
     def set_target_dependencies
+      frameworks_group = pods_project.frameworks_group
       aggregate_targets.each do |aggregate_target|
         aggregate_target.pod_targets.each do |pod_target|
+          unless pod_target.should_build?
+            pod_target.resource_bundle_targets.each do |resource_bundle_target|
+              aggregate_target.native_target.add_dependency(resource_bundle_target)
+            end
+
+            next
+          end
+
           aggregate_target.native_target.add_dependency(pod_target.native_target)
           pod_target.dependencies.each do |dep|
 
@@ -437,7 +486,15 @@ module Pod
               unless pod_dependency_target
                 puts "[BUG] DEP: #{dep}"
               end
+
+              next unless pod_dependency_target.should_build?
               pod_target.native_target.add_dependency(pod_dependency_target.native_target)
+
+              if pod_target.requires_frameworks?
+                product_ref = frameworks_group.files.find { |f| f.path == pod_dependency_target.product_name } ||
+                  frameworks_group.new_product_ref_for_target(pod_dependency_target.product_basename, pod_dependency_target.product_type)
+                pod_target.native_target.frameworks_build_phase.add_file_reference(product_ref)
+              end
             end
           end
         end

data/lib/cocoapods/installer/analyzer.rb

@@ -180,47 +180,92 @@ module Pod
       def generate_targets
         targets = []
         result.specs_by_target.each do |target_definition, specs|
-          target = AggregateTarget.new(target_definition, sandbox)
-          targets << target
-
-          if config.integrate_targets?
-            project_path = compute_user_project_path(target_definition)
-            user_project = Xcodeproj::Project.open(project_path)
-            native_targets = compute_user_project_targets(target_definition, user_project)
-
-            target.user_project_path = project_path
-            target.client_root = project_path.dirname
-            target.user_target_uuids = native_targets.map(&:uuid)
-            target.user_build_configurations = compute_user_build_configurations(target_definition, native_targets)
-            target.archs = @archs_by_target_def[target_definition]
-          else
-            target.client_root = config.installation_root
-            target.user_target_uuids = []
-            target.user_build_configurations = target_definition.build_configurations || {}
-            if target_definition.platform.name == :osx
-              target.archs = '$(ARCHS_STANDARD_64_BIT)'
-            end
+          targets << generate_target(target_definition, specs)
+        end
+        targets
+      end
+
+      # Setup the aggregate target for a single user target
+      #
+      # @param  [TargetDefinition] target_definition
+      #         the target definition for the user target.
+      #
+      # @param  [Array<Specification>] specs
+      #         the specifications that need to be installed grouped by the
+      #         given target definition.
+      #
+      # @return [AggregateTarget]
+      #
+      def generate_target(target_definition, specs)
+        target = AggregateTarget.new(target_definition, sandbox)
+        target.host_requires_frameworks |= target_definition.uses_frameworks?
+
+        if config.integrate_targets?
+          project_path = compute_user_project_path(target_definition)
+          user_project = Xcodeproj::Project.open(project_path)
+          native_targets = compute_user_project_targets(target_definition, user_project)
+
+          target.user_project_path = project_path
+          target.client_root = project_path.dirname
+          target.user_target_uuids = native_targets.map(&:uuid)
+          target.user_build_configurations = compute_user_build_configurations(target_definition, native_targets)
+          target.archs = @archs_by_target_def[target_definition]
+        else
+          target.client_root = config.installation_root
+          target.user_target_uuids = []
+          target.user_build_configurations = target_definition.build_configurations || { 'Release' => :release, 'Debug' => :debug }
+          if target_definition.platform.name == :osx
+            target.archs = '$(ARCHS_STANDARD_64_BIT)'
           end
+        end
 
-          grouped_specs = specs.map do |spec|
-            specs.select { |s| s.root == spec.root }
-          end.uniq
+        target.pod_targets = generate_pod_targets(target, specs)
 
-          grouped_specs.each do |pod_specs|
-            pod_target = PodTarget.new(pod_specs, target_definition, sandbox)
-            if config.integrate_targets?
-              pod_target.user_build_configurations = target.user_build_configurations
-              pod_target.archs = @archs_by_target_def[target_definition]
-            else
-              pod_target.user_build_configurations = {}
-              if target_definition.platform.name == :osx
-                pod_target.archs = '$(ARCHS_STANDARD_64_BIT)'
-              end
-            end
-            target.pod_targets << pod_target
+        target
+      end
+
+      # Setup the pod targets for an aggregate target. Group specs and subspecs
+      # by their root to create a {PodTarget} for each spec.
+      #
+      # @param  [AggregateTarget] target
+      #         the aggregate target
+      #
+      # @param  [Array<Specification>] specs
+      #         the specifications that need to be installed.
+      #
+      # @return [Array<PodTarget>]
+      #
+      def generate_pod_targets(target, specs)
+        grouped_specs = specs.group_by(&:root).values.uniq
+        grouped_specs.map do |pod_specs|
+          generate_pod_target(target, pod_specs)
+        end
+      end
+
+      # Create a target for each spec group and add it to the aggregate target
+      #
+      # @param  [AggregateTarget] target
+      #         the aggregate target
+      #
+      # @param  [Array<Specification>] specs
+      #         the specifications of an equal root.
+      #
+      # @return [PodTarget]
+      #
+      def generate_pod_target(target, pod_specs)
+        pod_target = PodTarget.new(pod_specs, target.target_definition, sandbox)
+
+        if config.integrate_targets?
+          pod_target.user_build_configurations = target.user_build_configurations
+          pod_target.archs = @archs_by_target_def[target.target_definition]
+        else
+          pod_target.user_build_configurations = {}
+          if target.platform.name == :osx
+            pod_target.archs = '$(ARCHS_STANDARD_64_BIT)'
           end
         end
-        targets
+
+        pod_target
       end
 
       # Generates dependencies that require the specific version of the Pods
@@ -331,6 +376,8 @@ module Pod
           pods_to_fetch = result.podfile_state.added + result.podfile_state.changed
           if update_mode == :selected
             pods_to_fetch += update[:pods]
+          elsif update_mode == :all
+            pods_to_fetch += result.podfile_state.unchanged + result.podfile_state.deleted
           end
           pods_to_fetch
         end
@@ -462,9 +509,8 @@ module Pod
             raise Informative, 'Unable to find the Xcode project ' \
               "`#{path}` for the target `#{target_definition.label}`."
           end
-
         else
-          xcodeprojs = Pathname.glob(config.installation_root + '*.xcodeproj')
+          xcodeprojs = config.installation_root.children.select { |e| e.fnmatch('*.xcodeproj') }
           if xcodeprojs.size == 1
             path = xcodeprojs.first
           else
@@ -514,6 +560,37 @@ module Pod
         end
       end
 
+      # Checks if any of the targets for the {TargetDefinition} computed before
+      # by #compute_user_project_targets require to be build as a framework due
+      # the presence of Swift source code in any of the source build phases.
+      #
+      # @param  [TargetDefinition] target_definition
+      #         the target definition
+      #
+      # @param  [Array<PBXNativeTarget>] native_targets
+      #         the targets which are checked for presence of Swift source code
+      #
+      # @return [Boolean] Whether the user project targets to integrate into
+      #         uses Swift
+      #
+      def compute_user_project_targets_require_framework(target_definition, native_targets)
+        file_predicate = nil
+        file_predicate = proc do |file_ref|
+          if file_ref.respond_to?(:last_known_file_type)
+            file_ref.last_known_file_type == 'sourcecode.swift'
+          elsif file_ref.respond_to?(:files)
+            file_ref.files.any?(&file_predicate)
+          else
+            false
+          end
+        end
+        target_definition.platform.supports_dynamic_frameworks? || native_targets.any? do |target|
+          target.source_build_phase.files.any? do |build_file|
+            file_predicate.call(build_file.file_ref)
+          end
+        end
+      end
+
       # @return [Hash{String=>Symbol}] A hash representing the user build
       #         configurations where each key corresponds to the name of a
       #         configuration and its value to its type (`:debug` or `:release`).

data/lib/cocoapods/installer/analyzer/locking_dependency_analyzer.rb

@@ -32,8 +32,13 @@ module Pod
               add_to_dependency_graph(pod, [], dependency_graph)
             end
 
+            pods_to_update = pods_to_update.flat_map do |u|
+              root_name = Specification.root_name(u)
+              dependency_graph.vertices.keys.select { |n| Specification.root_name(n) == root_name }
+            end
+
             pods_to_update.each do |u|
-              dependency_graph.detach_vertex_named(u) if dependency_graph.vertex_named(u)
+              dependency_graph.detach_vertex_named(u)
             end
           end
 

data/lib/cocoapods/installer/file_references_installer.rb

@@ -67,7 +67,7 @@ module Pod
       #
       def add_source_files_references
         UI.message '- Adding source files to Pods project' do
-          add_file_accessors_paths_to_pods_group(:source_files)
+          add_file_accessors_paths_to_pods_group(:source_files, nil, true)
         end
       end
 
@@ -100,8 +100,8 @@ module Pod
       #
       def add_resources
         UI.message '- Adding resources to Pods project' do
-          add_file_accessors_paths_to_pods_group(:resources, :resources)
-          add_file_accessors_paths_to_pods_group(:resource_bundle_files, :resources)
+          add_file_accessors_paths_to_pods_group(:resources, :resources, true)
+          add_file_accessors_paths_to_pods_group(:resource_bundle_files, :resources, true)
         end
       end
 
@@ -152,14 +152,20 @@ module Pod
       # @param  [Symbol] group_key
       #         The key of the group of the Pods project.
       #
+      # @param  [Bool] reflect_file_system_structure_for_development
+      #         Wether organizing the a local pod's files in subgroups inside
+      #         the pod's group is allowed.
+      #
       # @return [void]
       #
-      def add_file_accessors_paths_to_pods_group(file_accessor_key, group_key = nil)
+      def add_file_accessors_paths_to_pods_group(file_accessor_key, group_key = nil, reflect_file_system_structure_for_development = false)
         file_accessors.each do |file_accessor|
+          pod_name = file_accessor.spec.name
+          local = sandbox.local?(pod_name)
           paths = file_accessor.send(file_accessor_key)
           paths.each do |path|
             group = pods_project.group_for_spec(file_accessor.spec.name, group_key)
-            pods_project.add_file_reference(path, group)
+            pods_project.add_file_reference(path, group, local && reflect_file_system_structure_for_development)
           end
         end
       end

data/lib/cocoapods/installer/migrator.rb

@@ -13,6 +13,7 @@ module Pod
         def migrate(sandbox)
           if sandbox.manifest
             migrate_to_0_34(sandbox) if installation_minor?('0.34', sandbox)
+            migrate_to_0_36(sandbox) if installation_minor?('0.36', sandbox)
           end
         end
 
@@ -46,6 +47,14 @@ module Pod
           delete(Pathname(File.join(ENV['HOME'], 'Library/Caches/CocoaPods/Git')))
         end
 
+        # Migrates from CocoaPods versions prior to 0.36.
+        #
+        def migrate_to_0_36(sandbox)
+          UI.message('Migrating to CocoaPods 0.36') do
+            move(sandbox.root + 'Headers/Build', sandbox.root + 'Headers/Private')
+          end
+        end
+
         # @!group Private helpers
 
         def installation_minor?(target_version, sandbox)

data/lib/cocoapods/installer/target_installer.rb

@@ -36,25 +36,47 @@ module Pod
       # @return [void]
       #
       def add_target
+        product_type = target.product_type
         name = target.label
         platform = target.platform.name
         deployment_target = target.platform.deployment_target.to_s
-        @native_target = project.new_target(:static_library, name, platform, deployment_target)
+        @native_target = project.new_target(product_type, name, platform, deployment_target)
+
+        product_name = target.product_name
+        product = @native_target.product_reference
+        product.name = product_name
+        product.path = product_name
 
         target.user_build_configurations.each do |bc_name, type|
           configuration = @native_target.add_build_configuration(bc_name, type)
         end
 
-        settings = { 'OTHER_LDFLAGS' => '', 'OTHER_LIBTOOLFLAGS' => '' }
+        @native_target.build_configurations.each do |configuration|
+          configuration.build_settings.merge!(custom_build_settings)
+        end
+
+        target.native_target = @native_target
+      end
+
+      # Returns the customized build settings which are overridden in the build
+      # settings of the user target.
+      #
+      # @return [Hash{String => String}]
+      #
+      def custom_build_settings
+        settings = {}
+
         if target.archs
           settings['ARCHS'] = target.archs
         end
 
-        @native_target.build_configurations.each do |configuration|
-          configuration.build_settings.merge!(settings)
+        if target.requires_frameworks?
+          settings['PRODUCT_NAME'] = target.product_module_name
+        else
+          settings.merge!('OTHER_LDFLAGS' => '', 'OTHER_LIBTOOLFLAGS' => '')
         end
 
-        target.native_target = @native_target
+        settings
       end
 
       # Creates the directory where to store the support files of the target.
@@ -63,6 +85,68 @@ module Pod
         target.support_files_dir.mkdir
       end
 
+      # Creates the Info.plist file which sets public framework attributes
+      #
+      # @return [void]
+      #
+      def create_info_plist_file
+        path = target.info_plist_path
+        UI.message "- Generating Info.plist file at #{UI.path(path)}" do
+          generator = Generator::InfoPlistFile.new(target)
+          generator.save_as(path)
+          add_file_to_support_group(path)
+
+          native_target.build_configurations.each do |c|
+            relative_path = path.relative_path_from(sandbox.root)
+            c.build_settings['INFOPLIST_FILE'] = relative_path.to_s
+          end
+        end
+      end
+
+      # Creates the module map file which ensures that the umbrella header is
+      # recognized with a customized path
+      #
+      # @return [void]
+      #
+      def create_module_map
+        path = target.module_map_path
+        UI.message "- Generating module map file at #{UI.path(path)}" do
+          generator = Generator::ModuleMap.new(target)
+          generator.save_as(path)
+          add_file_to_support_group(path)
+
+          native_target.build_configurations.each do |c|
+            relative_path = path.relative_path_from(sandbox.root)
+            c.build_settings['MODULEMAP_FILE'] = relative_path.to_s
+          end
+        end
+      end
+
+      # Generates a header which ensures that all header files are exported
+      # in the module map
+      #
+      # @yield_param [Generator::UmbrellaHeader]
+      #              yielded once to configure the imports
+      #
+      def create_umbrella_header
+        path = target.umbrella_header_path
+        UI.message "- Generating umbrella header at #{UI.path(path)}" do
+          generator = Generator::UmbrellaHeader.new(target)
+          yield generator if block_given?
+          generator.save_as(path)
+
+          # Add the file to the support group and the native target,
+          # so it will been added to the header build phase
+          file_ref = add_file_to_support_group(path)
+          native_target.add_file_references([file_ref])
+
+          # Make the umbrella header public
+          build_file = native_target.headers_build_phase.build_file(file_ref)
+          build_file.settings ||= {}
+          build_file.settings['ATTRIBUTES'] = ['Public']
+        end
+      end
+
       # Generates a dummy source file for each target so libraries that contain
       # only categories build.
       #