cocoapods 0.16.4 → 0.17.0.rc1

data/lib/cocoapods/resolver.rb

@@ -1,221 +1,208 @@
-require 'colored'
-
 module Pod
-  class Resolver
-    include Config::Mixin
-
-    # @return [Bool] Whether the resolver should find the pods to install or
-    #   the pods to update.
-    #
-    attr_accessor :update_mode
-
-    # @return [Bool] Whether the resolver should update the external specs
-    #   in the resolution process.
-    #
-    attr_accessor :update_external_specs
-
-    # @return [Podfile] The Podfile used by the resolver.
-    #
-    attr_reader :podfile
 
-    # @return [Lockfile] The Lockfile used by the resolver.
-    #
-    attr_reader :lockfile
+  # The resolver is responsible of generating a list of specifications grouped
+  # by target for a given Podfile.
+  #
+  # @todo Its current implementation is naive, in the sense that it can't do full
+  #   automatic resolves like Bundler:
+  #   [how-does-bundler-bundle](http://patshaughnessy.net/2011/9/24/how-does-bundler-bundle)
+  #
+  # @todo Another limitation is that the order of the dependencies matter. The
+  #   current implementation could create issues, for example, if a
+  #   specification is loaded for a target definition and later for another
+  #   target is set in head mode. The first specification will not be in head
+  #   mode.
+  #
+  #
+  class Resolver
 
-    # @return [Sandbox] The Sandbox used by the resolver to find external
-    #   dependencies.
+    # @return [Sandbox] the Sandbox used by the resolver to find external
+    #         dependencies.
     #
     attr_reader :sandbox
 
-    # @return [Array<Strings>] The name of the pods that have an
-    #   external source.
+    # @return [Podfile] the Podfile used by the resolver.
     #
-    attr_reader :pods_from_external_sources
+    attr_reader :podfile
 
-    # @return [Array<Set>] A cache of the sets used to resolve the dependencies.
+    # @return [Array<Dependency>] the list of dependencies locked to a specific
+    #         version.
     #
-    attr_reader :cached_sets
+    attr_reader :locked_dependencies
 
-    # @return [Source::Aggregate] A cache of the sources needed to find the
-    #   podspecs.
+    # @param  [Sandbox] sandbox @see sandbox
+    # @param  [Podfile] podfile @see podfile
+    # @param  [Array<Dependency>] locked_dependencies @see locked_dependencies
     #
-    attr_reader :cached_sources
+    def initialize(sandbox, podfile, locked_dependencies = [])
+      @sandbox = sandbox
+      @podfile = podfile
+      @locked_dependencies = locked_dependencies
+    end
 
-    # @return [Hash{Podfile::TargetDefinition => Array<Specification>}]
-    #   Returns the resolved specifications grouped by target.
-    #
-    attr_reader :specs_by_target
+    #-------------------------------------------------------------------------#
 
-    def initialize(podfile, lockfile, sandbox)
-      @podfile  = podfile
-      @lockfile = lockfile
-      @sandbox  = sandbox
-      @update_external_specs = true
+    public
 
-      @cached_sets = {}
-      @cached_sources = Source::Aggregate.new
-    end
+    # @!group Resolution
 
-    # Identifies the specifications that should be installed according whether
-    #   the resolver is in update mode or not.
+    # Identifies the specifications that should be installed.
     #
-    # @return [Hash{Podfile::TargetDefinition => Array<Specification>}] specs_by_target
+    # @return [Hash{TargetDefinition => Array<Specification>}] specs_by_target
+    #         the specifications that need to be installed grouped by target
+    #         definition.
     #
     def resolve
-      @cached_specs = {}
+      @cached_sources  = SourcesManager.aggregate
+      @cached_sets     = {}
+      @cached_specs    = {}
       @specs_by_target = {}
-      @pods_from_external_sources = []
-      @pods_to_lock = []
-
-      if @lockfile
-        @pods_by_state = @lockfile.detect_changes_with_podfile(podfile)
-        UI.section "Finding added, modified or removed dependencies:" do
-          marks = {:added => "A".green, :changed => "M".yellow, :removed => "R".red, :unchanged => "-" }
-          @pods_by_state.each do |symbol, pod_names|
-            pod_names.each do |pod_name|
-              UI.message("#{marks[symbol]} #{pod_name}", '',2)
-            end
-          end
-        end if config.verbose?
-        @pods_to_lock = (lockfile.pods_names - @pods_by_state[:added] - @pods_by_state[:changed] - @pods_by_state[:removed]).uniq
-      end
-
-      unless config.skip_repo_update?
-        UI.section 'Updating spec repositories' do
-          Command::Repo.new(Command::ARGV.new(["update"])).run
-        end if !@lockfile || !(@pods_by_state[:added] + @pods_by_state[:changed]).empty? || update_mode
-      end
 
-      @podfile.target_definitions.values.each do |target_definition|
-        UI.section "Resolving dependencies for target `#{target_definition.name}' (#{target_definition.platform})" do
+      target_definitions = podfile.target_definitions.values.sort_by{ |td| td.name.to_s }
+      target_definitions.each do |target|
+        UI.section "Resolving dependencies for target `#{target.name}' (#{target.platform})" do
           @loaded_specs = []
-          find_dependency_specs(@podfile, target_definition.dependencies, target_definition)
-          @specs_by_target[target_definition] = @cached_specs.values_at(*@loaded_specs).sort_by(&:name)
+          find_dependency_specs(podfile, target.dependencies, target)
+          specs = cached_specs.values_at(*@loaded_specs).sort_by(&:name)
+          specs_by_target[target] = specs
         end
       end
 
-      @cached_specs.values.sort_by(&:name)
-      @specs_by_target
+      cached_specs.values.sort_by(&:name)
+      specs_by_target
     end
 
-    # @return [Array<Specification>] The specifications loaded by the resolver.
+    # @return [Hash{Podfile::TargetDefinition => Array<Specification>}]
+    #         returns the resolved specifications grouped by target.
     #
-    def specs
-      @cached_specs.values.uniq
-    end
+    # @note   The returned specifications can be subspecs.
+    #
+    attr_reader :specs_by_target
 
-    # @return [Bool] Whether a pod should be installed/reinstalled.
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@ Resolution context
+
+    # @return [Source::Aggregate] A cache of the sources needed to find the
+    #         podspecs.
     #
-    def should_install?(name)
-      pods_to_install.include? name
-    end
+    # @note   The sources are cached because frequently accessed by the
+    #         resolver and loading them requires disk activity.
+    #
+    attr_accessor :cached_sources
 
-    # @return [Array<Strings>] The name of the pods that should be
-    #   installed/reinstalled.
-    #
-    def pods_to_install
-      unless @pods_to_install
-        if lockfile
-          @pods_to_install = specs.select do |spec|
-            spec.version != lockfile.pods_versions[spec.pod_name]
-          end.map(&:name)
-          if update_mode
-            @pods_to_install += specs.select do |spec|
-              spec.version.head? || pods_from_external_sources.include?(spec.pod_name)
-            end.map(&:name)
-          end
-          @pods_to_install += @pods_by_state[:added] + @pods_by_state[:changed]
-        else
-          @pods_to_install = specs.map(&:name)
-        end
-      end
-      @pods_to_install
-    end
+    # @return [Hash<String => Set>] A cache that keeps tracks of the sets
+    #         loaded by the resolution process.
+    #
+    # @note   Sets store the resolved dependencies and return the highest
+    #         available specification found in the sources. This is done
+    #         globally and not per target definition because there can be just
+    #         one Pod installation, so different version of the same Pods for
+    #         target definitions are not allowed.
+    #
+    attr_accessor :cached_sets
 
-    # @return [Array<Strings>] The name of the pods that were installed
-    #   but don't have any dependency anymore. The name of the Pods are
-    #   stripped from subspecs.
+    # @return [Hash<String => Specification>] The loaded specifications grouped
+    #         by name.
     #
-    def removed_pods
-      return [] unless lockfile
-      unless @removed_pods
-        previously_installed = lockfile.pods_names.map { |pod_name| pod_name.split('/').first }
-        installed = specs.map { |spec| spec.name.split('/').first }
-        @removed_pods = previously_installed - installed
-      end
-      @removed_pods
-    end
+    attr_accessor :cached_specs
+
+    #-------------------------------------------------------------------------#
 
     private
 
-    # @return [Set] The cached set for a given dependency.
-    #
-    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
-          if update_mode && update_external_specs
-            # Always update external sources in update mode.
-            specification = external_source.specification_from_external(@sandbox, platform)
-          else
-            # Don't update external sources in install mode if not needed.
-            specification = external_source.specification_from_sandbox(@sandbox, platform)
-          end
-          set = Specification::Set::External.new(specification)
-          if dependency.subspec_dependency?
-            @cached_sets[dependency.top_level_spec_name] ||= set
-          end
-          set
-        else
-          @cached_sources.search(dependency)
-        end
-      end
-    end
+    # @!group Private helpers
 
-    # Resolves the dependencies of a specification and stores them in @cached_specs
+    # Resolves recursively the dependencies of a specification and stores them
+    # in the @cached_specs ivar.
+    #
+    # @param  [Podfile, Specification, #to_s] dependent_spec
+    #         the specification whose dependencies are being resolved. Used
+    #         only for UI purposes.
+    #
+    # @param  [Array<Dependency>] dependencies
+    #         the dependencies of the specification.
     #
-    # @param [Specification] dependent_specification
-    # @param [Array<Dependency>] dependencies
-    # @param [TargetDefinition] target_definition
+    # @param  [TargetDefinition] target_definition
+    #         the target definition that owns the specification.
+    #
+    # @note   If there is a locked dependency with the same name of a
+    #         given dependency the locked one is used in place of the
+    #         dependency of the specification. In this way it is possible to
+    #         prevent the update of the version of installed pods not changed
+    #         in the Podfile.
+    #
+    # @note   The recursive process checks if a dependency has already been
+    #         loaded to prevent an infinite loop.
+    #
+    # @note   The set class merges all (of all the target definitions) the
+    #         dependencies and thus it keeps track of whether it is in head
+    #         mode or from an external source because {Dependency#merge}
+    #         preserves this information.
     #
     # @return [void]
     #
-    def find_dependency_specs(dependent_specification, dependencies, target_definition)
+    def find_dependency_specs(dependent_spec, dependencies, target_definition)
       dependencies.each do |dependency|
-        # Replace the dependency with a more specific one if the pod is already installed.
-        if !update_mode && @pods_to_lock.include?(dependency.name)
-          dependency = lockfile.dependency_for_installed_pod_named(dependency.name)
-        end
+        locked_dep = locked_dependencies.find { |ld| ld.name == dependency.name }
+        dependency = locked_dep if locked_dep
+
         UI.message("- #{dependency}", '', 2) do
-          set = find_cached_set(dependency, target_definition.platform)
-          set.required_by(dependency, dependent_specification.to_s)
+          set = find_cached_set(dependency)
+          set.required_by(dependency, dependent_spec.to_s)
 
-          # 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)
-            @pods_from_external_sources << spec.pod_name if dependency.external?
+            spec = set.specification.subspec_by_name(dependency.name)
             @loaded_specs << spec.name
-            @cached_specs[spec.name] = spec
-            # Configure the specification
-            spec.activate_platform(target_definition.platform)
+            cached_specs[spec.name] = spec
+            validate_platform(spec, target_definition)
             spec.version.head = dependency.head?
-            # And recursively load the dependencies of the spec.
-            find_dependency_specs(spec, spec.dependencies, target_definition) if spec.dependencies
+
+            spec_dependencies = spec.all_dependencies(target_definition.platform)
+            find_dependency_specs(spec, spec_dependencies, target_definition)
           end
-          validate_platform(spec || @cached_specs[dependency.name], target_definition)
         end
       end
     end
 
-    # Ensures that a spec is compatible with the platform of a target.
+    # Loads or returns a previously initialized for the Pod of the given
+    # dependency.
+    #
+    # @param  [Dependency] dependency
+    #         the dependency for which the set is needed.
     #
-    # @raises If the spec is not supported by the target.
+    # @return [Set] the cached set for a given dependency.
+    #
+    def find_cached_set(dependency)
+      name = dependency.root_name
+      unless cached_sets[name]
+        if dependency.external_source
+          spec = sandbox.specification(dependency.root_name)
+          unless spec
+            raise StandardError, "[Bug] Unable to find the specification for `#{dependency}`."
+          end
+          set = Specification::Set::External.new(spec)
+        else
+          set = cached_sources.search(dependency)
+        end
+        cached_sets[name] = set
+      end
+      cached_sets[name]
+    end
+
+    # Ensures that a specification is compatible with the platform of a target.
+    #
+    # @raise  If the specification is not supported by the target.
+    #
+    # @return [void]
     #
     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
+      unless spec.available_platforms.any? { |p| target.platform.supports?(p) }
+        raise Informative, "The platform of the target `#{target.name}` "     \
+          "(#{target.platform}) is not compatible with `#{spec}` which has "  \
+          "a minimum requirement of #{spec.available_platforms.join(' - ')}."
       end
     end
   end

data/lib/cocoapods/sandbox.rb

@@ -1,105 +1,327 @@
 require 'fileutils'
 
 module Pod
+
+  # The sandbox provides support for the directory that CocoaPods uses for an
+  # installation. In this directory the Pods projects, the support files and
+  # the sources of the Pods are stored.
+  #
+  # CocoaPods assumes to have control of the sandbox.
+  #
+  # Once completed the sandbox will have the following file structure:
+  #
+  #     Pods
+  #     |
+  #     +-- Headers
+  #     |   +-- Private
+  #     |   |   +-- [Pod Name]
+  #     |   +-- Public
+  #     |       +-- [Pod Name]
+  #     |
+  #     +-- Sources
+  #     |   +-- [Pod Name]
+  #     |
+  #     +-- Specifications
+  #     |   +-- External Sources
+  #     |   +-- Normal Sources
+  #     |
+  #     +-- Target Support Files
+  #     |   +-- [Target Name]
+  #     |       +-- Acknowledgements.markdown
+  #     |       +-- Acknowledgements.plist
+  #     |       +-- Pods.xcconfig
+  #     |       +-- Pods-prefix.pch
+  #     |       +-- Pods-dummy_Pods.m
+  #     |
+  #     +-- Manifest.lock
+  #     |
+  #     +-- Pods.xcodeproj
+  #
   class Sandbox
+
+    autoload :FileAccessor, 'cocoapods/sandbox/file_accessor'
+    autoload :HeadersStore, 'cocoapods/sandbox/headers_store'
+    autoload :PathList,     'cocoapods/sandbox/path_list'
+
+    # @return [Pathname] the root of the sandbox.
+    #
     attr_reader :root
+
+    # @return [HeadersStore] the header directory for the Pods libraries.
+    #
     attr_reader :build_headers
-    attr_reader :public_headers
 
-    BUILD_HEADERS_DIR = "BuildHeaders"
-    PUBLIC_HEADERS_DIR = "Headers"
+    # @return [HeadersStore] the header directory for the user targets.
+    #
+    attr_reader :public_headers
 
-    def initialize(path)
-      @root = Pathname.new(path)
-      @build_headers = HeadersDirectory.new(self, BUILD_HEADERS_DIR)
-      @public_headers = HeadersDirectory.new(self, PUBLIC_HEADERS_DIR)
-      @cached_local_pods = {}
-      @cached_locally_sourced_pods = {}
+    # @param [String, Pathname] root @see root
+    #
+    def initialize(root)
+      @root = Pathname.new(root)
+      @build_headers  = HeadersStore.new(self, "BuildHeaders")
+      @public_headers = HeadersStore.new(self, "Headers")
+      @predownloaded_pods = []
+      @checkout_sources = {}
+      @local_pods = {}
       FileUtils.mkdir_p(@root)
     end
 
+    # @return [Lockfile] the manifest which contains the information about the
+    #         installed pods.
+    #
+    def manifest
+      Lockfile.from_file(manifest_path) if manifest_path.exist?
+    end
+
+    # @return [Project] the Pods project.
+    #
+    attr_accessor :project
+
+    # Removes the sandbox.
+    #
+    # @return [void]
+    #
     def implode
       root.rmtree
     end
 
+    #
+    #
+    #
+    def clean_pod(name)
+      root_name = Specification.root_name(name)
+      unless local?(root_name)
+        path = pod_dir(name)
+        path.rmtree if path.exist?
+      end
+      podspe_path = specification_path(name)
+      podspe_path.rmtree if podspe_path
+    end
+
+    # @return [String] a string representation suitable for debugging.
+    #
+    def inspect
+      "#<#{self.class}> with root #{root}"
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Paths
+
+    # @return [Pathname] the path of the manifest.
+    #
+    def manifest_path
+      root + "Manifest.lock"
+    end
+
+    # @return [Pathname] the path of the Pods project.
+    #
     def project_path
       root + "Pods.xcodeproj"
     end
 
-    def prepare_for_install
-      build_headers.prepare_for_install
-      public_headers.prepare_for_install
+    # Returns the path for the directory where to store the support files of
+    # a target.
+    #
+    # @param  [String] name
+    #         The name of the target.
+    #
+    # @return [Pathname] the path of the support files.
+    #
+    def library_support_files_dir(name)
+      # root + "Target Support Files/#{name}"
+      root
     end
 
-    def local_pod_for_spec(spec, platform)
-      key = [spec.top_level_parent.name, platform.to_sym]
-      (@cached_local_pods[key] ||= LocalPod.new(spec.top_level_parent, self, platform)).tap do |pod|
-        pod.add_specification(spec)
+    # Returns the path where the Pod with the given name is stored, taking into
+    # account whether the Pod is locally sourced.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [Pathname] the path of the Pod.
+    #
+    def pod_dir(name)
+      root_name = Specification.root_name(name)
+      if local?(root_name)
+        Pathname.new(local_pods[root_name])
+      else
+        # root + "Sources/#{name}"
+        root + root_name
       end
     end
 
-    # TODO: refactor the pods from a local source should not be chached by the sandbox
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Specification store
+
+    # Returns the specification for the Pod with the given name.
+    #
+    # @param  [String] name
+    #         the name of the Pod for which the specification is requested.
     #
-    def locally_sourced_pod_for_spec(spec, platform)
-      key = [spec.top_level_parent.name, platform.to_sym]
-      (@cached_locally_sourced_pods[key] ||= LocalPod::LocalSourcedPod.new(spec.top_level_parent, self, platform)).tap do |pod|
-        pod.add_specification(spec)
+    # @return [Specification] the specification if the file is found.
+    #
+    def specification(name)
+      if file = specification_path(name)
+        Specification.from_file(file)
       end
     end
 
-    def installed_pod_named(name, platform)
-      if spec_path = podspec_for_name(name)
-        key = [name, platform.to_sym]
-        @cached_local_pods[key] ||= LocalPod.from_podspec(spec_path, self, platform)
-      end
+    # @return [Pathname] the path for the directory where to store the
+    #         specifications.
+    #
+    # @todo   Migrate old installations and store the for all the pods.
+    #         Two folders should be created `External Sources` and `Podspecs`.
+    #
+    def specifications_dir(external_source = false)
+      # root + "Specifications"
+      root + "Local Podspecs"
     end
 
-    def podspec_for_name(name)
-      path = root + "Local Podspecs/#{name}.podspec"
+    # Returns the path of the specification for the Pod with the
+    # given name, if one is stored.
+    #
+    # @param  [String] name
+    #         the name of the Pod for which the podspec file is requested.
+    #
+    # @return [Pathname] the path or nil.
+    # @return [Nil] if the podspec is not stored.
+    #
+    def specification_path(name)
+      path = specifications_dir + "#{name}.podspec"
       path.exist? ? path : nil
     end
-  end
 
-  class HeadersDirectory
-    def initialize(sandbox, base_dir)
-      @sandbox = sandbox
-      @base_dir = base_dir
-      @search_paths = [base_dir]
+    # Stores a specification in the `Local Podspecs` folder.
+    #
+    # @param  [Sandbox] sandbox
+    #         the sandbox where the podspec should be stored.
+    #
+    # @param  [String, Pathname] podspec
+    #         The contents of the specification (String) or the path to a
+    #         podspec file (Pathname).
+    #
+    # @todo   Store all the specifications (including those not originating
+    #         from external sources) so users can check them.
+    #
+    def store_podspec(name, podspec, external_source = false)
+      output_path = specifications_dir(external_source) + "#{name}.podspec"
+      output_path.dirname.mkpath
+      if podspec.is_a?(String)
+        output_path.open('w') { |f| f.puts(podspec) }
+      else
+        unless podspec.exist?
+          raise Informative, "No podspec found for `#{name}` in #{podspec}"
+        end
+        FileUtils.copy(podspec, output_path)
+      end
+      spec = Specification.from_file(output_path)
+      unless spec.name == name
+        raise Informative, "The name of the given podspec `#{spec.name}` doesn't match the expected one `#{name}`"
+      end
     end
 
-    def root
-      @sandbox.root + @base_dir
-    end
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Pods information
 
-    def add_file(namespace_path, relative_header_path)
-      namespaced_header_path = root + namespace_path
-      namespaced_header_path.mkpath unless File.exist?(namespaced_header_path)
-      source = (@sandbox.root + relative_header_path).relative_path_from(namespaced_header_path)
-      Dir.chdir(namespaced_header_path) { FileUtils.ln_sf(source, relative_header_path.basename)}
-      @search_paths << namespaced_header_path.relative_path_from(@sandbox.root)
-      namespaced_header_path + relative_header_path.basename
+    # Marks a Pod as pre-downloaded
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [void]
+    #
+    def store_pre_downloaded_pod(name)
+      root_name = Specification.root_name(name)
+      predownloaded_pods << root_name
     end
 
-    def add_files(namespace_path, relative_header_paths)
-      relative_header_paths.map { |path| add_file(namespace_path, path) }
+    # @return [Array<String>] The names of the pods that have been
+    #         pre-downloaded from an external source.
+    #
+    attr_reader :predownloaded_pods
+
+    # Checks if a Pod has been pre-downloaded by the resolver in order to fetch
+    # the podspec.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [Bool] Whether the Pod has been pre-downloaded.
+    #
+    def predownloaded?(name)
+      root_name = Specification.root_name(name)
+      predownloaded_pods.include?(root_name)
     end
 
-    def search_paths
-      @search_paths.uniq.map { |path| "${PODS_ROOT}/#{path}" }
+    #--------------------------------------#
+
+    # Stores the local path of a Pod.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @param  [Hash] source
+    #         The hash which contains the options as returned by the
+    #         downloader.
+    #
+    # @return [void]
+    #
+    def store_checkout_source(name, source)
+      root_name = Specification.root_name(name)
+      checkout_sources[root_name] = source
     end
 
-    # Adds an header search path to the sandbox.
+    # @return [Hash{String=>Hash}] The options necessary to recreate the exact
+    #         checkout of a given Pod grouped by its name.
+    #
+    attr_reader :checkout_sources
+
+    #--------------------------------------#
+
+    # Stores the local path of a Pod.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
     #
-    # @param path [Pathname] The path tho add.
+    # @param  [#to_s] path
+    #         The local path where the Pod is stored.
     #
     # @return [void]
     #
-    def add_search_path(path)
-      @search_paths << Pathname.new(@base_dir) + path
+    def store_local_path(name, path)
+      root_name = Specification.root_name(name)
+      local_pods[root_name] = path.to_s
     end
 
-    def prepare_for_install
-      root.rmtree if root.exist?
+    # @return [Hash{String=>String}] The path of the Pods with a local source
+    #         grouped by their name.
+    #
+    attr_reader :local_pods
+
+    # Checks if a Pod is locally sourced?
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [Bool] Whether the Pod is locally sourced.
+    #
+    def local?(name)
+      root_name = Specification.root_name(name)
+      !local_pods[root_name].nil?
     end
+
+    #-------------------------------------------------------------------------#
+
   end
 end
+