cocoapods 0.5.1 → 0.6.0.rc1

data/lib/cocoapods/podfile.rb

@@ -1,26 +1,149 @@
 module Pod
   class Podfile
+    class UserProject
+      include Config::Mixin
+
+      DEFAULT_BUILD_CONFIGURATIONS = { 'Debug' => :debug, 'Release' => :release }.freeze
+
+      def initialize(path = nil, build_configurations = {})
+        self.path = path if path
+        @build_configurations = build_configurations.merge(DEFAULT_BUILD_CONFIGURATIONS)
+      end
+
+      def path=(path)
+        path  = path.to_s
+        @path = Pathname.new(File.extname(path) == '.xcodeproj' ? path : "#{path}.xcodeproj")
+        @path = config.project_root + @path unless @path.absolute?
+        @path
+      end
+
+      def path
+        if @path
+          @path
+        else
+          xcodeprojs = config.project_root.glob('*.xcodeproj')
+          if xcodeprojs.size == 1
+            @path = xcodeprojs.first
+          end
+        end
+      end
+
+      def project
+        Xcodeproj::Project.new(path) if path && path.exist?
+      end
+
+      def build_configurations
+        if project
+          project.build_configurations.map(&:name).inject({}) do |hash, name|
+            hash[name] = :release; hash
+          end.merge(@build_configurations)
+        else
+          @build_configurations
+        end
+      end
+    end
+
     class TargetDefinition
-      attr_reader :name, :parent, :target_dependencies
+      include Config::Mixin
 
-      def initialize(name, parent = nil)
-        @name, @parent, @target_dependencies = name, parent, []
+      attr_reader :name, :target_dependencies
+
+      attr_accessor :user_project, :link_with, :platform, :parent, :exclusive
+
+      def initialize(name, options = {})
+        @name, @target_dependencies = name, []
+        @parent, @exclusive = options.values_at(:parent, :exclusive)
       end
 
-      def lib_name
+      # A target is automatically `exclusive` if the `platform` does not match
+      # the parent's `platform`.
+      def exclusive
+        if @exclusive.nil?
+          if @platform.nil?
+            false
+          else
+            @parent.platform != @platform
+          end
+        else
+          @exclusive
+        end
+      end
+      alias_method :exclusive?, :exclusive
+
+      def user_project
+        @user_project || @parent.user_project
+      end
+
+      def link_with=(targets)
+        @link_with = targets.is_a?(Array) ? targets : [targets]
+      end
+
+      def platform
+        @platform || (@parent.platform if @parent)
+      end
+
+      def label
         if name == :default
           "Pods"
-        elsif @parent
-          "#{@parent.lib_name}-#{name}"
-        else
+        elsif exclusive?
           "Pods-#{name}"
+        else
+          "#{@parent.label}-#{name}"
+        end
+      end
+
+      def acknowledgements_path
+        config.project_pods_root + "#{label}-Acknowledgements"
+      end
+
+      # Returns a path, which is relative to the project_root, relative to the
+      # `$(SRCROOT)` of the user's project.
+      def relative_to_srcroot(path)
+        if user_project.path.nil?
+          # TODO this is not in the right place
+          raise Informative, "[!] Unable to find an Xcode project to integrate".red if config.integrate_targets
+          path
+        else
+          (config.project_root + path).relative_path_from(user_project.path.dirname)
         end
       end
 
+      def relative_pods_root
+        "${SRCROOT}/#{relative_to_srcroot "Pods"}"
+      end
+
+      def lib_name
+        "lib#{label}.a"
+      end
+
+      def xcconfig_name
+        "#{label}.xcconfig"
+      end
+
+      def xcconfig_relative_path
+        relative_to_srcroot("Pods/#{xcconfig_name}").to_s
+      end
+
+      def copy_resources_script_name
+        "#{label}-resources.sh"
+      end
+
+      def copy_resources_script_relative_path
+        "${SRCROOT}/#{relative_to_srcroot("Pods/#{copy_resources_script_name}")}"
+      end
+
+      def prefix_header_name
+        "#{label}-prefix.pch"
+      end
+
+      def bridge_support_name
+        "#{label}.bridgesupport"
+      end
+
       # Returns *all* dependencies of this target, not only the target specific
       # ones in `target_dependencies`.
       def dependencies
-        @target_dependencies + (@parent ? @parent.dependencies : [])
+        @target_dependencies + (exclusive? ? [] : @parent.dependencies)
       end
 
       def empty?
@@ -40,7 +163,9 @@ module Pod
     include Config::Mixin
 
     def initialize(&block)
-      @target_definitions = { :default => (@target_definition = TargetDefinition.new(:default)) }
+      @target_definition = TargetDefinition.new(:default, :exclusive => true)
+      @target_definition.user_project = UserProject.new
+      @target_definitions = { :default => @target_definition }
       instance_eval(&block)
     end
 
@@ -55,8 +180,73 @@ module Pod
     #   platform :ios, :deployment_target => "4.0"
     #
     # If the deployment target requires it (< 4.3), armv6 will be added to ARCHS.
-    def platform(platform = nil, options={})
-      platform ? @platform = Platform.new(platform, options) : @platform
+    #
+    def platform(platform, options={})
+      @target_definition.platform = Platform.new(platform, options)
+    end
+
+    # Specifies the Xcode workspace that should contain all the projects.
+    #
+    # If no explicit Xcode workspace is specified and only **one** project exists
+    # in the same directory as the Podfile, then the name of that project is used
+    # as the workspace’s name.
+    #
+    # @example
+    #
+    #   workspace 'MyWorkspace'
+    #
+    def workspace(path = nil)
+      if path
+        @workspace = config.project_root + (File.extname(path) == '.xcworkspace' ? path : "#{path}.xcworkspace")
+      elsif @workspace
+        @workspace
+      else
+        projects = @target_definitions.map { |_, td| td.user_project.path }.uniq
+        if projects.size == 1 && (xcodeproj = @target_definitions[:default].user_project.path)
+          config.project_root + "#{xcodeproj.basename('.xcodeproj')}.xcworkspace"
+        end
+      end
+    end
+
+    # Specifies the Xcode project that contains the target that the Pods library
+    # should be linked with.
+    #
+    # If no explicit project is specified, it will use the Xcode project of the
+    # parent target. If none of the target definitions specify an explicit project
+    # and there is only **one** project in the same directory as the Podfile then
+    # that project will be used.
+    #
+    # @example
+    #
+    #   # Look for target to link with in an Xcode project called ‘MyProject.xcodeproj’.
+    #   xcodeproj 'MyProject'
+    #
+    #   target :test do
+    #     # This Pods library links with a target in another project.
+    #     xcodeproj 'TestProject'
+    #   end
+    #
+    def xcodeproj(path, build_configurations = {})
+      @target_definition.user_project = UserProject.new(path, build_configurations)
+    end
+
+    # Specifies the target(s) in the user’s project that this Pods library
+    # should be linked in.
+    #
+    # If no explicit target is specified, then the Pods target will be linked
+    # with the first target in your project. So if you only have one target you
+    # do not need to specify the target to link with.
+    #
+    # @example
+    #
+    #   # Link with a target called ‘MyApp’ (in the user's project).
+    #   link_with 'MyApp'
+    #
+    #   # Link with the targets in the user’s project called ‘MyApp’ and ‘MyOtherApp’.
+    #   link_with ['MyApp', 'MyOtherApp']
+    #
+    def link_with(targets)
+      @target_definition.link_with = targets
     end
 
     # Specifies a dependency of the project.
@@ -156,8 +346,8 @@ module Pod
       @target_definition.target_dependencies << Dependency.new(*name_and_version_requirements, &block)
     end
 
-    # Specifies that a BridgeSupport metadata should be generated from the
-    # headers of all installed Pods.
+    # Specifies that a BridgeSupport metadata document should be generated from
+    # the headers of all installed Pods.
     #
     # This is for scripting languages such as MacRuby, Nu, and JSCocoa, which use
     # it to bridge types, functions, etc better.
@@ -193,7 +383,8 @@ module Pod
     # dependency (JSONKit).
     def target(name, options = {})
       parent = @target_definition
-      @target_definitions[name] = @target_definition = TargetDefinition.new(name, options[:exclusive] ? nil : parent)
+      options[:parent] = parent
+      @target_definitions[name] = @target_definition = TargetDefinition.new(name, options)
       yield
     ensure
       @target_definition = parent
@@ -206,8 +397,8 @@ module Pod
     #
     #   post_install do |installer|
     #     installer.project.targets.each do |target|
-    #       target.buildConfigurations.each do |config|
-    #         config.buildSettings['GCC_ENABLE_OBJC_GC'] = 'supported'
+    #       target.build_configurations.each do |config|
+    #         config.build_settings['GCC_ENABLE_OBJC_GC'] = 'supported'
     #       end
     #     end
     #   end
@@ -215,6 +406,19 @@ module Pod
       @post_install_callback = block
     end
 
+    # Specifies that the -fobjc-arc flag should be added to the OTHER_LD_FLAGS.
+    #
+    # This is used as a workaround for a compiler bug with non-ARC projects.
+    # (see https://github.com/CocoaPods/CocoaPods/issues/142)
+    #
+    # This was originally done automatically but libtool as of Xcode 4.3.2 no
+    # longer seems to support the -fobjc-arc flag. Therefore it now has to be
+    # enabled explicitly using this method.
+    #
+    # This may be removed in a future release.
+    def set_arc_compatibility_flag!
+      @set_arc_compatibility_flag = true
+    end
 
     # Not attributes
 
@@ -226,7 +430,7 @@ module Pod
     attr_reader :target_definitions
 
     def dependencies
-      @target_definitions.values.map(&:target_dependencies).flatten
+      @target_definitions.values.map(&:target_dependencies).flatten.uniq
     end
 
     def dependency_by_top_level_spec_name(name)
@@ -237,15 +441,24 @@ module Pod
       @generate_bridge_support
     end
 
+    def set_arc_compatibility_flag?
+      @set_arc_compatibility_flag
+    end
+
+    def user_build_configurations
+      configs_array = @target_definitions.values.map { |td| td.user_project.build_configurations }
+      configs_array.inject({}) { |hash, config| hash.merge(config) }
+    end
+
     def post_install!(installer)
       @post_install_callback.call(installer) if @post_install_callback
     end
 
     def validate!
-      lines = []
-      lines << "* the `platform` attribute should be either `:osx` or `:ios`" unless @platform && [:osx, :ios].include?(@platform.name)
-      lines << "* no dependencies were specified, which is, well, kinda pointless" if dependencies.empty?
-      raise(Informative, (["The Podfile at `#{@defined_in_file}' is invalid:"] + lines).join("\n")) unless lines.empty?
+      #lines = []
+      #lines << "* the `platform` attribute should be either `:osx` or `:ios`" unless @platform && [:osx, :ios].include?(@platform.name)
+      #lines << "* no dependencies were specified, which is, well, kinda pointless" if dependencies.empty?
+      #raise(Informative, (["The Podfile at `#{@defined_in_file}' is invalid:"] + lines).join("\n")) unless lines.empty?
     end
   end
 end

data/lib/cocoapods/project.rb

@@ -0,0 +1,67 @@
+require 'xcodeproj/project'
+require 'xcodeproj/project/object/build_phase'
+
+Xcodeproj::Project::Object::PBXCopyFilesBuildPhase.instance_eval do
+  def self.new_pod_dir(project, pod_name, path)
+    new(project, nil, {
+      "dstPath" => "Pods/#{path}",
+      "name"    => "Copy #{pod_name} Public Headers",
+    })
+  end
+end
+
+module Pod
+  class Project < Xcodeproj::Project
+    def initialize(*)
+      super
+      main_group << groups.new('name' => 'Pods')
+      @user_build_configurations = []
+    end
+
+    def user_build_configurations=(user_build_configurations)
+      @user_build_configurations = user_build_configurations
+      # The configurations at the top level only need to exist, they don't hold
+      # any build settings themselves, that's left to `add_pod_target`.
+      user_build_configurations.each do |name, _|
+        unless build_configurations.map(&:name).include?(name)
+          build_configurations.new('name' => name)
+        end
+      end
+    end
+
+    # Shortcut access to the `Pods' PBXGroup.
+    def pods
+      groups.find { |g| g.name == 'Pods' } || groups.new({ 'name' => 'Pods' })
+    end
+
+    # Adds a group as child to the `Pods' group.
+    def add_pod_group(name)
+      pods.groups.new('name' => name)
+    end
+
+    def add_pod_target(name, platform)
+      target = targets.new_static_library(platform.name, name)
+
+      settings = {}
+      if platform.requires_legacy_ios_archs?
+        settings['ARCHS'] = "armv6 armv7"
+      end
+      if platform == :ios && platform.deployment_target
+        settings['IPHONEOS_DEPLOYMENT_TARGET'] = platform.deployment_target.to_s
+      end
+
+      target.build_settings('Debug').merge!(settings)
+      target.build_settings('Release').merge!(settings)
+
+      @user_build_configurations.each do |name, type|
+        unless target.build_configurations.map(&:name).include?(name)
+          config = target.build_configurations.new('name' => name)
+          # Copy the settings from either the Debug or the Release configuration.
+          config.build_settings = target.build_settings(type.to_s.capitalize).merge(settings)
+        end
+      end
+
+      target
+    end
+  end
+end

data/lib/cocoapods/resolver.rb

@@ -1,51 +1,81 @@
+require 'colored'
+
 module Pod
   class Resolver
-    def initialize(specification, dependencies = nil)
-      @specification, @dependencies = specification, dependencies || specification.dependencies
+    include Config::Mixin
+
+    attr_reader :podfile, :sandbox
+    attr_accessor :cached_sets, :cached_sources
+
+    def initialize(podfile, sandbox)
+      @podfile = podfile
+      @sandbox = sandbox
+      @cached_sets = {}
+      @cached_sources = Source::Aggregate.new
+      @log_indent = 0;
     end
 
     def resolve
-      @sets, @loaded_spec_names, @specs = [], [], []
-      find_dependency_sets(@specification, @dependencies)
-      @specs.sort_by(&:name)
+      @specs = {}
+      targets_and_specs = {}
+
+      @podfile.target_definitions.values.each do |target_definition|
+        puts "\nResolving dependencies for target `#{target_definition.name}' (#{target_definition.platform})".green if config.verbose?
+        @loaded_specs = []
+        find_dependency_specs(@podfile, target_definition.dependencies, target_definition)
+        targets_and_specs[target_definition] = @specs.values_at(*@loaded_specs).sort_by(&:name)
+      end
+
+      @specs.values.sort_by(&:name)
+      targets_and_specs
     end
 
-    def find_dependency_sets(specification, dependencies = nil)
-      (dependencies || specification.dependencies).each do |dependency|
-        set = find_dependency_set(dependency)
-        set.required_by(specification)
-        unless @loaded_spec_names.include?(dependency.name)
-          # Get a reference to the spec that’s actually being loaded.
-          # If it’s a subspec dependency, e.g. 'RestKit/Network', then
-          # find that subspec.
-          spec = set.specification
+    private
+
+    def find_cached_set(dependency, platform)
+      set_name = dependency.name.split('/').first
+      @cached_sets[set_name] ||= begin
+        if dependency.specification
+          Specification::Set::External.new(dependency.specification)
+        elsif external_source = dependency.external_source
+          # The platform isn't actually being used by the LocalPod instance
+          # that's being used behind the scenes, but passing it anyways for
+          # completeness sake.
+          specification = external_source.specification_from_sandbox(@sandbox, platform)
+          set = Specification::Set::External.new(specification)
           if dependency.subspec_dependency?
-            spec = spec.subspec_by_name(dependency.name)
+            @cached_sets[dependency.top_level_spec_name] ||= set
           end
-          validate_platform!(spec)
-
-          # Ensure we don't resolve the same spec twice
-          @loaded_spec_names << spec.name
-          @specs << spec
-          @sets << set unless @sets.include?(set)
-
-          find_dependency_sets(spec)
+          set
+        else
+          @cached_sources.search(dependency)
         end
       end
     end
 
-    def find_dependency_set(dependency)
-      if external_spec = dependency.specification
-        Specification::Set::External.new(external_spec)
-      else
-        Source.search(dependency)
+    def find_dependency_specs(dependent_specification, dependencies, target_definition)
+      @log_indent += 1
+      dependencies.each do |dependency|
+        puts '  ' * @log_indent + "- #{dependency}" if config.verbose?
+        set = find_cached_set(dependency, target_definition.platform)
+        set.required_by(dependent_specification)
+        # Ensure we don't resolve the same spec twice for one target
+        unless @loaded_specs.include?(dependency.name)
+        spec = set.specification_by_name(dependency.name)
+          @loaded_specs << spec.name
+          @specs[spec.name] = spec
+          spec.activate_platform(target_definition.platform)
+          # And recursively load the dependencies of the spec.
+          find_dependency_specs(spec, spec.dependencies, target_definition) if spec.dependencies
+        end
+        validate_platform!(spec || @specs[dependency.name], target_definition)
       end
+      @log_indent -= 1
     end
 
-    def validate_platform!(spec)
-      unless spec.platform.nil? || spec.platform == @specification.platform
-        raise Informative, "The platform required by the Podfile (:#{@specification.platform}) " \
-                           "does not match that of #{spec} (:#{spec.platform})"
+    def validate_platform!(spec, target)
+      unless spec.available_platforms.any? { |platform| target.platform.supports?(platform) }
+        raise Informative, "[!] The platform of the target `#{target.name}' (#{target.platform}) is not compatible with `#{spec}' which has a minimun requirement of #{spec.available_platforms.join(' - ')}.".red
       end
     end
   end