cocoapods 0.16.4 → 0.17.0.rc1

data/lib/cocoapods/config.rb

@@ -1,79 +1,232 @@
-require 'pathname'
-
 module Pod
+
+  # Stores the global configuration of CocoaPods.
+  #
   class Config
-    def self.instance
-      @instance ||= new
-    end
 
-    def self.instance=(instance)
-      @instance = instance
-    end
+    # 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
+    #     generate_docs: false
+    #     install_docs: false
+    #
+    DEFAULTS = {
+      :verbose             => false,
+      :silent              => false,
+      :skip_repo_update    => false,
+      :aggressive_cache    => false,
+
+      :clean               => true,
+      :generate_docs       => true,
+      :install_docs        => true,
+      :integrate_targets   => true,
+      :skip_repo_update    => 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 the generated documentation should be installed to
+    #         Xcode.
+    #
+    attr_accessor :new_version_message
+    alias_method  :new_version_message?, :new_version_message
+
+    #--------------------------------------#
 
-    attr_accessor :repos_dir, :project_root, :project_pods_root
-    attr_accessor :clean, :verbose, :silent
-    attr_accessor :generate_docs, :doc_install
+    # @!group Installation
+
+    # @return [Bool] Whether the installer should clean after the installation.
+    #
+    attr_accessor :clean
+    alias_method  :clean?, :clean
+
+    # @return [Bool] Whether the documentation should be generated for the
+    #         installed Pods.
+    #
+    attr_accessor :generate_docs
+    alias_method  :generate_docs?, :generate_docs
+
+    # @return [Bool] Whether the generated documentation should be installed to
+    #         Xcode.
+    #
+    attr_accessor :install_docs
+    alias_method  :install_docs?, :install_docs
+
+    # @return [Bool] Whether CocoaPods should integrate a user target and build
+    #         the workspace or just create the Pods project.
+    #
     attr_accessor :integrate_targets
-    attr_accessor :new_version_message, :skip_repo_update
+    alias_method  :integrate_targets?, :integrate_targets
 
-    alias_method :clean?,             :clean
-    alias_method :verbose?,           :verbose
-    alias_method :silent?,            :silent
-    alias_method :generate_docs?,     :generate_docs
-    alias_method :doc_install?,       :doc_install
-    alias_method :integrate_targets?, :integrate_targets
-    alias_method :skip_repo_update?,  :skip_repo_update
-    alias_method :new_version_message?, :new_version_message
+
+    # @return [Bool] Whether the installer should skip the repos update.
+    #
+    attr_accessor :skip_repo_update
+    alias_method  :skip_repo_update?, :skip_repo_update
+
+    # @return [Bool] Whether the downloader should use more aggressive caching
+    #         options.
+    #
+    attr_accessor :aggressive_cache
+    alias_method  :aggressive_cache?, :aggressive_cache
+
+    #--------------------------------------#
+
+    # @!group Initialization
 
     def initialize
-      @repos_dir = Pathname.new(File.expand_path("~/.cocoapods"))
-      @verbose = @silent = @skip_repo_update = false
-      @clean = @generate_docs = @doc_install = @integrate_targets = @new_version_message = true
+      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 project_root
-      @project_root ||= Pathname.pwd
+    def verbose
+      @verbose && !silent
     end
 
-    def project_pods_root
-      @project_pods_root ||= project_root + 'Pods'
+    #--------------------------------------#
+
+    # @!group Paths
+
+    # @return [Pathname] the directory where the CocoaPods sources are stored.
+    #
+    def repos_dir
+      @repos_dir ||= Pathname.new(ENV['HOME'] + "/.cocoapods")
     end
 
-    def project_podfile
-      unless @project_podfile
-        @project_podfile = project_root + 'CocoaPods.podfile'
-        unless @project_podfile.exist?
-          @project_podfile = project_root + 'Podfile'
-        end
-      end
-      @project_podfile
+    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
 
-    def project_lockfile
-      @project_lockfile ||= project_root + 'Podfile.lock'
+    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
 
-    def headers_symlink_root
-      @headers_symlink_root ||= "#{project_pods_root}/Headers"
+    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 ||= begin
-        Podfile.from_file(project_podfile) if project_podfile.exist?
-      end
+      @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 ||= begin
-        Lockfile.from_file(project_lockfile) if project_lockfile.exist?
+      @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
+      Pathname.new(ENV['HOME'] + "/.cocoapods/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)
+      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 + 'Podfile.yaml'
+        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

data/lib/cocoapods/downloader.rb

@@ -1,45 +1,58 @@
-require 'uri'
+require 'cocoapods-downloader'
 
 module Pod
-  class Downloader
-    autoload :Git,        'cocoapods/downloader/git'
-    autoload :GitHub,     'cocoapods/downloader/git'
-    autoload :Mercurial,  'cocoapods/downloader/mercurial'
-    autoload :Subversion, 'cocoapods/downloader/subversion'
-    autoload :Http,       'cocoapods/downloader/http'
+  module Downloader
+    class Base
 
-    extend Executable
+      override_api do
 
-    def self.for_pod(pod)
-      spec = pod.top_specification
-      for_target(pod.root, spec.source.dup)
-    end
-
-    attr_reader :target_path, :url, :options
+        def execute_command(executable, command, raise_on_failure = false)
+          Executable.execute_command(executable, command, raise_on_failure)
+        end
 
-    def initialize(target_path, url, options)
-      @target_path, @url, @options = target_path, url, options
-      @target_path.mkpath
-    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
 
-    private
+        # 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
 
-    def self.for_target(target_path, options)
-      options = options.dup
-      if url = options.delete(:git)
-        if url.to_s =~ /github.com/
-          GitHub.new(target_path, url, options)
-        else
-          Git.new(target_path, url, options)
+        # Prints an UI message.
+        #
+        # @param  [String] message
+        #         The message associated with the action.
+        #
+        # @return [void]
+        #
+        def ui_message(message)
+          UI.puts message
         end
-      elsif url = options.delete(:hg)
-        Mercurial.new(target_path, url, options)
-      elsif url = options.delete(:svn)
-        Subversion.new(target_path, url, options)
-      elsif url = options.delete(:http)
-        Http.new(target_path, url, options)
-      else
-        raise "Unsupported download strategy `#{options.inspect}'."
+
       end
     end
   end

data/lib/cocoapods/executable.rb

@@ -1,61 +1,118 @@
-require 'open4'
-
 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
-      include Config::Mixin
 
+      # @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
-
-    def executable(name)
-      bin = `which #{name}`.strip
-      base_method = "base_" << name.to_s
-      define_method(base_method) do |command, should_raise|
-        if bin.empty?
-          raise Informative, "Unable to locate the executable `#{name}'"
-        end
-        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
-        status = Open4.spawn(full_command, :stdout => stdout, :stderr => stderr, :status => true)
-
-        output = stdout.join("\n") + stderr.join("\n") # TODO will this suffice?
-        unless status.success?
-          if should_raise
-            raise Informative, "#{name} #{command}\n\n#{output}"
-          else
-            UI.message("[!] Failed: #{full_command}".red)
-          end
-        end
-        output
-      end
-
-      define_method(name) do |command|
-        send(base_method, command, false)
-      end
-
-      define_method(name.to_s + "!") do |command|
-        send(base_method, command, true)
-      end
-
-      private name
-    end
   end
 end