cocoapods 0.16.4 → 0.17.0.rc1

data/lib/cocoapods/command/list.rb

@@ -1,17 +1,8 @@
 module Pod
   class Command
     class List < Command
-      def self.banner
-        %{List all pods:
-
-    $ pod list
-
-      Lists all available pods.
-
-    $ pod list new
-
-      Lists the pods introduced in the master repository since the last check.}
-      end
+      self.summary = 'List pods'
+      self.description = 'Lists all available pods.'
 
       def self.options
         [[
@@ -24,51 +15,61 @@ module Pod
       executable :git
 
       def initialize(argv)
-        @update = argv.option('--update')
-        @stats  = argv.option('--stats')
-        @new    = argv.option('new')
-        super unless argv.empty?
+        @update = argv.flag?('update')
+        @stats  = argv.flag?('stats')
+        super
       end
 
-      def list_all
-        sets = Source.all_sets
+      def run
+        update_if_necessary!
+
+        sets = SourcesManager.all_sets
         sets.each { |set| UI.pod(set, :name) }
         UI.puts "\n#{sets.count} pods were found"
       end
 
-      def list_new
-        days = [1,2,3,5,8]
-        dates, groups = {}, {}
-        days.each {|d| dates[d] = Time.now - 60 * 60 * 24 * d}
-        sets = Source.all_sets
-        creation_dates = Pod::Specification::Statistics.instance.creation_dates(sets)
+      def update_if_necessary!
+        if @update && config.verbose?
+          UI.section("\nUpdating Spec Repositories\n".yellow) do
+            Repo.new(ARGV.new(["update"])).run
+          end
+        end
+      end
 
-        sets.each do |set|
-          set_date = creation_dates[set.name]
-          days.each do |d|
-            if set_date >= dates[d]
-              groups[d] = [] unless groups[d]
-              groups[d] << set
-              break
+      #-----------------------------------------------------------------------#
+
+      class New < List
+        self.summary = 'Lists pods introduced in the master spec-repo since the last check'
+
+        def run
+          update_if_necessary!
+
+          days = [1,2,3,5,8]
+          dates, groups = {}, {}
+          days.each {|d| dates[d] = Time.now - 60 * 60 * 24 * d}
+          sets = SourcesManager.all_sets
+          creation_dates = Specification::Set::Statistics.instance.creation_dates(sets)
+
+          sets.each do |set|
+            set_date = creation_dates[set.name]
+            days.each do |d|
+              if set_date >= dates[d]
+                groups[d] = [] unless groups[d]
+                groups[d] << set
+                break
+              end
             end
           end
-        end
-        days.reverse.each do |d|
-          sets = groups[d]
-          next unless sets
-          UI.section("\nPods added in the last #{"day".pluralize(d)}".yellow) do
-            sorted = sets.sort_by {|s| creation_dates[s.name]}
-            sorted.each { |set| UI.pod(set, (@stats ? :stats : :name)) }
+          days.reverse.each do |d|
+            sets = groups[d]
+            next unless sets
+            UI.section("\nPods added in the last #{"day".pluralize(d)}".yellow) do
+              sorted = sets.sort_by {|s| creation_dates[s.name]}
+              sorted.each { |set| UI.pod(set, (@stats ? :stats : :name)) }
+            end
           end
         end
       end
-
-      def run
-        UI.section("\nUpdating Spec Repositories\n".yellow) do
-          Repo.new(ARGV.new(["update"])).run
-        end if @update && config.verbose?
-        @new ? list_new : list_all
-      end
     end
   end
 end

data/lib/cocoapods/command/outdated.rb

@@ -1,47 +1,50 @@
 module Pod
   class Command
     class Outdated < Command
-      def self.banner
-%{Show outdated pods:
+      self.summary = 'Show outdated project dependencies'
 
-    $ pod outdated
-
-      Shows the outdated pods in the current Podfile.lock, but only those from
-      spec repos, not those from local/external sources or `:head' versions.}
-      end
+      self.description = <<-DESC
+        Shows the outdated pods in the current Podfile.lock, but only those from
+        spec repos, not those from local/external sources or `:head` versions.
+      DESC
 
       def self.options
         [["--no-update", "Skip running `pod repo update` before install"]].concat(super)
       end
 
       def initialize(argv)
-        config.skip_repo_update = argv.option('--no-update')
-        super unless argv.empty?
+        config.skip_repo_update = argv.flag?('update', config.skip_repo_update)
+        super
       end
 
+      # @todo the command report new dependencies added to the Podfile as
+      #       updates.
+      # @todo fix.
+      #
       def run
         verify_podfile_exists!
         verify_lockfile_exists!
 
-        sandbox = Sandbox.new(config.project_pods_root)
-        resolver = Resolver.new(config.podfile, config.lockfile, sandbox)
-        resolver.update_mode = true
-        resolver.update_external_specs = false
-        resolver.resolve
-
-        #TODO: the command report new dependencies (added to by updated ones)
-        # as updates.
-
-        names = resolver.pods_to_install - resolver.pods_from_external_sources
-        specs = resolver.specs.select do |spec|
-          names.include?(spec.name) && !spec.version.head?
+        lockfile = config.lockfile
+        pods = lockfile.pod_names
+        updates = []
+        pods.each do |pod_name|
+          set = SourcesManager.search(Dependency.new(pod_name))
+          source_version = set.versions.first
+          lockfile_version = lockfile.version(pod_name)
+          if source_version > lockfile_version
+            updates << [pod_name, lockfile_version, source_version]
+          end
         end
 
-        if specs.empty?
-          puts "No updates are available.".yellow
+        if updates.empty?
+          UI.puts "No updates are available.".yellow
         else
-          puts "The following updates are available:".green
-          puts "  - " << specs.join("\n  - ") << "\n"
+          UI.section "The following updates are available:" do
+            updates.each do |(name, from_version, to_version)|
+              UI.message "- #{name} #{from_version} -> #{to_version}"
+            end
+          end
         end
       end
     end

data/lib/cocoapods/command/project.rb

@@ -0,0 +1,90 @@
+module Pod
+  class Command
+
+    # Provides support the common behaviour of the `install` and `update`
+    # commands.
+    #
+    module Project
+      module Options
+        def options
+          [
+            ["--no-clean",     "Leave SCM dirs like `.git' and `.svn' intact after downloading"],
+            ["--no-doc",       "Skip documentation generation with appledoc"],
+            ["--no-integrate", "Skip integration of the Pods libraries in the Xcode project(s)"],
+            ["--no-update",    "Skip running `pod repo update` before install"],
+          ].concat(super)
+        end
+      end
+
+      def self.included(base)
+        base.extend Options
+      end
+
+      def initialize(argv)
+        config.clean = argv.flag?('clean', config.clean)
+        config.generate_docs = argv.flag?('doc', config.generate_docs)
+        config.integrate_targets = argv.flag?('integrate', config.integrate_targets)
+        config.skip_repo_update = !argv.flag?('update', !config.skip_repo_update)
+        super
+      end
+
+      # Runs the installer.
+      #
+      # @param  [update] whether the installer should be run in update mode.
+      #
+      # @return [void]
+      #
+      def run_install_with_update(update)
+        installer = Installer.new(config.sandbox, config.podfile, config.lockfile)
+        installer.update_mode = update
+        installer.install!
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    class Install < Command
+      include Project
+
+      self.summary = 'Install project dependencies'
+
+      self.description = <<-DESC
+        Downloads all dependencies defined in `Podfile' and creates an Xcode
+        Pods library project in `./Pods'.
+
+        The Xcode project file should be specified in your `Podfile` like this:
+
+          xcodeproj 'path/to/XcodeProject'
+
+        If no xcodeproj is specified, then a search for an Xcode project will
+        be made.  If more than one Xcode project is found, the command will
+        raise an error.
+
+        This will configure the project to reference the Pods static library,
+        add a build configuration file, and add a post build script to copy
+        Pod resources.
+      DESC
+
+      def run
+        verify_podfile_exists!
+        run_install_with_update(false)
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    class Update < Command
+      include Project
+
+      self.summary = 'Update outdated project dependencies'
+
+      def run
+        verify_podfile_exists!
+        verify_lockfile_exists!
+        run_install_with_update(true)
+      end
+    end
+
+  end
+end
+

data/lib/cocoapods/command/push.rb

@@ -4,36 +4,40 @@ require 'active_support/core_ext/string/inflections'
 module Pod
   class Command
     class Push < Command
-      def self.banner
-%{Pushing new specifications to a spec-repo:
+      self.summary = 'Push new specifications to a spec-repo'
 
-    $ pod push REPO [NAME.podspec]
+      self.description = <<-DESC
+        Validates NAME.podspec or `*.podspec' in the current working dir, creates
+        a directory and version folder for the pod in the local copy of 
+        REPO (~/.cocoapods/[REPO]), copies the podspec file into the version directory,
+        and finally it pushes REPO to its remote.
+      DESC
 
-      Validates NAME.podspec or `*.podspec' in the current working dir, creates
-      a directory and version folder for the pod in the local copy of 
-      REPO (~/.cocoapods/[REPO]), copies the podspec file into the version directory,
-      and finally it pushes REPO to its remote.}
-      end
+      self.arguments = 'REPO [NAME.podspec]'
 
       def self.options
         [ ["--allow-warnings", "Allows to push if warnings are not evitable"],
           ["--local-only", "Does not perform the step of pushing REPO to its remote"] ].concat(super)
       end
 
-      extend Executable
-      executable :git
-
       def initialize(argv)
-        @allow_warnings = argv.option('--allow-warnings')
-        @local_only = argv.option('--local-only')
+        @allow_warnings = argv.flag?('allow-warnings')
+        @local_only = argv.flag?('local-only')
         @repo = argv.shift_argument
-        if @repo.end_with? ".podspec"
+        if @repo.nil?
+          @repo = "master"
+        elsif @repo.end_with? ".podspec"
           @podspec = @repo
           @repo = "master"
         else
           @podspec = argv.shift_argument
         end
-        super unless argv.empty? && @repo
+        super
+      end
+
+      def validate!
+        super
+        help! "A spec-repo name is required." unless @repo
       end
 
       def run
@@ -44,35 +48,39 @@ module Pod
         push_repo unless @local_only
       end
 
+      #--------------------------------------#
+
       private
 
+      extend Executable
+      executable :git
+
       def update_repo
-        UI.puts "Updating the `#{@repo}' repo\n".yellow unless config.silent
-        # show the output of git even if not verbose
-        # TODO: use the `git!' and find a way to show the output in realtime.
+        UI.puts "Updating the `#{@repo}' repo\n".yellow
         Dir.chdir(repo_dir) { UI.puts `git pull 2>&1` }
       end
 
       def push_repo
-        UI.puts "\nPushing the `#{@repo}' repo\n".yellow unless config.silent
+        UI.puts "\nPushing the `#{@repo}' repo\n".yellow
         Dir.chdir(repo_dir) { UI.puts `git push 2>&1` }
       end
 
       def repo_dir
         dir = config.repos_dir + @repo
-        raise Informative, "[!] `#{@repo}' repo not found".red unless dir.exist?
+        raise Informative, "`#{@repo}` repo not found" unless dir.exist?
         dir
       end
 
+      # @todo: Add specs for staged and unstaged files.
+      #
       def check_repo_status
-        # TODO: add specs for staged and unstaged files (tested manually)
         clean = Dir.chdir(repo_dir) { `git status --porcelain  2>&1` } == ''
-        raise Informative, "[!] `#{@repo}' repo not clean".red unless clean
+        raise Informative, "The repo `#{@repo}` is not clean" unless clean
       end
 
       def podspec_files
         files = Pathname.glob(@podspec || "*.podspec")
-        raise Informative, "[!] Couldn't find any .podspec file in current directory".red if files.empty?
+        raise Informative, "Couldn't find any .podspec file in current directory" if files.empty?
         files
       end
 
@@ -83,18 +91,29 @@ module Pod
       end
 
       def validate_podspec_files
-        UI.puts "\nValidating #{'spec'.pluralize(count)}".yellow unless config.silent
-        lint_argv = ["lint"]
-        lint_argv << "--only-errors" if @allow_warnings
-        lint_argv << "--silent" if config.silent
-        # all_valid = true
+        UI.puts "\nValidating #{'spec'.pluralize(count)}".yellow
         podspec_files.each do |podspec|
-          Spec.new(ARGV.new(lint_argv + [podspec.to_s])).run
+          validator = Validator.new(podspec)
+          begin
+            validator.validate
+          rescue Exception => e
+            raise Informative, "The `#{podspec}` specification does not validate."
+          end
+          raise Informative, "The `#{podspec}` specification does not validate." unless validator.validated?
         end
       end
 
+      # Commits the podspecs to the source, which should be a git repo.
+      #
+      # @note   The pre commit hook of the repo is skipped as the podspecs have
+      #         already been linted.
+      #
+      # @todo   Raise if the source is not under git source control.
+      #
+      # @return [void]
+      #
       def add_specs_to_repo
-        UI.puts "\nAdding the #{'spec'.pluralize(count)} to the `#{@repo}' repo\n".yellow unless config.silent
+        UI.puts "\nAdding the #{'spec'.pluralize(count)} to the `#{@repo}' repo\n".yellow
         podspec_files.each do |spec_file|
           spec = Pod::Specification.from_file(spec_file)
           output_path = File.join(repo_dir, spec.name, spec.version.to_s)
@@ -105,13 +124,12 @@ module Pod
           else
             message = "[Add] #{spec}"
           end
-          UI.puts " - #{message}" unless config.silent
+          UI.puts " - #{message}"
 
           FileUtils.mkdir_p(output_path)
           FileUtils.cp(Pathname.new(spec.name+'.podspec'), output_path)
           Dir.chdir(repo_dir) do
             git!("add #{spec.name}")
-            # Bypass the pre-commit hook because we already performed validation
             git!("commit --no-verify -m '#{message}'")
           end
         end

data/lib/cocoapods/command/repo.rb

@@ -3,194 +3,164 @@ require 'fileutils'
 module Pod
   class Command
     class Repo < Command
-      def self.banner
-%{Managing spec-repos:
+      self.abstract_command = true
 
-    $ pod repo add NAME URL [BRANCH]
+      # @todo should not show a usage banner!
+      #
+      self.summary = 'Manage spec-repositories'
 
-      Clones `URL' in the local spec-repos directory at `~/.cocoapods'. The
-      remote can later be referred to by `NAME'.
+      class Add < Repo
+        self.summary = 'Add a spec repo.'
 
-    $ pod repo update [NAME]
+        self.description = <<-DESC
+          Clones `URL` in the local spec-repos directory at `~/.cocoapods`. The
+          remote can later be referred to by `NAME`.
+        DESC
 
-      Updates the local clone of the spec-repo `NAME'. If `NAME' is omitted
-      this will update all spec-repos in `~/.cocoapods'.
+        self.arguments = 'NAME URL [BRANCH]'
 
-    $ pod repo lint [NAME | DIRECTORY]
-
-      Lints the spec-repo `NAME'. If a directory is provided it is assumed
-      to be the root of a repo. Finally, if NAME is not provided this will
-      lint all the spec-repos known to CocoaPods.}
-      end
-
-      def self.options
-        [["--only-errors", "Lint presents only the errors"]].concat(super)
-      end
+        def initialize(argv)
+          @name, @url, @branch = argv.shift_argument, argv.shift_argument, argv.shift_argument
+          super
+        end
 
-      extend Executable
-      executable :git
+        def validate!
+          super
+          unless @name && @url
+            help! "Adding a repo needs a `NAME` and a `URL`."
+          end
+        end
 
-      def initialize(argv)
-        case @action = argv.arguments[0]
-        when 'add'
-          unless (@name = argv.arguments[1]) && (@url = argv.arguments[2])
-            raise Informative, "#{@action == 'add' ? 'Adding' : 'Updating the remote of'} a repo needs a `name' and a `url'."
+        def run
+          UI.section("Cloning spec repo `#{@name}` from `#{@url}`#{" (branch `#{@branch}`)" if @branch}") do
+            config.repos_dir.mkpath
+            Dir.chdir(config.repos_dir) { git!("clone '#{@url}' #{@name}") }
+            Dir.chdir(dir) { git!("checkout #{@branch}") } if @branch
+            SourcesManager.check_version_information(dir)
           end
-          @branch = argv.arguments[3]
-        when 'update'
-          @name = argv.arguments[1]
-        when 'lint'
-          @name = argv.arguments[1]
-          @only_errors = argv.option('--only-errors')
-        else
-          super
         end
       end
 
-      def dir
-        config.repos_dir + @name
-      end
+      #-----------------------------------------------------------------------#
 
-      def run
-        send @action.gsub('-', '_')
-      end
+      class Update < Repo
+        self.summary = 'Update a spec repo.'
 
-      def add
-        UI.section("Cloning spec repo `#{@name}' from `#{@url}'#{" (branch `#{@branch}')" if @branch}") do
-          config.repos_dir.mkpath
-          Dir.chdir(config.repos_dir) { git!("clone '#{@url}' #{@name}") }
-          Dir.chdir(dir) { git!("checkout #{@branch}") } if @branch
-          check_versions(dir)
-        end
-      end
+        self.description = <<-DESC
+          Updates the local clone of the spec-repo `NAME`. If `NAME` is omitted
+          this will update all spec-repos in `~/.cocoapods`.
+        DESC
 
-      def update
-        dirs = @name ? [dir] : config.repos_dir.children.select {|c| c.directory?}
-        dirs.each do |dir|
-          UI.section "Updating spec repo `#{dir.basename}'" do
-            Dir.chdir(dir) do
-              `git rev-parse  >/dev/null 2>&1`
-              if $?.exitstatus.zero?
-                git!("pull")
-              else
-                UI.message "Not a git repository"
-              end
-            end
-          end
-          check_versions(dir)
-        end
-      end
+        self.arguments = '[NAME]'
 
-      def lint
-        if @name
-          dirs = File.exists?(@name) ? [ Pathname.new(@name) ] : [ dir ]
-        else
-          dirs = config.repos_dir.children.select {|c| c.directory?}
+        def initialize(argv)
+          @name = argv.shift_argument
+          super
         end
-        dirs.each do |dir|
-          check_versions(dir)
-          UI.puts "\nLinting spec repo `#{dir.realpath.basename}'\n".yellow
-          podspecs = Pathname.glob( dir + '**/*.podspec')
-          invalid_count = 0
-
-          podspecs.each do |podspec|
-            linter = Linter.new(podspec)
-            linter.quick     = true
-            linter.repo_path = dir
-
-            linter.lint
-
-            case linter.result_type
-            when :error
-              invalid_count += 1
-              color = :red
-              should_display = true
-            when :warning
-              color = :yellow
-              should_display = !@only_errors
-            end
-
-            if should_display
-              UI.puts " -> ".send(color) << linter.spec_name
-              print_messages('ERROR', linter.errors)
-              unless @only_errors
-                print_messages('WARN',  linter.warnings)
-                print_messages('NOTE',  linter.notes)
-              end
-              UI.puts unless config.silent?
-            end
-          end
-          UI.puts "Analyzed #{podspecs.count} podspecs files.\n\n" unless config.silent?
 
-          if invalid_count == 0
-            UI.puts "All the specs passed validation.".green << "\n\n" unless config.silent?
-          else
-            raise Informative, "#{invalid_count} podspecs failed validation."
-          end
+        def run
+          SourcesManager.update(@name, true)
         end
       end
 
-      def print_messages(type, messages)
-        return if config.silent?
-        messages.each {|msg| UI.puts "    - #{type.ljust(5)} | #{msg}"}
-      end
+      #-----------------------------------------------------------------------#
 
-      def check_versions(dir)
-        versions = versions(dir)
-        unless is_compatilbe(versions)
-          min, max = versions['min'], versions['max']
-          version_msg = ( min == max ) ? min : "#{min} - #{max}"
-          raise Informative,
-          "\n[!] The `#{dir.basename.to_s}' repo requires CocoaPods #{version_msg}\n".red +
-          "Update Cocoapods, or checkout the appropriate tag in the repo.\n\n"
-        end
-        UI.puts "\nCocoapods #{versions['last']} is available.\n".green if has_update(versions) && config.new_version_message?
-      end
+      class Lint < Repo
+        self.summary = 'Validates all specs in a repo.'
 
-      def self.compatible?(name)
-        dir = Config.instance.repos_dir + name
-        versions = versions(dir)
-        is_compatilbe(versions)
-      end
+        self.description = <<-DESC
+          Lints the spec-repo `NAME`. If a directory is provided it is assumed
+          to be the root of a repo. Finally, if `NAME` is not provided this
+          will lint all the spec-repos known to CocoaPods.
+        DESC
 
-      #--------------------------------------#
+        self.arguments = '[ NAME | DIRECTORY ]'
 
-      private
+        def self.options
+          [["--only-errors", "Lint presents only the errors"]].concat(super)
+        end
 
-      def versions(dir)
-        self.class.versions(dir)
-      end
+        def initialize(argv)
+          @name = argv.shift_argument
+          @only_errors = argv.flag?('only-errors')
+          super
+        end
 
-      def self.versions(dir)
-        require 'yaml'
-        yaml_file  = dir + 'CocoaPods-version.yml'
-        yaml_file.exist? ? YAML.load_file(yaml_file) : {}
-      end
+        # @todo Part of this logic needs to be ported to cocoapods-core so web
+        #       services can validate the repo.
+        #
+        # @todo add UI.print and enable print statements again.
+        #
+        def run
+          if @name
+            dirs = File.exists?(@name) ? [ Pathname.new(@name) ] : [ dir ]
+          else
+            dirs = config.repos_dir.children.select {|c| c.directory?}
+          end
+          dirs.each do |dir|
+            SourcesManager.check_version_information(dir)
+            UI.puts "\nLinting spec repo `#{dir.realpath.basename}`\n".yellow
+            podspecs = Pathname.glob( dir + '**/*.podspec')
+            invalid_count = 0
+
+            messages_by_type = {}
+            podspecs.each do |podspec|
+              # print "\033[K -> #{podspec.relative_path_from(dir)}\r" unless config.silent?
+              validator = Validator.new(podspec)
+              validator.quick       = true
+              validator.repo_path   = dir
+              validator.only_errors = @only_errors
+              validator.disable_ui_output = true
+
+              validator.validate
+              invalid_count += 1 if validator.result_type == :error
+              unless validator.validated?
+                if @only_errors
+                  results = validator.results.select { |r| r.type.to_s == "error" }
+                else
+                  results = validator.results
+                end
+                sorted_results = results.sort_by { |r| [r.type.to_s, r.message] }
+                sorted_results.each do |result|
+                  name = validator.spec ? validator.spec.name : podspec.relative_path_from(dir)
+                  version = validator.spec ? validator.spec.version : 'unknown'
+                  messages_by_type[result.type] ||= {}
+                  messages_by_type[result.type][result.message] ||= {}
+                  messages_by_type[result.type][result.message][name] ||= []
+                  messages_by_type[result.type][result.message][name] << version
+                end
+              end
+            end
 
-      def is_compatilbe(versions)
-        self.class.is_compatilbe(versions)
-      end
+            # print "\033[K" unless config.silent?
+            messages_by_type.each do |type, names_by_message|
+              names_by_message.each do |message, versions_by_names|
+                color = type == :error ? :red : :yellow
+                UI.puts "[#{type}] #{message}".send(color)
+                versions_by_names.each { |name, versions| UI.puts "  - #{name} (#{versions * ', '})" }
+                UI.puts
+              end
+            end
 
-      def self.is_compatilbe(versions)
-        min, max = versions['min'], versions['max']
-        supports_min = !min || bin_version >= Gem::Version.new(min)
-        supports_max = !max || bin_version <= Gem::Version.new(max)
-        supports_min && supports_max
-      end
+            UI.puts "Analyzed #{podspecs.count} podspecs files.\n\n"
 
-      def has_update(versions)
-        self.class.has_update(versions)
+            if invalid_count == 0
+              UI.puts "All the specs passed validation.".green << "\n\n"
+            else
+              raise Informative, "#{invalid_count} podspecs failed validation."
+            end
+          end
+        end
       end
 
-      def self.has_update(versions)
-        last = versions['last']
-        last && Gem::Version.new(last) > bin_version
-      end
+      #-----------------------------------------------------------------------#
 
-      def self.bin_version
-        Gem::Version.new(VERSION)
-      end
+      extend Executable
+      executable :git
 
+      def dir
+        config.repos_dir + @name
+      end
     end
   end
 end