cocoapods 0.5.1 → 0.6.0.rc1

data/lib/cocoapods/installer.rb

@@ -1,28 +1,21 @@
+require 'colored'
+
 module Pod
   class Installer
-    autoload :TargetInstaller, 'cocoapods/installer/target_installer'
-
-    module Shared
-      def dependent_specifications
-        @dependent_specifications ||= Resolver.new(@podfile, @definition ? @definition.dependencies : nil).resolve
-      end
-
-      def build_specifications
-        dependent_specifications.reject do |spec|
-          spec.wrapper? || spec.defined_in_set.only_part_of_other_pod?
-        end
-      end
-
-      def download_only_specifications
-        dependent_specifications - build_specifications
-      end
-    end
+    autoload :TargetInstaller,       'cocoapods/installer/target_installer'
+    autoload :UserProjectIntegrator, 'cocoapods/installer/user_project_integrator'
 
     include Config::Mixin
-    include Shared
+
+    attr_reader :sandbox
 
     def initialize(podfile)
       @podfile = podfile
+      # FIXME: pass this into the installer as a parameter
+      @sandbox = Sandbox.new(config.project_pods_root)
+      @resolver = Resolver.new(@podfile, @sandbox)
+      # TODO: remove in 0.7 (legacy support for config.ios? and config.osx?)
+      config.podfile = podfile
     end
 
     def lock_file
@@ -31,15 +24,13 @@ module Pod
 
     def project
       return @project if @project
-      @project = Xcodeproj::Project.for_platform(@podfile.platform)
-      # First we need to resolve dependencies across *all* targets, so that the
-      # same correct versions of pods are being used for all targets. This
-      # happens when we call `build_specifications'.
-      build_specifications.each do |spec|
+      @project = Pod::Project.new
+      @project.user_build_configurations = @podfile.user_build_configurations
+      pods.each do |pod|
         # Add all source files to the project grouped by pod
-        group = @project.add_pod_group(spec.name)
-        spec.expanded_source_files.each do |path|
-          group.children.new('path' => path.to_s)
+        group = @project.add_pod_group(pod.name)
+        pod.source_files.each do |path|
+          group.files.new('path' => path.to_s)
         end
       end
       # Add a group to hold all the target support files
@@ -54,69 +45,105 @@ module Pod
     end
 
     def install_dependencies!
-      build_specifications.each do |spec|
-        if spec.pod_destroot.exist? || spec.local?
-          message = "Using #{spec}"
-          message += " [LOCAL]" if spec.local?
-          puts message unless config.silent?
-        else
-          puts "Installing #{spec}" unless config.silent?
-          spec = spec.part_of_specification if spec.part_of_other_pod?
-          downloader = Downloader.for_source(spec.pod_destroot, spec.source)
+      pods.each do |pod|
+        unless config.silent?
+          marker = config.verbose ? "\n-> ".green : ''
+          name = pod.top_specification.preferred_dependency ? "#{pod.top_specification.name}/#{pod.top_specification.preferred_dependency} (#{pod.top_specification.version})" : pod.to_s
+          puts marker << ( pod.exists? ? "Using #{name}" : "Installing #{name}".green )
+        end
+
+        unless pod.exists?
+          downloader = Downloader.for_pod(pod)
           downloader.download
-          # TODO move cleaning into the installer as well
-          downloader.clean(spec.expanded_clean_paths) if config.clean
+          # The docs need to be generated before cleaning because
+          # the documentation is created for all the subspecs.
+          generate_docs(pod)
+          pod.clean if config.clean
         end
       end
     end
 
+    #TODO: move to generator ?
+    def generate_docs(pod)
+      doc_generator = Generator::Documentation.new(pod)
+      if ( config.generate_docs? && !doc_generator.already_installed? )
+        puts "-> Installing documentation" if config.verbose?
+        doc_generator.generate(config.doc_install?)
+      else
+        puts "-> Using existing documentation" if config.verbose?
+      end
+    end
+
     def install!
-      puts "Installing dependencies of: #{@podfile.defined_in_file}" if config.verbose?
-      install_dependencies!
-      root = config.project_pods_root
-      headers_symlink_root = config.headers_symlink_root
+      @sandbox.prepare_for_install
 
-      # Clean old header symlinks
-      FileUtils.rm_r(headers_symlink_root, :secure => true) if File.exists?(headers_symlink_root)
+      print_title "Resolving dependencies of: #{@podfile.defined_in_file}"
+      specs_by_target
 
-      puts "Generating support files" unless config.silent?
+      print_title "Installing dependencies"
+      install_dependencies!
+
+      print_title("Generating support files\n", false)
       target_installers.each do |target_installer|
-        target_installer.install!
-        target_installer.create_files_in(root)
+        pods_for_target = pods_by_target[target_installer.target_definition]
+        target_installer.install!(pods_for_target, @sandbox)
+        acknowledgements_path = target_installer.target_definition.acknowledgements_path
+        Generator::Acknowledgements.new(target_installer.target_definition,
+                                        pods_for_target).save_as(acknowledgements_path)
       end
-      generate_lock_file!
 
-      puts "* Running post install hooks" if config.verbose?
+      generate_lock_file!(specifications)
+      generate_dummy_source
+
+      puts "- Running post install hooks" if config.verbose?
       # Post install hooks run _before_ saving of project, so that they can alter it before saving.
+      run_post_install_hooks
+
+      puts "- Writing Xcode project file to `#{@sandbox.project_path}'\n\n" if config.verbose?
+      project.save_as(@sandbox.project_path)
+
+      UserProjectIntegrator.new(@podfile).integrate! if config.integrate_targets?
+    end
+
+    def run_post_install_hooks
+      # we loop over target installers instead of pods, because we yield the target installer
+      # to the spec post install hook.
       target_installers.each do |target_installer|
-        target_installer.build_specifications.each { |spec| spec.post_install(target_installer) }
+        specs_by_target[target_installer.target_definition].each do |spec|
+          spec.post_install(target_installer)
+        end
       end
-      @podfile.post_install!(self)
 
-      projpath = File.join(root, 'Pods.xcodeproj')
-      puts "* Writing Xcode project file to `#{projpath}'" if config.verbose?
-      project.save_as(projpath)
+      @podfile.post_install!(self)
     end
 
-    def generate_lock_file!
+    def generate_lock_file!(specs)
       lock_file.open('w') do |file|
         file.puts "PODS:"
-        pods = build_specifications.map do |spec|
+
+        # Get list of [name, dependencies] pairs.
+        pod_and_deps = specs.map do |spec|
           [spec.to_s, spec.dependencies.map(&:to_s).sort]
-        end.sort_by(&:first).each do |name, deps|
-          if deps.empty?
-            file.puts "  - #{name}"
+        end.uniq
+
+        # Merge dependencies of ios and osx version of the same pod.
+        tmp = {}
+        pod_and_deps.each do |name, deps|
+          if tmp[name]
+            tmp[name].concat(deps).uniq!
           else
-            file.puts "  - #{name}:"
-            deps.each { |dep| file.puts "    - #{dep}" }
+            tmp[name] = deps
           end
         end
+        pod_and_deps = tmp
 
-        unless download_only_specifications.empty?
-          file.puts
-          file.puts "DOWNLOAD_ONLY:"
-          download_only_specifications.map(&:to_s).sort.each do |name|
+        # Sort by name and print
+        pod_and_deps.sort_by(&:first).each do |name, deps|
+          if deps.empty?
             file.puts "  - #{name}"
+          else
+            file.puts "  - #{name}:"
+            deps.each { |dep| file.puts "    - #{dep}" }
           end
         end
 
@@ -128,55 +155,59 @@ module Pod
       end
     end
 
-    # For now this assumes just one pods target, i.e. only libPods.a.
-    # Not sure yet if we should try to be smart with apps that have multiple
-    # targets and try to map pod targets to those app targets.
-    #
-    # Possible options are:
-    # 1. Only cater to the most simple setup
-    # 2. Try to automagically figure it out by name. For example, a pod target
-    #    called `:some_target' could map to an app target called `SomeTarget'.
-    #    (A variation would be to not even camelize the target name, but simply
-    #    let the user specify it with the proper case.)
-    # 3. Let the user specify the app target name as an extra argument, but this
-    #    seems to be a less good version of the variation on #2.
-    def configure_project(projpath)
-      # TODO use more of Pathname’s API here
-      root = File.dirname(projpath)
-      xcworkspace = File.join(root, File.basename(projpath, '.xcodeproj') + '.xcworkspace')
-      workspace = Xcodeproj::Workspace.new_from_xcworkspace(xcworkspace)
-      pods_projpath = File.join(config.project_pods_root, 'Pods.xcodeproj')
-      root = Pathname.new(root).expand_path
-      [projpath, pods_projpath].each do |path|
-        path = Pathname.new(path).expand_path.relative_path_from(root).to_s
-        workspace << path unless workspace.include? path
-      end
-      workspace.save_as(xcworkspace)
+    def generate_dummy_source
+      filename = "PodsDummy.m"
+      pathname = Pathname.new(sandbox.root + filename)
+      Generator::DummySource.new.save_as(pathname)
 
-      app_project = Xcodeproj::Project.new(projpath)
-      return if app_project.files.find { |file| file.path =~ /libPods\.a$/ }
+      project_file = project.files.new('path' => filename)
+      project.group("Targets Support Files") << project_file
 
-      configfile = app_project.files.new('path' => 'Pods/Pods.xcconfig')
-      app_project.targets.each do |target|
-        target.buildConfigurations.each do |config|
-          config.baseConfiguration = configfile
-        end
+      target_installers.each do |target_installer|
+        target_installer.target.source_build_phases.first << project_file
       end
-      
-      libfile = app_project.files.new_static_library('Pods')
-      libfile.group = app_project.main_group.groups.find { |g| g.name == 'Frameworks' }
-      app_project.objects.select_by_class(Xcodeproj::Project::PBXFrameworksBuildPhase).each do |build_phase|
-        build_phase.files << libfile.buildFiles.new
+    end
+
+    def specs_by_target
+      @specs_by_target ||= @resolver.resolve
+    end
+
+    # @return [Array<Specification>]  All dependencies that have been resolved.
+    def specifications
+      specs_by_target.values.flatten
+    end
+
+    # @return [Array<LocalPod>]  A list of LocalPod instances for each
+    #                            dependency that is not a download-only one.
+    def pods
+      pods_by_target.values.flatten
+    end
+
+    def pods_by_target
+      @pods_by_spec = {}
+      result = {}
+      specs_by_target.each do |target_definition, specs|
+        @pods_by_spec[target_definition.platform] = {}
+        result[target_definition] = specs.map do |spec|
+          pod = pod_for_spec(spec, target_definition.platform)
+          pod.add_specification(spec)
+          pod
+        end.uniq.compact
       end
-      
-      copy_resources = app_project.add_shell_script_build_phase('Copy Pods Resources',
-%{"${SRCROOT}/Pods/Pods-resources.sh"\n})
-      app_project.targets.each { |target| target.buildPhases << copy_resources }
-      
-      app_project.save_as(projpath)
-
-      unless config.silent?
-        puts "[!] From now on use `#{File.basename(xcworkspace)}' instead of `#{File.basename(projpath)}'."
+      result
+    end
+
+    def pod_for_spec(spec, platform)
+      @pods_by_spec[platform][spec.top_level_parent.name] ||= LocalPod.new(spec, @sandbox, platform)
+    end
+
+    private
+
+    def print_title(title, only_verbose = true)
+      if config.verbose?
+        puts "\n" + title.yellow
+      elsif !config.silent? && !only_verbose
+        puts title
       end
     end
   end

data/lib/cocoapods/installer/target_installer.rb

@@ -2,123 +2,118 @@ module Pod
   class Installer
     class TargetInstaller
       include Config::Mixin
-      include Shared
 
-      attr_reader :podfile, :project, :definition, :target
+      attr_reader :podfile, :project, :target_definition, :target
+      attr_accessor :requires_arc
 
-      def initialize(podfile, project, definition)
-        @podfile, @project, @definition = podfile, project, definition
+      def initialize(podfile, project, target_definition)
+        @podfile, @project, @target_definition = podfile, project, target_definition
       end
 
       def xcconfig
         @xcconfig ||= Xcodeproj::Config.new({
           # In a workspace this is where the static library headers should be found.
-          'PODS_ROOT' => '$(SRCROOT)/Pods',
-          'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/Headers"',
+          'PODS_ROOT'                => @target_definition.relative_pods_root,
           'ALWAYS_SEARCH_USER_PATHS' => 'YES', # needed to make EmbedReader build
-          # This makes categories from static libraries work, which many libraries
-          # require, so we add these by default.
-          'OTHER_LDFLAGS'            => '-ObjC -all_load',
+          'OTHER_LDFLAGS'            => default_ld_flags,
         })
       end
 
-      def xcconfig_filename
-        "#{@definition.lib_name}.xcconfig"
+      def copy_resources_script_for(pods)
+        @copy_resources_script ||= Generator::CopyResourcesScript.new(pods.map { |p| p.resources }.flatten)
       end
 
-      def copy_resources_script
-        @copy_resources_script ||= Generator::CopyResourcesScript.new(build_specifications.map do |spec|
-          spec.expanded_resources
+      def bridge_support_generator_for(pods, sandbox)
+        Generator::BridgeSupport.new(pods.map do |pod|
+          pod.header_files.map { |header| sandbox.root + header }
         end.flatten)
       end
 
-      def copy_resources_filename
-        "#{@definition.lib_name}-resources.sh"
-      end
-
-      def bridge_support_generator
-        Generator::BridgeSupport.new(build_specifications.map do |spec|
-          spec.header_files.map do |header|
-            config.project_pods_root + header
-          end
-        end.flatten)
-      end
-
-      def bridge_support_filename
-        "#{@definition.lib_name}.bridgesupport"
+      # TODO This has to be removed, but this means the specs have to be updated if they need a reference to the prefix header.
+      def prefix_header_filename
+        @target_definition.prefix_header_name
       end
 
       # TODO move out to Generator::PrefixHeader
-      def save_prefix_header_as(pathname)
+      def save_prefix_header_as(pathname, pods)
         pathname.open('w') do |header|
           header.puts "#ifdef __OBJC__"
-          header.puts "#import #{@podfile.platform == :ios ? '<UIKit/UIKit.h>' : '<Cocoa/Cocoa.h>'}"
+          header.puts "#import #{@target_definition.platform == :ios ? '<UIKit/UIKit.h>' : '<Cocoa/Cocoa.h>'}"
           header.puts "#endif"
+          pods.each do |pod|
+            if prefix_header_contents = pod.top_specification.prefix_header_contents
+              header.puts
+              header.puts prefix_header_contents
+            elsif prefix_header = pod.prefix_header_file
+              header.puts
+              header.puts prefix_header.read
+            end
+          end
         end
       end
 
-      def prefix_header_filename
-        "#{@definition.lib_name}-prefix.pch"
+      def target_support_files
+        [:copy_resources_script_name, :prefix_header_name, :xcconfig_name].map { |file| @target_definition.send(file) }
       end
 
       # TODO move xcconfig related code into the xcconfig method, like copy_resources_script and generate_bridge_support.
-      def install!
-        # First add the target to the project
-        @target = @project.targets.new_static_library(@definition.lib_name)
-
-        header_search_paths = []
-        build_specifications.each do |spec|
-          xcconfig.merge!(spec.xcconfig)
-          # Only add implementation files to the compile phase
-          spec.implementation_files.each do |file|
-            @target.add_source_file(file, nil, spec.compiler_flags)
-          end
-          # Symlink header files to Pods/Headers
-          spec.copy_header_mappings.each do |header_dir, files|
-            target_dir = "#{config.headers_symlink_root}/#{header_dir}"
-            FileUtils.mkdir_p(target_dir)
-            target_dir_real_path = Pathname.new(target_dir).realpath
-            files.each do |file|
-              source = Pathname.new("#{config.project_pods_root}/#{file}").realpath.relative_path_from(target_dir_real_path)
-              Dir.chdir(target_dir) do
-                FileUtils.ln_sf(source, File.basename(file))
-              end
-            end
-          end
-          # Collect all header search paths
-          header_search_paths.concat(spec.header_search_paths)
+      def install!(pods, sandbox)
+        self.requires_arc = pods.any? { |pod| pod.requires_arc? }
+
+        @target = @project.add_pod_target(@target_definition.label, @target_definition.platform)
+
+        pods.each do |pod|
+          xcconfig.merge!(pod.xcconfig)
+          pod.add_to_target(@target)
+
+          # TODO: this doesn't need to be done here, it has nothing to do with the target
+          pod.link_headers
         end
-        xcconfig.merge!('HEADER_SEARCH_PATHS' => header_search_paths.sort.uniq.join(" "))
-
-        # Add all the target related support files to the group, even the copy
-        # resources script although the project doesn't actually use them.
-        support_files_group = @project.groups.find do |group|
-          group.name == "Targets Support Files"
-        end.groups.new("name" => @definition.lib_name)
-        support_files_group.files.new('path' => copy_resources_filename)
-        prefix_file = support_files_group.files.new('path' => prefix_header_filename)
-        xcconfig_file = support_files_group.files.new("path" => xcconfig_filename)
-        # Assign the xcconfig as the base config of each config.
-        @target.buildConfigurations.each do |config|
-          config.baseConfiguration = xcconfig_file
-          config.buildSettings['OTHER_LDFLAGS'] = ''
-          config.buildSettings['GCC_PREFIX_HEADER'] = prefix_header_filename
-          config.buildSettings['PODS_ROOT'] = '$(SRCROOT)'
+
+        xcconfig.merge!('HEADER_SEARCH_PATHS' => quoted(sandbox.header_search_paths).join(" "))
+
+        support_files_group = @project.group("Targets Support Files").create_group(@target_definition.label)
+        support_files_group.create_files(target_support_files)
+
+        xcconfig_file = support_files_group.files.where(:path => @target_definition.xcconfig_name)
+        configure_build_configurations(xcconfig_file)
+        create_files(pods, sandbox)
+      end
+
+      def configure_build_configurations(xcconfig_file)
+        @target.build_configurations.each do |config|
+          config.base_configuration = xcconfig_file
+          config.build_settings['OTHER_LDFLAGS'] = ''
+          config.build_settings['GCC_PREFIX_HEADER'] = @target_definition.prefix_header_name
+          config.build_settings['PODS_ROOT'] = '${SRCROOT}'
         end
       end
 
-      def create_files_in(root)
+      def create_files(pods, sandbox)
         if @podfile.generate_bridge_support?
-          puts "* Generating BridgeSupport metadata file at `#{root + bridge_support_filename}'" if config.verbose?
-          bridge_support_generator.save_as(root + bridge_support_filename)
-          copy_resources_script.resources << bridge_support_filename
+          bridge_support_metadata_path = sandbox.root + @target_definition.bridge_support_name
+          puts "- Generating BridgeSupport metadata file at `#{bridge_support_metadata_path}'" if config.verbose?
+          bridge_support_generator_for(pods, sandbox).save_as(bridge_support_metadata_path)
+          copy_resources_script_for(pods).resources << @target_definition.bridge_support_name
         end
-        puts "* Generating xcconfig file at `#{root + xcconfig_filename}'" if config.verbose?
-        xcconfig.save_as(root + xcconfig_filename)
-        puts "* Generating prefix header at `#{root + prefix_header_filename}'" if config.verbose?
-        save_prefix_header_as(root + prefix_header_filename)
-        puts "* Generating copy resources script at `#{root + copy_resources_filename}'" if config.verbose?
-        copy_resources_script.save_as(root + copy_resources_filename)
+        puts "- Generating xcconfig file at `#{sandbox.root + @target_definition.xcconfig_name}'" if config.verbose?
+        xcconfig.save_as(sandbox.root + @target_definition.xcconfig_name)
+        puts "- Generating prefix header at `#{sandbox.root + @target_definition.prefix_header_name}'" if config.verbose?
+        save_prefix_header_as(sandbox.root + @target_definition.prefix_header_name, pods)
+        puts "- Generating copy resources script at `#{sandbox.root + @target_definition.copy_resources_script_name}'" if config.verbose?
+        copy_resources_script_for(pods).save_as(sandbox.root + @target_definition.copy_resources_script_name)
+      end
+
+      private
+
+      def quoted(strings)
+        strings.map { |s| "\"#{s}\"" }
+      end
+
+      def default_ld_flags
+        flags = %w{-ObjC}
+        flags << '-fobjc-arc' if @podfile.set_arc_compatibility_flag? && self.requires_arc
+        flags.join(" ")
       end
     end
   end