cocoapods 0.5.1 → 0.6.0.rc1

data/lib/cocoapods/sandbox.rb

@@ -0,0 +1,63 @@
+require 'fileutils'
+
+module Pod
+  class Sandbox
+    attr_reader :root
+
+    HEADERS_DIR = "Headers"
+
+    def initialize(path)
+      @root = Pathname.new(path)
+      @header_search_paths = [HEADERS_DIR]
+
+      FileUtils.mkdir_p(@root)
+    end
+
+    def implode
+      root.rmtree
+    end
+
+    def headers_root
+      root + HEADERS_DIR
+    end
+
+    def project_path
+      root + "Pods.xcodeproj"
+    end
+
+    def add_header_file(namespace_path, relative_header_path)
+      namespaced_header_path = headers_root + namespace_path
+      namespaced_header_path.mkpath unless File.exist?(namespaced_header_path)
+      source = (root + relative_header_path).relative_path_from(namespaced_header_path)
+      Dir.chdir(namespaced_header_path) { FileUtils.ln_sf(source, relative_header_path.basename)}
+      @header_search_paths << namespaced_header_path.relative_path_from(root)
+      namespaced_header_path + relative_header_path.basename
+    end
+
+    def add_header_files(namespace_path, relative_header_paths)
+      relative_header_paths.map { |path| add_header_file(namespace_path, path) }
+    end
+
+    def header_search_paths
+      @header_search_paths.uniq.map { |path| "${PODS_ROOT}/#{path}" }
+    end
+
+    def prepare_for_install
+      headers_root.rmtree if headers_root.exist?
+    end
+
+    def podspec_for_name(name)
+      if spec_path = Dir[root + "#{name}/*.podspec"].first
+        Pathname.new(spec_path)
+      elsif spec_path = Dir[root + "Local Podspecs/#{name}.podspec"].first
+        Pathname.new(spec_path)
+      end
+    end
+
+    def installed_pod_named(name, platform)
+      if spec_path = podspec_for_name(name)
+        LocalPod.from_podspec(spec_path, self, platform)
+      end
+    end
+  end
+end

data/lib/cocoapods/source.rb

@@ -1,29 +1,51 @@
 module Pod
   class Source
-    def self.all
-      @sources ||= begin
-        repos_dir = Config.instance.repos_dir
-        unless repos_dir.exist?
-          raise Informative, "No spec repos found in `#{repos_dir}'. " \
-                             "To fetch the `master' repo run: $ pod setup"
+    class Aggregate
+      def all
+        @sources ||= begin
+          repos_dir = Config.instance.repos_dir
+          unless repos_dir.exist?
+            raise Informative, "No spec repos found in `#{repos_dir}'. " \
+                               "To fetch the `master' repo run: $ pod setup"
+          end
+          repos_dir.children.select(&:directory?).map { |repo| Source.new(repo) }
+        end
+      end
+
+      def all_sets
+        all.map(&:pod_sets).flatten
+      end
+
+      def search(dependency)
+        all.map { |s| s.search(dependency) }.compact.first ||
+          raise(Informative, "[!] Unable to find a pod named `#{dependency.name}'".red)
+      end
+
+      def search_by_name(query, full_text_search)
+        result = all.map { |s| s.search_by_name(query, full_text_search) }.flatten
+        if result.empty?
+          extra = ", author, summary, or description" if full_text_search
+          raise(Informative, "Unable to find a pod with name" \
+                             "#{extra} matching `#{query}'")
         end
-        repos_dir.children.select(&:directory?).map { |repo| new(repo) }
+        result
       end
     end
 
+    def self.all
+      Aggregate.new.all
+    end
+
+    def self.all_sets
+      Aggregate.new.all_sets
+    end
+
     def self.search(dependency)
-      all.map { |s| s.search(dependency) }.compact.first ||
-        raise(Informative, "Unable to find a pod named `#{dependency.name}'")
+      Aggregate.new.search(dependency)
     end
 
-    def self.search_by_name(query, full_text_search)
-      result = all.map { |s| s.search_by_name(query, full_text_search) }.flatten
-      if result.empty?
-        extra = ", summary, or description" if full_text_search
-        raise(Informative, "Unable to find a pod with name" \
-                           "#{extra} matching `#{query}'")
-      end
-      result
+    def self.search_by_name(name, full_text_search)
+      Aggregate.new.search_by_name(name, full_text_search)
     end
 
     attr_reader :repo
@@ -35,7 +57,7 @@ module Pod
     def pod_sets
       @repo.children.map do |child|
         if child.directory? && child.basename.to_s != '.git'
-          Specification::Set.by_pod_dir(child)
+          Specification::Set.new(child)
         end
       end.compact
     end
@@ -46,7 +68,7 @@ module Pod
         set.name == dependency.top_level_spec_name &&
           # Now either check if it's a dependency on the top level spec, or if it's not
           # check if the requested subspec exists in the top level spec.
-          (!dependency.subspec_dependency? || !set.specification.subspec_by_name(dependency.name).nil?)
+          set.specification.subspec_by_name(dependency.name)
       end
     end
 
@@ -54,7 +76,7 @@ module Pod
       pod_sets.map do |set|
         text = if full_text_search
           s = set.specification
-          "#{s.name} #{s.summary} #{s.description}"
+          "#{s.name} #{s.authors} #{s.summary} #{s.description}"
         else
           set.name
         end

data/lib/cocoapods/specification.rb

@@ -1,3 +1,5 @@
+require 'xcodeproj/config'
+
 module Pod
   extend Config::Mixin
 
@@ -6,166 +8,293 @@ module Pod
   end
 
   class Specification
-    autoload :Set, 'cocoapods/specification/set'
+    autoload :Set,        'cocoapods/specification/set'
+    autoload :Statistics, 'cocoapods/specification/statistics'
+
+    ### Initalization
 
     # The file is expected to define and return a Pods::Specification.
-    def self.from_file(path)
+    # If name is equals to nil it returns the top level Specification,
+    # otherwise it returned the specification with the name that matches
+    def self.from_file(path, subspec_name = nil)
       unless path.exist?
         raise Informative, "No podspec exists at path `#{path}'."
       end
-      spec = Pod._eval_podspec(path)
+      spec = ::Pod._eval_podspec(path)
       spec.defined_in_file = path
-      spec
+      spec.subspec_by_name(subspec_name)
     end
 
-    attr_accessor :defined_in_file
+    def initialize(parent = nil, name = nil)
+      @parent, @name = parent, name
+      @define_for_platforms = [:osx, :ios]
+      @clean_paths, @subspecs = [], []
+      @deployment_target = {}
+      unless parent
+        @source = {:git => ''}
+      end
 
-    def initialize
-      post_initialize
-      yield self if block_given?
-    end
+      # multi-platform attributes
+      %w[ source_files resources preserve_paths exclude_header_search_paths frameworks libraries dependencies compiler_flags].each do |attr|
+        instance_variable_set( "@#{attr}", { :ios => [], :osx => [] } )
+      end
+      @xcconfig = { :ios => Xcodeproj::Config.new, :osx => Xcodeproj::Config.new }
 
-    # TODO This is just to work around a MacRuby bug
-    def post_initialize
-      @dependencies, @source_files, @resources, @clean_paths, @subspecs = [], [], [], [], []
-      @platform = Platform.new(nil)
-      @xcconfig = Xcodeproj::Config.new
+      yield self if block_given?
     end
 
-    # Attributes
-
-    attr_accessor :name
-    attr_accessor :homepage
-    attr_accessor :description
-    attr_accessor :source
-    attr_accessor :license
+    ### Meta programming
 
-    attr_reader :version
-    def version=(version)
-      @version = Version.new(version)
+    # Creates a top level attribute reader. A lambda can
+    # be passed to process the ivar before returning it
+    def self.top_attr_reader(attr, read_lambda = nil)
+      define_method(attr) do
+        ivar = instance_variable_get("@#{attr}")
+        @parent ? top_level_parent.send(attr) : ( read_lambda ? read_lambda.call(self, ivar) : ivar )
+      end
     end
 
-    def authors=(*names_and_email_addresses)
-      list = names_and_email_addresses.flatten
-      unless list.first.is_a?(Hash)
-        authors = list.last.is_a?(Hash) ? list.pop : {}
-        list.each { |name| authors[name] = nil }
+    # Creates a top level attribute writer. A lambda can
+    # be passed to initalize the value
+    def self.top_attr_writer(attr, init_lambda = nil)
+      define_method("#{attr}=") do |value|
+        raise Informative, "Can't set `#{attr}' for subspecs." if @parent
+        instance_variable_set("@#{attr}",  init_lambda ? init_lambda.call(value) : value);
       end
-      @authors = authors || list.first
     end
-    alias_method :author=, :authors=
-    attr_reader :authors
 
+    # Creates a top level attribute accessor. A lambda can
+    # be passed to initialize the value in the attribute writer.
+    def self.top_attr_accessor(attr, writer_labmda = nil)
+      top_attr_reader attr
+      top_attr_writer attr, writer_labmda
+    end
 
-    def summary=(summary)
-      @summary = summary
+    # Returns the value of the attribute for the active platform
+    # chained with the upstream specifications. The ivar must store
+    # the platform specific values as an array.
+    def self.pltf_chained_attr_reader(attr)
+      define_method(attr) do
+        active_plaform_check
+        ivar_value = instance_variable_get("@#{attr}")[active_platform]
+        @parent ? @parent.send(attr) + ivar_value : ( ivar_value )
+      end
     end
-    attr_reader :summary
 
-    def description
-      @description || summary
+    def active_plaform_check
+      raise Informative, "#{self.inspect} not activated for a platform before consumption." unless active_platform
     end
 
-    def part_of=(*name_and_version_requirements)
-      self.part_of_dependency = *name_and_version_requirements
-      @part_of.only_part_of_other_pod = true
+    # Attribute writer that works in conjuction with the PlatformProxy.
+    def self.platform_attr_writer(attr, block = nil)
+      define_method("#{attr}=") do |value|
+        current = instance_variable_get("@#{attr}")
+        @define_for_platforms.each do |platform|
+          block ?  current[platform] = block.call(value, current[platform]) : current[platform] = value
+        end
+      end
     end
-    attr_reader :part_of
 
-    def part_of_dependency=(*name_and_version_requirements)
-      @part_of = dependency(*name_and_version_requirements)
+    def self.pltf_chained_attr_accessor(attr, block = nil)
+      pltf_chained_attr_reader(attr)
+      platform_attr_writer(attr, block)
     end
 
-    def source_files=(patterns)
-      @source_files = pattern_list(patterns)
+    # The PlatformProxy works in conjuction with Specification#_on_platform.
+    # It allows a syntax like `spec.ios.source_files = file`
+    class PlatformProxy
+      def initialize(specification, platform)
+        @specification, @platform = specification, platform
+      end
+
+      %w{ source_files= resource= resources= xcconfig= framework= frameworks= library= libraries= compiler_flags= deployment_target= dependency }.each do |method|
+        define_method(method) do |args|
+          @specification._on_platform(@platform) do
+            @specification.send(method, args)
+          end
+        end
+      end
     end
-    attr_reader :source_files
 
-    def resources=(patterns)
-      @resources = pattern_list(patterns)
+    def ios
+      PlatformProxy.new(self, :ios)
     end
-    attr_reader :resources
-    alias_method :resource=, :resources=
 
-    def clean_paths=(patterns)
-      @clean_paths = pattern_list(patterns)
+    def osx
+      PlatformProxy.new(self, :osx)
     end
-    attr_reader :clean_paths
+
+    ### Deprecated attributes - TODO: remove once master repo and fixtures have been updated
+
+    attr_writer :part_of_dependency
+    attr_writer :part_of
+
+    top_attr_accessor :clean_paths, lambda { |patterns| pattern_list(patterns) }
     alias_method :clean_path=, :clean_paths=
 
-    def xcconfig=(hash)
-      @xcconfig.merge!(hash)
+    ### Regular attributes
+
+    attr_accessor :parent
+    attr_accessor :preferred_dependency
+
+    def name
+      @parent ? "#{@parent.name}/#{@name}" : @name
     end
-    attr_reader :xcconfig
+    attr_writer :name
+
+    ### Attributes that return the first value defined in the chain
 
-    def frameworks=(*frameworks)
-      frameworks.unshift('')
-      self.xcconfig = { 'OTHER_LDFLAGS' => frameworks.join(' -framework ').strip }
+    def platform
+      @platform || ( @parent ? @parent.platform : nil )
     end
-    alias_method :framework=, :frameworks=
 
-    def libraries=(*libraries)
-      libraries.unshift('')
-      self.xcconfig = { 'OTHER_LDFLAGS' => libraries.join(' -l').strip }
+    def platform=(platform)
+      @platform = Platform.new(*platform)
     end
-    alias_method :library=, :libraries=
 
-    def header_dir=(dir)
-      @header_dir = Pathname.new(dir)
+    # If not platform is specified all the platforms are returned.
+    def available_platforms
+      platform.nil? ? @define_for_platforms.map { |platform| Platform.new(platform, deployment_target(platform)) } : [ platform ]
     end
-    def header_dir
-      @header_dir || pod_destroot_name
+
+    ### Top level attributes. These attributes represent the unique features of pod and can't be specified by subspecs.
+
+    top_attr_accessor :defined_in_file
+    top_attr_accessor :source
+    top_attr_accessor :homepage
+    top_attr_accessor :summary
+    top_attr_accessor :documentation
+    top_attr_accessor :requires_arc
+    top_attr_accessor :license,             lambda { |l| ( l.kind_of? String ) ? { :type => l } : l }
+    top_attr_accessor :version,             lambda { |v| Version.new(v) }
+    top_attr_accessor :authors,             lambda { |a| parse_authors(a) }
+    top_attr_accessor :header_mappings_dir, lambda { |file| Pathname.new(file) } # If not provided the headers files are flattened
+    top_attr_accessor :prefix_header_file,  lambda { |file| Pathname.new(file) }
+    top_attr_accessor :prefix_header_contents
+
+    top_attr_reader   :description,         lambda {|instance, ivar| ivar || instance.summary }
+    top_attr_writer   :description
+
+    top_attr_reader   :header_dir,          lambda {|instance, ivar| ivar || instance.pod_destroot_name }
+    top_attr_writer   :header_dir,          lambda {|dir| Pathname.new(dir) }
+
+    alias_method      :author=, :authors=
+
+    def self.parse_authors(*names_and_email_addresses)
+      list = names_and_email_addresses.flatten
+      unless list.first.is_a?(Hash)
+        authors = list.last.is_a?(Hash) ? list.pop : {}
+        list.each { |name| authors[name] = nil }
+      end
+      authors || list.first
     end
 
-    attr_writer :compiler_flags
-    def compiler_flags
-      flags = "#{@compiler_flags} "
-      flags << '-fobjc-arc' if requires_arc
-      flags
+    ### Attributes **with** multiple platform support
+
+    pltf_chained_attr_accessor  :source_files,                lambda {|value, current| pattern_list(value) }
+    pltf_chained_attr_accessor  :resources,                   lambda {|value, current| pattern_list(value) }
+    pltf_chained_attr_accessor  :preserve_paths,              lambda {|value, current| pattern_list(value) } # Paths that should not be cleaned
+    pltf_chained_attr_accessor  :exclude_header_search_paths, lambda {|value, current| pattern_list(value) } # Headers to be excluded from being added to search paths (RestKit)
+    pltf_chained_attr_accessor  :frameworks,                  lambda {|value, current| (current << value).flatten }
+    pltf_chained_attr_accessor  :libraries,                   lambda {|value, current| (current << value).flatten }
+
+    alias_method :resource=,    :resources=
+    alias_method :framework=,   :frameworks=
+    alias_method :library=,     :libraries=
+
+    platform_attr_writer        :xcconfig,                     lambda {|value, current| current.tap { |c| c.merge!(value) } }
+
+    def xcconfig
+      raw_xconfig.dup.
+        tap { |x| x.libraries.merge  libraries }.
+        tap { |x| x.frameworks.merge frameworks }
     end
 
-    def platform=(platform)
-      @platform = Platform.new(platform)
+    def raw_xconfig
+      @parent ? @parent.raw_xconfig.merge(@xcconfig[active_platform]) : @xcconfig[active_platform]
     end
-    attr_reader :platform
 
-    attr_accessor :requires_arc
+
+    def compiler_flags
+      if @parent
+        chained = @compiler_flags[active_platform].clone
+        # TODO hack to get the parent's compiler flags without it being
+        # converted to a String by Specification#compiler_flags.
+        chained.unshift @parent.instance_variable_get(:@compiler_flags)[active_platform]
+      else
+        chained = @compiler_flags[active_platform].clone
+        chained.unshift '-fobjc-arc' if @requires_arc
+        chained.unshift ''
+      end
+      chained.join(' ')
+    end
+
+    platform_attr_writer :compiler_flags, lambda {|value, current| current << value }
 
     def dependency(*name_and_version_requirements)
       name, *version_requirements = name_and_version_requirements.flatten
+      raise Informative, "A specification can't require self as a subspec" if name == self.name
+      raise Informative, "A subspec can't require one of its parents specifications" if @parent && @parent.name.include?(name)
       dep = Dependency.new(name, *version_requirements)
-      @dependencies << dep
+      @define_for_platforms.each do |platform|
+        @dependencies[platform] << dep
+      end
       dep
     end
-    attr_reader :dependencies
 
-    def subspec(name, &block)
-      subspec = Subspec.new(self, name, &block)
-      @subspecs << subspec
-      subspec
+    # External dependencies are inherited by subspecs
+    def external_dependencies(all_platforms = false)
+      active_plaform_check unless all_platforms
+      result = all_platforms ? @dependencies.values.flatten : @dependencies[active_platform]
+      result += parent.external_dependencies if parent
+      result
     end
-    attr_reader :subspecs
 
-    # Not attributes
+    # A specification inherits the preferred_dependency or
+    # all the compatible subspecs as dependencies
+    def subspec_dependencies
+      active_plaform_check
+      specs = preferred_dependency ? [subspec_by_name("#{name}/#{preferred_dependency}")] : subspecs
+      specs.compact \
+        .select { |s| s.supports_platform?(active_platform) } \
+        .map    { |s| Dependency.new(s.name, version) }
+    end
 
-    # TODO when we move to use a 'ResolveContext' this should happen there.
-    attr_accessor :defined_in_set
+    def dependencies
+      external_dependencies + subspec_dependencies
+    end
 
     include Config::Mixin
-    
-    def local?
-      !source.nil? && !source[:local].nil?
+
+    def top_level_parent
+      @parent ? @parent.top_level_parent : self
     end
-    
-    def local_path
-      Pathname.new(File.expand_path(source[:local]))
+
+    def subspec?
+      !@parent.nil?
     end
 
-    def wrapper?
-      source_files.empty? && !subspecs.empty?
+    def subspec(name, &block)
+      subspec = Specification.new(self, name, &block)
+      @subspecs << subspec
+      subspec
+    end
+    attr_reader :subspecs
+
+    def recursive_subspecs
+      unless @recursive_subspecs
+        mapper = lambda do |spec|
+            spec.subspecs.map do |subspec|
+              [subspec, *mapper.call(subspec)]
+            end.flatten
+          end
+          @recursive_subspecs = mapper.call self
+      end
+      @recursive_subspecs
     end
 
     def subspec_by_name(name)
+      return self if name.nil? || name == self.name
       # Remove this spec's name from the beginning of the name we’re looking for
       # and take the first component from the remainder, which is the spec we need
       # to find now.
@@ -175,38 +304,24 @@ module Pod
       # If this was the last component in the name, then return the subspec,
       # otherwise we recursively keep calling subspec_by_name until we reach the
       # last one and return that
-      remainder.empty? ? subspec : subspec.subspec_by_name(name)
-    end
-
-    def ==(other)
-      object_id == other.object_id ||
-        (self.class === other &&
-          name && name == other.name &&
-            version && version == other.version)
-    end
 
-    def dependency_by_top_level_spec_name(name)
-      @dependencies.find { |d| d.top_level_spec_name == name }
+      raise Informative, "Unable to find a subspec named `#{name}'." unless subspec
+      remainder.empty? ? subspec : subspec.subspec_by_name(name)
     end
 
-    def part_of_specification_set
-      if part_of
-        Set.by_specification_name(part_of.name)
-      end
+    def local?
+      !source.nil? && !source[:local].nil?
     end
 
-    # Returns the specification for the pod that this pod's source is a part of.
-    def part_of_specification
-      (set = part_of_specification_set) && set.specification
+    def local_path
+      Pathname.new(File.expand_path(source[:local]))
     end
 
     def pod_destroot
-      if part_of_other_pod?
-        part_of_specification.pod_destroot
-      elsif local?
+      if local?
         local_path
       else
-        config.project_pods_root + @name
+        config.project_pods_root + top_level_parent.name
       end
     end
 
@@ -216,15 +331,7 @@ module Pod
       end
     end
 
-    def part_of_other_pod?
-      !part_of.nil?
-    end
-
-    def podfile?
-      false
-    end
-
-    def pattern_list(patterns)
+    def self.pattern_list(patterns)
       if patterns.is_a?(Array) && (!defined?(Rake) || !patterns.is_a?(Rake::FileList))
         patterns
       else
@@ -232,121 +339,14 @@ module Pod
       end
     end
 
-    # Returns all resource files of this pod, but relative to the
-    # project pods root.
-    def expanded_resources
-      files = []
-      resources.each do |pattern|
-        pattern = pod_destroot + pattern
-        pattern.glob.each do |file|
-          files << file.relative_path_from(config.project_pods_root)
-        end
-      end
-      files
-    end
-
-    # Returns full paths to clean for this pod.
-    def expanded_clean_paths
-      files = []
-      clean_paths.each do |pattern|
-        pattern = pod_destroot + pattern
-        pattern.glob.each do |file|
-          files << file
-        end
-      end
-      files
-    end
-
-    # Returns all source files of this pod including header files,
-    # but relative to the project pods root.
-    #
-    # If the pattern is the path to a directory, the pattern will
-    # automatically glob for c, c++, Objective-C, and Objective-C++
-    # files.
-    def expanded_source_files
-      files = []
-      source_files.each do |pattern|
-        pattern = pod_destroot + pattern
-        pattern = pattern + '*.{h,m,mm,c,cpp}' if pattern.directory?
-        pattern.glob.each do |file|
-          files << file.relative_path_from(config.project_pods_root)
-        end
-      end
-      files
-    end
-
-    def implementation_files
-      expanded_source_files.select { |f| f.extname != '.h' }
-    end
-
-    # Returns only the header files of this pod.
-    def header_files
-      expanded_source_files.select { |f| f.extname == '.h' }
-    end
-
     # This method takes a header path and returns the location it should have
     # in the pod's header dir.
     #
     # By default all headers are copied to the pod's header dir without any
-    # namespacing. You can, however, override this method in the podspec, or
-    # copy_header_mappings for full control.
+    # namespacing. However if the top level attribute accessor header_mappings_dir
+    # is specified the namespacing will be preserved from that directory.
     def copy_header_mapping(from)
-      from.basename
-    end
-
-    # See copy_header_mapping.
-    def copy_header_mappings
-      header_files.inject({}) do |mappings, from|
-        from_without_prefix = from.relative_path_from(pod_destroot_name)
-        to = header_dir + copy_header_mapping(from_without_prefix)
-        (mappings[to.dirname] ||= []) << from
-        mappings
-      end
-    end
-
-    # Returns a list of search paths where the pod's headers can be found. This
-    # includes the pod's header dir root and any other directories that might
-    # have been added by overriding the copy_header_mapping/copy_header_mappings
-    # methods.
-    def header_search_paths
-      dirs = [header_dir] + copy_header_mappings.keys
-      dirs.map { |dir| %{"$(PODS_ROOT)/Headers/#{dir}"} }
-    end
-
-    def to_s
-      "#{name} (#{version})"
-    end
-
-    def inspect
-      "#<#{self.class.name} for #{to_s}>"
-    end
-
-    def validate!
-      missing = []
-      missing << "`name'"                       unless name
-      missing << "`version'"                    unless version
-      missing << "`summary'"                    unless summary
-      missing << "`homepage'"                   unless homepage
-      missing << "`author(s)'"                  unless authors
-      missing << "either `source' or `part_of'" unless source || part_of
-      missing << "`source_files'"               if source_files.empty? && subspecs.empty?
-      # TODO
-      # * validate subspecs
-
-      incorrect = []
-      allowed = [nil, :ios, :osx]
-      incorrect << ["`platform'", allowed] unless allowed.include?(platform.name)
-
-      no_errors_found = missing.empty? && incorrect.empty?
-
-      unless no_errors_found
-        message = "The following #{(missing + incorrect).size == 1 ? 'attribute is' : 'attributes are'}:\n"
-        message << "* missing: #{missing.join(", ")}" unless missing.empty?
-        message << "* incorrect: #{incorrect.map { |x| "#{x[0]} (#{x[1..-1]})" }.join(", ")}" unless incorrect.empty?
-        raise Informative, message
-      end
-
-      no_errors_found
+      header_mappings_dir ? from.relative_path_from(header_mappings_dir) : from.basename
     end
 
     # This is a convenience method which gets called after all pods have been
@@ -365,53 +365,76 @@ module Pod
     def post_install(target)
     end
 
-    class Subspec < Specification
-      attr_reader :parent
+    def podfile?
+      false
+    end
 
-      def initialize(parent, name)
-        @parent, @name = parent, name
-        # TODO a MacRuby bug, the correct super impl `initialize' is not called consistently
-        #super(&block)
-        post_initialize
+    # This is used by the specification set
+    def dependency_by_top_level_spec_name(name)
+      external_dependencies(true).each do |dep|
+        return dep if dep.top_level_spec_name == name
+      end
+    end
 
-        # A subspec is _always_ part of the source of its top level spec.
-        self.part_of = top_level_parent.name, version
-        # A subspec has a dependency on the parent if the parent is a subspec too.
-        dependency(@parent.name, version) if @parent.is_a?(Subspec)
+    def to_s
+      "#{name} (#{version})"
+    end
 
-        yield self if block_given?
-      end
+    def inspect
+      "#<#{self.class.name} for #{to_s}>"
+    end
 
-      undef_method :name=, :version=, :source=, :defined_in_set=
+    def ==(other)
+      object_id == other.object_id ||
+        (self.class === other &&
+         name && name == other.name &&
+         version && version == other.version)
+    end
 
-      def top_level_parent
-        top_level_parent = @parent
-        top_level_parent = top_level_parent.parent while top_level_parent.is_a?(Subspec)
-        top_level_parent
-      end
+    # Returns whether the specification is supported in a given platform
+    def supports_platform?(*platform)
+      platform = platform[0].is_a?(Platform) ? platform[0] : Platform.new(*platform)
+      available_platforms.any? { |p| platform.supports?(p) }
+    end
 
-      def name
-        "#{@parent.name}/#{@name}"
-      end
+    # Defines the active platform for comsumption of the specification and
+    # returns self for method chainability.
+    # The active platform must the the same accross the chain so attributes
+    # that are inherited can be correctly resolved.
+    def activate_platform(*platform)
+      platform = platform[0].is_a?(Platform) ? platform[0] : Platform.new(*platform)
+      raise Informative, "#{to_s} is not compatible with #{platform}." unless supports_platform?(platform)
+      top_level_parent.active_platform = platform.to_sym
+      self
+    end
 
-      # TODO manually forwarding the attributes that we have so far needed to forward,
-      # but need to think if there's a better way to do this.
+    top_attr_accessor :active_platform
 
-      def summary
-        @summary ? @summary : top_level_parent.summary
-      end
+    ### Not attributes
 
-      # Override the getters to always return the value of the top level parent spec.
-      [:version, :summary, :platform, :license, :authors, :requires_arc, :compiler_flags, :defined_in_set].each do |attr|
-        define_method(attr) { top_level_parent.send(attr) }
-      end
+    # @visibility private
+    #
+    # This is used by PlatformProxy to assign attributes for the scoped platform.
+    def _on_platform(platform)
+      before, @define_for_platforms = @define_for_platforms, [platform]
+      yield
+    ensure
+      @define_for_platforms = before
+    end
 
-      def copy_header_mapping(from)
-        top_level_parent.copy_header_mapping(from)
-      end
+    # @visibility private
+    #
+    # This is multi-platform and to support
+    # subspecs with different platforms is is resolved as the
+    # first non nil value accross the chain.
+    def deployment_target=(version)
+      raise Informative, "The deployment target must be defined per platform like `s.ios.deployment_target = '5.0'`." unless @define_for_platforms.count == 1
+      @deployment_target[@define_for_platforms.first] = version
     end
 
+    def deployment_target(platform)
+      @deployment_target[platform] || ( @parent ? @parent.deployment_target(platform) : nil )
+    end
   end
-
   Spec = Specification
 end