cocoapods 0.2.0 → 0.3.0

data/lib/cocoapods/command/spec.rb

@@ -4,14 +4,14 @@ module Pod
       def self.banner
 %{Managing PodSpec files:
 
-    $ pod help spec
+    $ pod spec create NAME
 
-      pod spec create NAME
-        Creates a PodSpec, in the current working dir, called `NAME.podspec'.
+      Creates a PodSpec, in the current working dir, called `NAME.podspec'.
 
-      pod spec lint NAME.podspec
-        Validates `NAME.podspec'. In case `NAME.podspec' is omitted, it defaults
-        to `*.podspec' in the current working dir.}
+    $ pod spec lint NAME.podspec
+
+      Validates `NAME.podspec'. In case `NAME.podspec' is omitted, it defaults
+      to `*.podspec' in the current working dir.}
       end
 
       def initialize(argv)
@@ -34,6 +34,7 @@ module Pod
           Pod::Spec.new do |s|
             s.name     = '#{@name}'
             s.version  = '1.0.0'
+            s.license  = 'MIT'
             s.summary  = 'A short description of #{@name}.'
             s.homepage = 'http://example.com/#{@name}'
             s.author   = { '#{author}' => '#{email}' }
@@ -45,7 +46,7 @@ module Pod
             # automatically have '*.{h,m,mm,c,cpp}' appended.
             s.source_files = 'Classes', 'Classes/**/*.{h,m}'
 
-            s.xcconfig = { 'OTHER_LDFLAGS' => '-framework SomeRequiredFramework' }
+            s.framework = 'SomeRequiredFramework'
 
             s.dependency 'SomeLibraryThat#{@name}DependsOn', '>= 1.0.0'
           end

data/lib/cocoapods/config.rb

@@ -10,7 +10,7 @@ module Pod
       @instance = instance
     end
 
-    attr_accessor :repos_dir, :project_pods_root, :rootspec, :clean, :verbose, :silent
+    attr_accessor :repos_dir, :project_root, :project_pods_root, :rootspec, :clean, :verbose, :silent
     alias_method :clean?,   :clean
     alias_method :verbose?, :verbose
     alias_method :silent?,  :silent
@@ -23,7 +23,7 @@ module Pod
     end
 
     def project_root
-      Pathname.pwd
+      @project_root ||= Pathname.pwd
     end
 
     def project_pods_root

data/lib/cocoapods/dependency.rb

@@ -7,13 +7,75 @@ module Pod
     attr_accessor :only_part_of_other_pod
     alias_method :only_part_of_other_pod?, :only_part_of_other_pod
 
-    def initialize(name, *version_requirements)
-      super
+    attr_accessor :external_spec_source
+
+    attr_accessor :specification
+
+    def initialize(*name_and_version_requirements, &block)
+      if name_and_version_requirements.empty? && block
+        @inline_podspec = true
+        @specification  = Specification.new(&block)
+        super(@specification.name, @specification.version)
+
+      elsif !name_and_version_requirements.empty? && block.nil?
+        if name_and_version_requirements.last.is_a?(Hash)
+          @external_spec_source = name_and_version_requirements.pop
+        end
+        super(*name_and_version_requirements)
+
+      else
+        raise Informative, "A dependency needs either a name and version requirements, " \
+                           "a source hash, or a block which defines a podspec."
+      end
       @only_part_of_other_pod = false
     end
 
     def ==(other)
-      super && @only_part_of_other_pod == other.only_part_of_other_pod
+      super &&
+        @only_part_of_other_pod == other.only_part_of_other_pod &&
+         (@specification ? @specification == other.specification : @external_spec_source == other.external_spec_source)
+    end
+
+    def to_s
+      version = ''
+      if source = @external_spec_source
+        version << "from `#{source[:git] || source[:podspec]}'"
+        version << ", commit `#{source[:commit]}'" if source[:commit]
+        version << ", tag `#{source[:tag]}'"       if source[:tag]
+      elsif @inline_podspec
+        version << "defined in Podfile"
+      elsif @version_requirements != Gem::Requirement.default
+        version << @version_requirements.to_s
+      end
+      version.empty? ? @name : "#{@name} (#{version})"
+    end
+
+    # In case this dependency was defined with either a repo url, :podspec, or block,
+    # this method will return the Specification instance.
+    def specification
+      @specification ||= begin
+        if @external_spec_source
+          config   = Config.instance
+          pod_root = config.project_pods_root + @name
+          spec     = nil
+          if @external_spec_source[:podspec]
+            config.project_pods_root.mkpath
+            spec = config.project_pods_root + "#{@name}.podspec"
+            source = @external_spec_source[:podspec]
+            # can be http, file, etc
+            require 'open-uri'
+            puts "  * Fetching podspec for `#{@name}' from: #{source}" unless config.silent?
+            open(source) do |io|
+              spec.open('w') { |f| f << io.read }
+            end
+          else
+            puts "  * Pre-downloading: `#{@name}'" unless config.silent?
+            Downloader.for_source(pod_root, @external_spec_source).download
+            spec = pod_root + "#{@name}.podspec"
+          end
+          Specification.from_file(spec)
+        end
+      end
     end
 
     # Taken from a newer version of RubyGems

data/lib/cocoapods/downloader.rb

@@ -20,17 +20,22 @@ module Pod
       executable :git
 
       def download
+        @pod_root.dirname.mkpath
         if @options[:tag]
           download_tag
         elsif @options[:commit]
           download_commit
         else
-          raise "Either a tag or a commit has to be specified."
+          download_head
         end
       end
 
+      def download_head
+        git "clone '#{@url}' '#{@pod_root}'"
+      end
+
       def download_tag
-        @pod_root.mkdir
+        @pod_root.mkpath
         Dir.chdir(@pod_root) do
           git "init"
           git "remote add origin '#{@url}'"

data/lib/cocoapods/installer.rb

@@ -1,107 +1,269 @@
+require 'yaml'
+
 module Pod
   class Installer
-    include Config::Mixin
+    module Shared
+      def dependent_specification_sets
+        @dependent_specification_sets ||= Resolver.new(@podfile, @definition ? @definition.dependencies : nil).resolve
+      end
 
-    def initialize(specification)
-      @specification = specification
-    end
+      def build_specifications
+        dependent_specification_sets.reject(&:only_part_of_other_pod?).map(&:specification)
+      end
 
-    def dependent_specification_sets
-      @dependent_specification_sets ||= Resolver.new(@specification).resolve
+      def download_only_specifications
+        dependent_specification_sets.select(&:only_part_of_other_pod?).map(&:specification)
+      end
     end
 
-    def build_specification_sets
-      dependent_specification_sets.reject(&:only_part_of_other_pod?)
-    end
+    class CopyResourcesScript
+      CONTENT = <<EOS
+#!/bin/sh
 
-    def build_specifications
-      build_specification_sets.map(&:specification)
-    end
+install_resource()
+{
+  echo "cp -R ${SRCROOT}/Pods/$1 ${CONFIGURATION_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
+  cp -R ${SRCROOT}/Pods/$1 ${CONFIGURATION_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}
+}
+EOS
 
-    def xcconfig
-      @xcconfig ||= Xcode::Config.new({
-        # In a workspace this is where the static library headers should be found.
-        'USER_HEADER_SEARCH_PATHS' => '"$(BUILT_PRODUCTS_DIR)/Pods"',
-        'ALWAYS_SEARCH_USER_PATHS' => 'YES',
-        # This makes categories from static libraries work, which many libraries
-        # require, so we add these by default.
-        'OTHER_LDFLAGS'            => '-ObjC -all_load',
-      })
-    end
+      attr_reader :resources
 
-    def template
-      @template ||= ProjectTemplate.new(@specification.platform)
-    end
+      # A list of files relative to the project pods root.
+      def initialize(resources)
+        @resources = resources
+      end
 
-    def xcodeproj
-      @xcodeproj ||= Xcode::Project.new(template.xcodeproj_path)
+      def save_as(pathname)
+        pathname.open('w') do |script|
+          script.puts CONTENT
+          @resources.each do |resource|
+            script.puts "install_resource '#{resource}'"
+          end
+        end
+        # TODO use File api
+        system("chmod +x '#{pathname}'")
+      end
     end
 
-    # TODO move xcconfig related code into the xcconfig method, like copy_resources_script and generate_bridge_support.
-    def generate_project
-      puts "==> Generating Xcode project and xcconfig" unless config.silent?
-      user_header_search_paths = []
-      build_specifications.each do |spec|
-        xcconfig.merge!(spec.xcconfig)
-        group = xcodeproj.add_pod_group(spec.name)
+    class TargetInstaller
+      include Config::Mixin
+      include Shared
+
+      attr_reader :target
+
+      def initialize(podfile, project, definition)
+        @podfile, @project, @definition = podfile, project, definition
+      end
+
+      def xcconfig
+        @xcconfig ||= Xcodeproj::Config.new({
+          # In a workspace this is where the static library headers should be found.
+          'USER_HEADER_SEARCH_PATHS' => '"$(BUILT_PRODUCTS_DIR)/Pods"',
+          'ALWAYS_SEARCH_USER_PATHS' => 'YES',
+          # This makes categories from static libraries work, which many libraries
+          # require, so we add these by default.
+          'OTHER_LDFLAGS'            => '-ObjC -all_load',
+        })
+      end
+
+      def xcconfig_filename
+        "#{@definition.lib_name}.xcconfig"
+      end
+
+      def copy_resources_script
+        @copy_resources_script ||= CopyResourcesScript.new(build_specifications.map do |spec|
+          spec.expanded_resources
+        end.flatten)
+      end
+
+      def copy_resources_filename
+        "#{@definition.lib_name}-resources.sh"
+      end
 
-        # Only add implementation files to the compile phase
-        spec.implementation_files.each do |file|
-          group.add_source_file(file, nil, spec.compiler_flags)
+      def bridge_support_generator
+        BridgeSupportGenerator.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"
+      end
+
+      # TODO move out
+      def save_prefix_header_as(pathname)
+        pathname.open('w') do |header|
+          header.puts "#ifdef __OBJC__"
+          header.puts "#import #{@podfile.platform == :ios ? '<UIKit/UIKit.h>' : '<Cocoa/Cocoa.h>'}"
+          header.puts "#endif"
         end
+      end
+
+      def prefix_header_filename
+        "#{@definition.lib_name}-prefix.pch"
+      end
 
-        # Add header files to a `copy header build phase` for each destination
-        # directory in the pod's header directory.
-        spec.copy_header_mappings.each do |header_dir, files|
-          copy_phase = xcodeproj.add_copy_header_build_phase(spec.name, header_dir)
-          files.each do |file|
-            group.add_source_file(file, copy_phase)
+      # 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)
+
+        user_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
+          # Add header files to a `copy header build phase` for each destination
+          # directory in the pod's header directory.
+          spec.copy_header_mappings.each do |header_dir, files|
+            copy_phase = @target.copy_files_build_phases.new_pod_dir(spec.name, header_dir)
+            files.each do |file|
+              @target.add_source_file(file, copy_phase)
+            end
           end
+          # Collect all header search paths
+          user_header_search_paths.concat(spec.user_header_search_paths)
         end
+        xcconfig.merge!('USER_HEADER_SEARCH_PATHS' => user_header_search_paths.sort.uniq.join(" "))
 
-        # Collect all header search paths
-        user_header_search_paths.concat(spec.user_header_search_paths)
+        # 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
+        end
+      end
+
+      def create_files_in(root)
+        xcconfig.save_as(root + xcconfig_filename)
+        if @podfile.generate_bridge_support?
+          bridge_support_generator.save_as(root + bridge_support_filename)
+          copy_resources_script.resources << bridge_support_filename
+        end
+        save_prefix_header_as(root + prefix_header_filename)
+        copy_resources_script.save_as(root + copy_resources_filename)
       end
-      xcconfig.merge!('USER_HEADER_SEARCH_PATHS' => user_header_search_paths.sort.uniq.join(" "))
     end
 
-    def copy_resources_script
-      @copy_resources_script ||= Xcode::CopyResourcesScript.new(build_specifications.map { |spec| spec.expanded_resources }.flatten)
+    include Config::Mixin
+    include Shared
+
+    def initialize(podfile)
+      @podfile = podfile
     end
 
-    def bridge_support_generator
-      BridgeSupportGenerator.new(build_specifications.map do |spec|
-        spec.header_files.map do |header|
-          config.project_pods_root + header
+    def lock_file
+      config.project_root + 'Podfile.lock'
+    end
+
+    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|
+        # 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)
         end
-      end.flatten)
+      end
+      # Add a group to hold all the target support files
+      @project.main_group.groups.new('name' => 'Targets Support Files')
+      @project
+    end
+
+    def target_installers
+      @target_installers ||= @podfile.target_definitions.values.map do |definition|
+        TargetInstaller.new(@podfile, project, definition)
+      end
     end
 
     def install!
-      puts "Installing dependencies of: #{@specification.defined_in_file}" unless config.silent?
+      puts "Installing dependencies of: #{@podfile.defined_in_file}" unless config.silent?
       build_specifications.each(&:install!)
-      generate_project
-
       root = config.project_pods_root
-      puts "  * Copying contents of template directory `#{template.path}' to `#{root}'" if config.verbose?
-      template.copy_to(root)
-      pbxproj = File.join(root, 'Pods.xcodeproj')
-      puts "  * Writing Xcode project file to `#{pbxproj}'" if config.verbose?
-      xcodeproj.save_as(pbxproj)
-      xcconfig.create_in(root)
-      if @specification.generate_bridge_support?
-        path = bridge_support_generator.create_in(root)
-        copy_resources_script.resources << path.relative_path_from(config.project_pods_root)
-      end
-      copy_resources_script.create_in(root)
-
-      build_specifications.each(&:post_install)
+
+      puts "==> Generating support files" unless config.silent?
+      target_installers.each do |target_installer|
+        target_installer.install!
+        target_installer.create_files_in(root)
+      end
+      generate_lock_file!
+
+      puts "==> Running post install hooks" unless config.silent?
+      # Post install hooks run _before_ saving of project, so that they can alter it before saving.
+      target_installers.each do |target_installer|
+        target_installer.build_specifications.each { |spec| spec.post_install(target_installer) }
+      end
+      @podfile.post_install!(self)
+
+      puts "==> Generating Xcode project" unless config.silent?
+      projpath = File.join(root, 'Pods.xcodeproj')
+      puts "  * Writing Xcode project file to `#{projpath}'" if config.verbose?
+      project.save_as(projpath)
+    end
+
+    def generate_lock_file!
+      lock_file.open('w') do |file|
+        file.puts "PODS:"
+        pods = build_specifications.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}"
+          else
+            file.puts "  - #{name}:"
+            deps.each { |dep| file.puts "    - #{dep}" }
+          end
+        end
+
+        unless download_only_specifications.empty?
+          file.puts
+          file.puts "DOWNLOAD_ONLY:"
+          download_only_specifications.map(&:to_s).sort.each do |name|
+            file.puts "  - #{name}"
+          end
+        end
+
+        file.puts
+        file.puts "DEPENDENCIES:"
+        @podfile.dependencies.map(&:to_s).sort.each do |dep|
+          file.puts "  - #{dep}"
+        end
+      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)
       root = File.dirname(projpath)
       xcworkspace = File.join(root, File.basename(projpath, '.xcodeproj') + '.xcworkspace')
-      workspace = Xcode::Workspace.new_from_xcworkspace(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|
@@ -110,41 +272,24 @@ module Pod
       end
       workspace.save_as(xcworkspace)
 
-      app_project = Xcode::Project.new(projpath)
+      app_project = Xcodeproj::Project.new(projpath)
       return if app_project.files.find { |file| file.path =~ /libPods\.a$/ }
 
-      configfile = app_project.files.new({
-        'path' => 'Pods/Pods.xcconfig',
-        'lastKnownFileType' => 'text.xcconfig'
-      })
+      configfile = app_project.files.new('path' => 'Pods/Pods.xcconfig')
       app_project.targets.each do |target|
-        target.buildConfigurationList.buildConfigurations.each do |config|
-          config.baseConfigurationReference = configfile
+        target.buildConfigurations.each do |config|
+          config.baseConfiguration = configfile
         end
       end
-      app_project.main_group << configfile
       
-      libfile = app_project.files.new({
-        'path' => 'libPods.a',
-        'lastKnownFileType' => 'archive.ar',
-        'includeInIndex' => '0',
-        'sourceTree' => 'BUILT_PRODUCTS_DIR'
-      })
-      app_project.objects.select_by_class(Xcode::Project::PBXFrameworksBuildPhase).each do |build_phase|
-        build_phase.files << libfile.build_file
-      end
-      app_project.main_group << libfile
+      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
       
-      copy_resources = app_project.objects.add(Xcode::Project::PBXShellScriptBuildPhase, {
-        'name' => 'Copy Pods Resources',
-        'buildActionMask' => '2147483647',
-        'files' => [],
-        'inputPaths' => [],
-        'outputPaths' => [],
-        'runOnlyForDeploymentPostprocessing' => '0',
-        'shellPath' => '/bin/sh',
-        'shellScript' => "${SRCROOT}/Pods/PodsResources.sh\n"
-      })
+      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)