cocoapods-square-stable 0.19.3

data/lib/cocoapods/config.rb

@@ -0,0 +1,231 @@
+module Pod
+
+  # Stores the global configuration of CocoaPods.
+  #
+  class Config
+
+    # The default settings for the configuration.
+    #
+    # Users can specify custom settings in `~/.cocoapods/config.yaml`.
+    # An example of the contents of this file might look like:
+    #
+    #     ---
+    #     skip_repo_update: true
+    #     new_version_message: false
+    #
+    DEFAULTS = {
+      :verbose             => false,
+      :silent              => false,
+      :skip_repo_update    => false,
+      :aggressive_cache    => false,
+
+      :clean               => true,
+      :integrate_targets   => true,
+      :new_version_message => true,
+    }
+
+    #--------------------------------------#
+
+    # @!group UI
+
+    # @return [Bool] Whether CocoaPods should provide detailed output about the
+    #         performed actions.
+    #
+    attr_accessor :verbose
+    alias_method  :verbose?, :verbose
+
+    # @return [Bool] Whether CocoaPods should produce not output.
+    #
+    attr_accessor :silent
+    alias_method  :silent?, :silent
+
+    # @return [Bool] Whether a message should be printed when a new version of 
+    #         CocoaPods is available.
+    #
+    attr_accessor :new_version_message
+    alias_method  :new_version_message?, :new_version_message
+
+    #--------------------------------------#
+
+    # @!group Installation
+
+    # @return [Bool] Whether the installer should clean after the installation.
+    #
+    attr_accessor :clean
+    alias_method  :clean?, :clean
+
+    # @return [Bool] Whether CocoaPods should integrate a user target and build
+    #         the workspace or just create the Pods project.
+    #
+    attr_accessor :integrate_targets
+    alias_method  :integrate_targets?, :integrate_targets
+
+
+    # @return [Bool] Whether the installer should skip the repos update.
+    #
+    attr_accessor :skip_repo_update
+    alias_method  :skip_repo_update?, :skip_repo_update
+
+    # Allows to set whether the downloader should use more aggressive caching
+    # options.
+    #
+    # @note The aggressive cache has lead to issues if a tag is updated to
+    #       point to another commit.
+    #
+    attr_writer :aggressive_cache
+
+    # @return [Bool] Whether the downloader should use more aggressive caching
+    #         options.
+    #
+    def aggressive_cache?
+      @aggressive_cache || (ENV['CP_AGGRESSIVE_CACHE'] != 'FALSE')
+    end
+
+    #--------------------------------------#
+
+    # @!group Initialization
+
+    def initialize
+      configure_with(DEFAULTS)
+
+      if user_settings_file.exist?
+        require 'yaml'
+        user_settings = YAML.load_file(user_settings_file)
+        configure_with(user_settings)
+      end
+    end
+
+    def verbose
+      @verbose && !silent
+    end
+
+    #--------------------------------------#
+
+    # @!group Paths
+
+    # @return [Pathname] the directory where the CocoaPods sources are stored.
+    #
+    def repos_dir
+      @repos_dir ||= Pathname.new(ENV['CP_REPOS_DIR'] || "~/.cocoapods").expand_path
+    end
+
+    attr_writer :repos_dir
+
+    # @return [Pathname] the root of the CocoaPods installation where the
+    #         Podfile is located.
+    #
+    def installation_root
+      @installation_root ||= Pathname.pwd
+    end
+
+    attr_writer :installation_root
+    alias :project_root :installation_root
+
+    # @return [Pathname] The root of the sandbox.
+    #
+    def sandbox_root
+      @sandbox_root ||= installation_root + 'Pods'
+    end
+
+    attr_writer :sandbox_root
+    alias :project_pods_root :sandbox_root
+
+    # @return [Sandbox] The sandbox of the current project.
+    #
+    def sandbox
+      @sandbox ||= Sandbox.new(sandbox_root)
+    end
+
+    # @return [Podfile] The Podfile to use for the current execution.
+    #
+    def podfile
+      @podfile ||= Podfile.from_file(podfile_path) if podfile_path.exist?
+    end
+    attr_writer :podfile
+
+    # @return [Lockfile] The Lockfile to use for the current execution.
+    #
+    def lockfile
+      @lockfile ||= Lockfile.from_file(lockfile_path) if lockfile_path.exist?
+    end
+
+    #--------------------------------------#
+
+    # @!group Helpers
+
+    # private
+
+    # @return [Pathname] The path of the file which contains the user settings.
+    #
+    def user_settings_file
+      repos_dir + "config.yaml"
+    end
+
+    # Sets the values of the attributes with the given hash.
+    #
+    # @param  [Hash{String,Symbol => Object}] values_by_key
+    #         The values of the attributes grouped by key.
+    #
+    # @return [void]
+    #
+    def configure_with(values_by_key)
+      return unless values_by_key
+      values_by_key.each do |key, value|
+        self.instance_variable_set("@#{key}", value)
+      end
+    end
+
+    # Returns the path of the Podfile.
+    #
+    # @note The Podfile can be named either `CocoaPods.podfile` or `Podfile`.
+    #       The first is preferred as it allows to specify an OS X UTI.
+    #
+    def podfile_path
+      unless @podfile_path
+        path = installation_root + 'CocoaPods.podfile.yaml'
+        path = installation_root + 'CocoaPods.podfile' unless path.exist?
+        path = installation_root + 'Podfile' unless path.exist?
+        @podfile_path = path
+      end
+      @podfile_path
+    end
+
+    # Returns the path of the Lockfile.
+    #
+    # @note The Lockfile is named `Podfile.lock`.
+    #
+    def lockfile_path
+      @lockfile_path ||= installation_root + 'Podfile.lock'
+    end
+
+    #--------------------------------------#
+
+    # @return [Config] the current config instance creating one if needed.
+    #
+    def self.instance
+      @instance ||= new
+    end
+
+    # Sets the current config instance. If set to nil the config will be
+    # recreated when needed.
+    #
+    # @param  [Config, Nil] the instance.
+    #
+    # @return [void]
+    #
+    def self.instance=(instance)
+      @instance = instance
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Provides support for accessing the configuration instance in other
+    # scopes.
+    #
+    module Mixin
+      def config
+        Config.instance
+      end
+    end
+  end
+end

data/lib/cocoapods/downloader.rb

@@ -0,0 +1,59 @@
+require 'cocoapods-downloader'
+
+module Pod
+  module Downloader
+    class Base
+
+      override_api do
+
+        def execute_command(executable, command, raise_on_failure = false)
+          Executable.execute_command(executable, command, raise_on_failure)
+        end
+
+        # Indicates that an action will be performed. The action is passed as a
+        # block.
+        #
+        # @param  [String] message
+        #         The message associated with the action.
+        #
+        # @yield  The action, this block is always executed.
+        #
+        # @return [void]
+        #
+        def ui_action(message)
+          UI.section(" > #{message}", '', 1) do
+            yield
+          end
+        end
+
+        # Indicates that a minor action will be performed. The action is passed
+        # as a block.
+        #
+        # @param  [String] message
+        #         The message associated with the action.
+        #
+        # @yield  The action, this block is always executed.
+        #
+        # @return [void]
+        #
+        def ui_sub_action(message)
+          UI.section(" > #{message}", '', 2) do
+            yield
+          end
+        end
+
+        # Prints an UI message.
+        #
+        # @param  [String] message
+        #         The message associated with the action.
+        #
+        # @return [void]
+        #
+        def ui_message(message)
+          UI.puts message
+        end
+
+      end
+    end
+  end
+end

data/lib/cocoapods/executable.rb

@@ -0,0 +1,118 @@
+module Pod
+
+  # Module which provides support for running executables.
+  #
+  # In a class it can be used as:
+  #
+  #     extend Executable
+  #     executable :git
+  #
+  # This will create two methods `git` and `git!` both accept a command but
+  # the later will raise on non successful executions. The methods return the
+  # output of the command.
+  #
+  module Executable
+
+    # Creates the methods for the executable with the given name.
+    #
+    # @param  [Symbol] name
+    #         the name of the executable.
+    #
+    # @return [void]
+    #
+    def executable(name)
+
+      define_method(name) do |command|
+        Executable.execute_command(name, command, false)
+      end
+
+      define_method(name.to_s + "!") do |command|
+        Executable.execute_command(name, command, true)
+      end
+    end
+
+    # Executes the given command displaying it if in verbose mode.
+    #
+    # @param  [String] bin
+    #         The binary to use.
+    #
+    # @param  [String] command
+    #         The command to send to the binary.
+    #
+    # @param  [Bool] raise_on_failure
+    #         Whether it should raise if the command fails.
+    #
+    # @raise  If the executable could not be located.
+    #
+    # @raise  If the command fails and the `raise_on_failure` is set to true.
+    #
+    # @return [String] the output of the command (STDOUT and STDERR).
+    #
+    # @todo   Find a way to display the live output of the commands.
+    #
+    def self.execute_command(executable, command, raise_on_failure)
+
+      bin = `which #{executable}`.strip
+      raise Informative, "Unable to locate the executable `#{executable}`" if bin.empty?
+
+      require 'open4'
+
+      full_command = "#{bin} #{command}"
+
+      if Config.instance.verbose?
+        UI.message("$ #{full_command}")
+        stdout, stderr = Indenter.new(STDOUT), Indenter.new(STDERR)
+      else
+        stdout, stderr = Indenter.new, Indenter.new
+      end
+
+      options = {:stdout => stdout, :stderr => stderr, :status => true}
+      status  = Open4.spawn(full_command, options)
+      output  = stdout.join("\n") + stderr.join("\n")
+      unless status.success?
+        if raise_on_failure
+          raise Informative, "#{name} #{command}\n\n#{output}"
+        else
+          UI.message("[!] Failed: #{full_command}".red)
+        end
+      end
+      output
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Helper class that allows to write to an {IO} instance taking into account
+    # the UI indentation lever.
+    #
+    class Indenter < ::Array
+
+      # @return [Fixnum] The indentation level of the UI.
+      #
+      attr_accessor :indent
+
+      # @return [IO] the {IO} to which the output should be printed.
+      #
+      attr_accessor :io
+
+      # @param [IO] io @see io
+      #
+      def initialize(io = nil)
+        @io = io
+        @indent = ' ' * UI.indentation_level
+      end
+
+      # Stores a portion of the output and prints it to the {IO} instance.
+      #
+      # @param  [String] value
+      #         the output to print.
+      #
+      # @return [void]
+      #
+      def <<(value)
+        super
+      ensure
+        @io << "#{ indent }#{ value }" if @io
+      end
+    end
+  end
+end

data/lib/cocoapods/external_sources.rb

@@ -0,0 +1,363 @@
+module Pod
+
+  # Provides support for initializing the correct concrete class of an external
+  # source.
+  #
+  module ExternalSources
+
+    # @return [AbstractExternalSource] an initialized instance of the concrete
+    #         external source class associated with the option specified in the
+    #         hash.
+    #
+    def self.from_dependency(dependency, podfile_path)
+      name   = dependency.root_name
+      params = dependency.external_source
+
+      klass  =  if params.key?(:git)          then GitSource
+                elsif params.key?(:svn)       then SvnSource
+                elsif params.key?(:hg)        then MercurialSource
+                elsif params.key?(:podspec)   then PodspecSource
+                elsif params.key?(:path)      then PathSource
+                end
+
+      if params.key?(:local)
+        klass = PathSource
+        UI.warn "The `:local` option of the Podfile has been renamed to `:path` and is deprecated." \
+      end
+
+      if klass
+        klass.new(name, params, podfile_path)
+      else
+        msg = "Unknown external source parameters for `#{name}`: `#{params}`"
+        raise Informative, msg
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Abstract class that defines the common behaviour of external sources.
+    #
+    class AbstractExternalSource
+
+      # @return [String] the name of the Pod described by this external source.
+      #
+      attr_reader :name
+
+      # @return [Hash{Symbol => String}] the hash representation of the
+      #         external source.
+      #
+      attr_reader :params
+
+      # @return [String] the path where the podfile is defined to resolve
+      #         relative paths.
+      #
+      attr_reader :podfile_path
+
+      # @param [String] name @see name
+      # @param [Hash] params @see params
+      # @param [String] podfile_path @see podfile_path
+      #
+      def initialize(name, params, podfile_path)
+        @name = name
+        @params = params
+        @podfile_path = podfile_path
+      end
+
+      # @return [Bool] whether an external source source is equal to another
+      #         according to the {#name} and to the {#params}.
+      #
+      def ==(other)
+        return false if other.nil?
+        name == other.name && params == other.params
+      end
+
+      #--------------------------------------#
+
+      public
+
+      # @!group Fetching
+
+      # Fetches the external source from the remote according to the params.
+      #
+      # @param  [Sandbox] sandbox
+      #         the sandbox where the specification should be stored.
+      #
+      # @return [void]
+      #
+      def fetch(sandbox)
+        raise "Abstract method"
+      end
+
+      #--------------------------------------#
+
+      public
+
+      # @!group Subclasses hooks
+
+      # Fetches the external source from the remote according to the params.
+      #
+      # @param  [Sandbox] sandbox
+      #         the sandbox where the specification should be stored.
+      #
+      # @return [void]
+      #
+      def fetch(sandbox)
+        raise "Abstract method"
+      end
+
+      # @return [String] a string representation of the source suitable for UI.
+      #
+      def description
+        raise "Abstract method"
+      end
+
+      #--------------------------------------#
+
+      private
+
+      # @! Subclasses helpers
+
+      # Pre-downloads a Pod passing the options to the downloader and informing
+      # the sandbox.
+      #
+      # @param  [Sandbox] sandbox
+      #         The sandbox where the Pod should be downloaded.
+      #
+      # @note   To prevent a double download of the repository the pod is
+      #         marked as pre-downloaded indicating to the installer that only
+      #         clean operations are needed.
+      #
+      # @todo  The downloader configuration is the same of the
+      #        #{PodSourceInstaller} and it needs to be kept in sync.
+      #
+      # @return [void]
+      #
+      def pre_download(sandbox)
+        UI.titled_section("Pre-downloading: `#{name}` #{description}", { :verbose_prefix => "-> " }) do
+          target = sandbox.root + name
+          target.rmtree if target.exist?
+          downloader = Downloader.for_target(target, params)
+          downloader.cache_root = CACHE_ROOT.to_s
+          downloader.max_cache_size = MAX_CACHE_SIZE
+          downloader.aggressive_cache = false
+          downloader.download
+          store_podspec(sandbox, target + "#{name}.podspec")
+          sandbox.store_pre_downloaded_pod(name)
+          if downloader.options_specific?
+            source = params
+          else
+            source = downloader.checkout_options
+          end
+          sandbox.store_checkout_source(name, source)
+        end
+      end
+
+      # Stores the podspec in the sandbox and marks it as from an external
+      # source.
+      #
+      # @param  [Sandbox] sandbox
+      #         The sandbox where the specification should be stored.
+      #
+      # @param  [Pathname, String] spec
+      #         The path of the specification or its contents.
+      #
+      # @note   All the concrete implementations of #{fetch} should invoke this
+      #         method.
+      #
+      # @note   The sandbox ensures that the podspec exists and that the names
+      #         match.
+      #
+      # @return [void]
+      #
+      def store_podspec(sandbox, spec)
+        sandbox.store_podspec(name, spec, true)
+      end
+
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Provides support for fetching a specification file from a Git remote.
+    #
+    # Supports all the options of the downloader (is similar to the git key of
+    # `source` attribute of a specification).
+    #
+    # @note The podspec must be in the root of the repository and should have a
+    #       name matching the one of the dependency.
+    #
+    class GitSource < AbstractExternalSource
+
+      # @see AbstractExternalSource#fetch
+      #
+      def fetch(sandbox)
+        pre_download(sandbox)
+      end
+
+      # @see AbstractExternalSource#description
+      #
+      def description
+        "from `#{params[:git]}`".tap do |description|
+          description << ", commit `#{params[:commit]}`" if params[:commit]
+          description << ", branch `#{params[:branch]}`" if params[:branch]
+          description << ", tag `#{params[:tag]}`" if params[:tag]
+        end
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Provides support for fetching a specification file from a SVN source
+    # remote.
+    #
+    # Supports all the options of the downloader (is similar to the git key of
+    # `source` attribute of a specification).
+    #
+    # @note The podspec must be in the root of the repository and should have a
+    #       name matching the one of the dependency.
+    #
+    class SvnSource < AbstractExternalSource
+
+      # @see AbstractExternalSource#fetch
+      #
+      def fetch(sandbox)
+        pre_download(sandbox)
+      end
+
+      # @see AbstractExternalSource#description
+      #
+      def description
+        "from `#{params[:svn]}`".tap do |description|
+          description << ", folder `#{params[:folder]}`" if params[:folder]
+          description << ", tag `#{params[:tag]}`" if params[:tag]
+          description << ", revision `#{params[:revision]}`" if params[:revision]
+        end
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Provides support for fetching a specification file from a Mercurial
+    # source remote.
+    #
+    # Supports all the options of the downloader (is similar to the git key of
+    # `source` attribute of a specification).
+    #
+    # @note The podspec must be in the root of the repository and should have a
+    #       name matching the one of the dependency.
+    #
+    class MercurialSource < AbstractExternalSource
+
+      # @see AbstractExternalSource#fetch
+      #
+      def fetch(sandbox)
+        pre_download(sandbox)
+      end
+
+      # @see AbstractExternalSource#description
+      #
+      def description
+        "from `#{params[:hg]}`".tap do |description|
+          description << ", revision `#{params[:revision]}`" if params[:revision]
+        end
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Provides support for fetching a specification file from an URL. Can be
+    # http, file, etc.
+    #
+    class PodspecSource < AbstractExternalSource
+
+      # @see AbstractExternalSource#fetch
+      #
+      def fetch(sandbox)
+        UI.titled_section("Fetching podspec for `#{name}` #{description}", { :verbose_prefix => "-> " }) do
+
+          require 'open-uri'
+          open(podspec_uri) { |io| store_podspec(sandbox, io.read) }
+        end
+      end
+
+      # @see AbstractExternalSource#description
+      #
+      def description
+        "from `#{params[:podspec]}`"
+      end
+
+      #--------------------------------------#
+
+      private
+
+      # @!group Helpers
+
+      # @return [String] The uri of the podspec appending the name of the file
+      #         and expanding it if necessary.
+      #
+      # @note   If the declared path is expanded only if the represents a path
+      #         relative to the file system.
+      #
+      def podspec_uri
+        declared_path = params[:podspec].to_s
+        if declared_path.match(%r{^.+://})
+          declared_path
+        else
+          path_with_ext = File.extname(declared_path) == '.podspec' ? declared_path : "#{declared_path}/#{name}.podspec"
+          podfile_dir   = File.dirname(podfile_path || '')
+          absolute_path = File.expand_path(path_with_ext, podfile_dir)
+          absolute_path
+        end
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Provides support for fetching a specification file from a path local to
+    # the machine running the installation.
+    #
+    # Works with the {LocalPod::LocalSourcedPod} class.
+    #
+    class PathSource < AbstractExternalSource
+
+      # @see  AbstractExternalSource#fetch
+      #
+      def fetch(sandbox)
+        UI.titled_section("Fetching podspec for `#{name}` #{description}", { :verbose_prefix => "-> " }) do
+          podspec = podspec_path
+          store_podspec(sandbox, podspec)
+          sandbox.store_local_path(name, podspec.dirname)
+        end
+      end
+
+      # @see  AbstractExternalSource#description
+      #
+      def description
+        "from `#{params[:path] || params[:local]}`"
+      end
+
+      #--------------------------------------#
+
+      private
+
+      # @!group Helpers
+
+      # @return [Pathname] the path of the podspec.
+      #
+      def podspec_path
+        declared_path = (params[:path] || params[:local]).to_s
+        path_with_ext = File.extname(declared_path) == '.podspec' ? declared_path : "#{declared_path}/#{name}.podspec"
+        podfile_dir   = File.dirname(podfile_path || '')
+        absolute_path = File.expand_path(path_with_ext, podfile_dir)
+        pathname      = Pathname.new(absolute_path)
+
+        unless pathname.exist?
+          raise Informative, "No podspec found for `#{name}` in `#{params[:local]}`"
+        end
+        pathname
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+  end
+end