cocoapods-square-stable 0.19.3

data/lib/cocoapods/project.rb

@@ -0,0 +1,209 @@
+require 'xcodeproj'
+
+module Pod
+
+  # The Pods project.
+  #
+  # Model class which provides helpers for working with the Pods project
+  # through the installation process.
+  #
+  class Project < Xcodeproj::Project
+
+    # @return [Pathname] the path of the xcodeproj file which stores the
+    #         project.
+    #
+    attr_reader :path
+
+    # @param  [Sandbox] sandbox @see #sandbox
+    #
+    def initialize(path = nil)
+      super(nil) # Recreate the project from scratch for now.
+      @path = path
+      @support_files_group = new_group('Targets Support Files')
+
+      @refs_by_absolute_path = {}
+    end
+
+    # @return [Pathname] the path of the xcodeproj file which stores the
+    #         project.
+    #
+    attr_reader :path
+
+    # @return [Pathname] the directory where the project is stored.
+    #
+    def root
+      @root ||= path.dirname
+    end
+
+    # @return [Pathname] Returns the relative path from the project root.
+    #
+    # @param  [Pathname] path
+    #         The path that needs to be converted to the relative format.
+    #
+    # @note   If the two absolute paths don't share the same root directory an
+    #         extra `../` is added to the result of
+    #         {Pathname#relative_path_from}.
+    #
+    # @example
+    #
+    #   path = Pathname.new('/Users/dir')
+    #   @sandbox.root #=> Pathname('/tmp/CocoaPods/Lint/Pods')
+    #
+    #   @sandbox.relativize(path) #=> '../../../../Users/dir'
+    #   @sandbox.relativize(path) #=> '../../../../../Users/dir'
+    #
+    def relativize(path)
+      unless path.absolute?
+        raise StandardError, "[Bug] Attempt to add relative path `#{path}` to the Pods project"
+      end
+
+      result = path.relative_path_from(root)
+      unless root.to_s.split('/')[1] == path.to_s.split('/')[1]
+        result = Pathname.new('../') + result
+      end
+      result
+    end
+
+    # @return [String] a string representation suited for debugging.
+    #
+    def inspect
+      "#<#{self.class}> path:#{path}"
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Groups
+
+    # @return [PBXGroup] the group where the support files for the Pod
+    #         libraries should be added.
+    #
+    attr_reader :support_files_group
+
+    # Returns the `Pods` group, creating it if needed.
+    #
+    # @return [PBXGroup] the group.
+    #
+    def pods
+      @pods ||= new_group('Pods')
+    end
+
+    # Returns the `Local Pods` group, creating it if needed. This group is used
+    # to contain locally sourced pods.
+    #
+    # @return [PBXGroup] the group.
+    #
+    def local_pods
+      @local_pods ||= new_group('Local Pods')
+    end
+
+    # Returns the `Local Pods` group, creating it if needed. This group is used
+    # to contain locally sourced pods.
+    #
+    # @return [PBXGroup] the group.
+    #
+    def resources
+      @resources ||= new_group('Resources')
+    end
+
+    # Adds a group as child to the `Pods` group namespacing subspecs.
+    #
+    # @param  [String] spec_name
+    #         The full name of the specification.
+    #
+    # @param  [PBXGroup] root_group
+    #         The group where to add the specification. Either `Pods` or `Local
+    #         Pods`.
+    #
+    # @return [PBXGroup] the group for the spec with the given name.
+    #
+    def add_spec_group(spec_name, root_group)
+      current_group = root_group
+      group = nil
+      spec_name.split('/').each do |name|
+        group = current_group[name] || current_group.new_group(name)
+        current_group = group
+      end
+      group
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group File references
+
+    # Adds a file reference for each one of the given files in the specified
+    # group, namespaced by specification unless a file reference for the given
+    # path already exits.
+    #
+    # @note   With this set-up different subspecs might not reference the same
+    #         file (i.e. the first will win). Not sure thought if this is a
+    #         limitation or a feature.
+    #
+    # @param  [Array<Pathname,String>] paths
+    #         The files for which the file reference is needed.
+    #
+    # @param  [String] spec_name
+    #         The full name of the specification.
+    #
+    # @param  [PBXGroup] parent_group
+    #         The group where the file references should be added.
+    #
+    # @return [void]
+    #
+    def add_file_references(absolute_path, spec_name, parent_group)
+      group = add_spec_group(spec_name, parent_group)
+      absolute_path.each do |file|
+        existing = file_reference(file)
+        unless existing
+          file = Pathname.new(file)
+          ref = group.new_file(relativize(file))
+          @refs_by_absolute_path[file] = ref
+        end
+      end
+    end
+
+    # Returns the file reference for the given absolute file path.
+    #
+    # @param  [Pathname,String] absolute_path
+    #         The absolute path of the file whose reference is needed.
+    #
+    # @return [PBXFileReference] The file reference.
+    # @return [Nil] If no file reference could be found.
+    #
+    def file_reference(absolute_path)
+      absolute_path = Pathname.new(absolute_path)
+      refs_by_absolute_path[absolute_path]
+    end
+
+    # Adds a file reference to the podfile.
+    #
+    # @param  [Pathname,String] podfile_path
+    #         the path of the podfile
+    #
+    # @return [PBXFileReference] the file reference.
+    #
+    def add_podfile(podfile_path)
+      podfile_path = Pathname.new(podfile_path)
+      podfile_ref  = new_file(relativize(podfile_path))
+      podfile_ref.xc_language_specification_identifier = 'xcode.lang.ruby'
+      podfile_ref
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # @!group Private helpers
+
+    # @return [Hash{Pathname => PBXFileReference}] The file references grouped
+    #         by absolute path.
+    #
+    attr_reader :refs_by_absolute_path
+
+    #-------------------------------------------------------------------------#
+
+  end
+end

data/lib/cocoapods/resolver.rb

@@ -0,0 +1,212 @@
+module Pod
+
+  # 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.
+    #
+    attr_reader :sandbox
+
+    # @return [Podfile] the Podfile used by the resolver.
+    #
+    attr_reader :podfile
+
+    # @return [Array<Dependency>] the list of dependencies locked to a specific
+    #         version.
+    #
+    attr_reader :locked_dependencies
+
+    # @param  [Sandbox] sandbox @see sandbox
+    # @param  [Podfile] podfile @see podfile
+    # @param  [Array<Dependency>] locked_dependencies @see locked_dependencies
+    #
+    def initialize(sandbox, podfile, locked_dependencies = [])
+      @sandbox = sandbox
+      @podfile = podfile
+      @locked_dependencies = locked_dependencies
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Resolution
+
+    # Identifies the specifications that should be installed.
+    #
+    # @return [Hash{TargetDefinition => Array<Specification>}] specs_by_target
+    #         the specifications that need to be installed grouped by target
+    #         definition.
+    #
+    def resolve
+      @cached_sources  = SourcesManager.aggregate
+      @cached_sets     = {}
+      @cached_specs    = {}
+      @specs_by_target = {}
+
+      target_definitions = podfile.target_definition_list
+      target_definitions.each do |target|
+        UI.section "Resolving dependencies for target `#{target.name}' (#{target.platform})" do
+          @loaded_specs = []
+          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
+    end
+
+    # @return [Hash{Podfile::TargetDefinition => Array<Specification>}]
+    #         returns the resolved specifications grouped by target.
+    #
+    # @note   The returned specifications can be subspecs.
+    #
+    attr_reader :specs_by_target
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@ Resolution context
+
+    # @return [Source::Aggregate] A cache of the sources needed to find the
+    #         podspecs.
+    #
+    # @note   The sources are cached because frequently accessed by the
+    #         resolver and loading them requires disk activity.
+    #
+    attr_accessor :cached_sources
+
+    # @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 [Hash<String => Specification>] The loaded specifications grouped
+    #         by name.
+    #
+    attr_accessor :cached_specs
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # @!group Private helpers
+
+    # 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  [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_spec, dependencies, target_definition)
+      dependencies.each do |dependency|
+        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)
+          set.required_by(dependency, dependent_spec.to_s)
+
+          unless @loaded_specs.include?(dependency.name)
+            spec = set.specification.subspec_by_name(dependency.name)
+            @loaded_specs << spec.name
+            cached_specs[spec.name] = spec
+            validate_platform(spec, target_definition)
+            spec.version.head = dependency.head?
+
+            spec_dependencies = spec.all_dependencies(target_definition.platform)
+            find_dependency_specs(spec, spec_dependencies, target_definition)
+          end
+        end
+      end
+    end
+
+    # Loads or returns a previously initialized for the Pod of the given
+    # dependency.
+    #
+    # @param  [Dependency] dependency
+    #         the dependency for which the set is needed.
+    #
+    # @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
+        unless set
+          raise Informative, "Unable to find a specification for `#{dependency}`."
+        end
+      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? { |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
+end

data/lib/cocoapods/sandbox.rb

@@ -0,0 +1,343 @@
+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
+  #     |
+  #     +-- User
+  #     | +-- [Target Name]-configuration.h
+  #     | +-- Specs
+  #     | +-- Scripts
+  #     |
+  #     +-- Generated
+  #       +-- Headers
+  #       |   +-- Private
+  #       |   |   +-- [Pod Name]
+  #       |   +-- Public
+  #       |       +-- [Pod Name]
+  #       |
+  #       +-- Sources
+  #       |   +-- [Pod Name]
+  #       |
+  #       +-- Specs
+  #       |   +-- External Sources
+  #       |   +-- Normal Sources
+  #       |
+  #       +-- Target Support Files
+  #       |   +-- [Target Name]
+  #       |       +-- Pods-acknowledgements.markdown
+  #       |       +-- Pods-acknowledgements.plist
+  #       |       +-- Pods-dummy.m
+  #       |       +-- Pods-prefix.pch
+  #       |       +-- Pods.xcconfig
+  #       |
+  #       +-- Manifest.lock
+  #       |
+  #       +-- Pods.xcodeproj
+  #
+  # See #833
+  #
+  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
+
+    # @return [HeadersStore] the header directory for the user targets.
+    #
+    attr_reader :public_headers
+
+    # @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
+
+    # 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
+
+    # 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
+
+    # @return [Pathname] the directory where to store the documentation.
+    #
+    def documentation_dir
+      root + 'Documentation'
+    end
+
+    #-------------------------------------------------------------------------#
+
+    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.
+    #
+    # @return [Specification] the specification if the file is found.
+    #
+    def specification(name)
+      if file = specification_path(name)
+        Specification.from_file(file)
+      end
+    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
+
+    # 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
+
+    # 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
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Pods information
+
+    # 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
+
+    # @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
+
+    #--------------------------------------#
+
+    # 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
+
+    # @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  [#to_s] path
+    #         The local path where the Pod is stored.
+    #
+    # @return [void]
+    #
+    def store_local_path(name, path)
+      root_name = Specification.root_name(name)
+      local_pods[root_name] = path.to_s
+    end
+
+    # @return [Hash{String=>String}] The path of the Pods with a local source
+    #         grouped by their name.
+    #
+    # @todo   Rename (e.g. `pods_with_local_path`)
+    #
+    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
+