cocoapods 0.16.4 → 0.17.0.rc1

data/lib/cocoapods/sources_manager.rb

@@ -0,0 +1,218 @@
+module Pod
+
+  # Manages all the sources known to the running CocoaPods Instance.
+  #
+  class SourcesManager
+
+    class << self
+
+      include Config::Mixin
+
+      # @return [Source::Aggregate] the aggregate of all the sources known to
+      #         this installation of CocoaPods.
+      #
+      def aggregate
+        Source::Aggregate.new(config.repos_dir)
+      end
+
+      # @return [Array<Source>] the list of all the sources known to this
+      #         installation of CocoaPods.
+      #
+      def all
+        aggregate.all
+      end
+
+      # @return [Array<Specification::Set>] the list of all the specification
+      #         sets know to this installation of CocoaPods.
+      #
+      def all_sets
+        aggregate.all_sets
+      end
+
+      # Search all the sources to match the set for the given dependency.
+      #
+      # @return [Set, nil] a set for a given dependency including all the
+      #         {Source} that contain the Pod. If no sources containing the
+      #         Pod where found it returns nil.
+      #
+      # @raise  If no source including the set can be found.
+      #
+      def search(dependency)
+        set = aggregate.search(dependency)
+        unless set
+          raise Informative, "Unable to find a pod named `#{dependency.name}`"
+        end
+        set
+      end
+
+      # Search all the sources with the given search term.
+      #
+      # @param  [String] query
+      #         The search term.
+      #
+      # @param  [Bool] full_text_search
+      #         Whether the search should be limited to the name of the Pod or
+      #         should include also the author, the summary, and the
+      #         description.
+      #
+      # @raise  If no source including the set can be found.
+      #
+      # @note   Full text search requires to load the specification for each
+      #         pod, hence is considerably slower.
+      #
+      # @return [Array<Set>]  The sets that contain the search term.
+      #
+      def search_by_name(query, full_text_search = false)
+        result = aggregate.search_by_name(query, full_text_search)
+        if result.empty?
+          extra = ", author, summary, or description" if full_text_search
+          raise Informative "Unable to find a pod with name#{extra} matching `#{query}`"
+        end
+        result
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Updating Sources
+
+      extend Executable
+      executable :git
+
+      # Updates the local clone of the spec-repo with the given name or of all
+      # the git repos if the name is omitted.
+      #
+      # @param  [String] name
+      #
+      # @return [void]
+      #
+      def update(source_name = nil, show_output = false)
+        if source_name
+          source = aggregate.all.find { |s| s.name == source_name }
+          raise Informative, "Unable to find the `#{source_name}` repo."    unless source
+          raise Informative, "The `#{source_name}` repo is not a git repo." unless git_repo?(source.repo)
+          sources = [source]
+        else
+          sources = aggregate.all.select { |source| git_repo?(source.repo) }
+        end
+
+        sources.each do |source|
+          UI.section "Updating spec repo `#{source.name}`" do
+            Dir.chdir(source.repo) do
+              output = git!("pull")
+              UI.puts output if show_output && !config.verbose?
+            end
+            check_version_information(source.repo)
+          end
+        end
+      end
+
+      # Returns whether a source is a GIT repo.
+      #
+      # @param  [Pathname] dir
+      #         The directory where the source is stored.
+      #
+      # @return [Bool] Wether the given source is a GIT repo.
+      #
+      def git_repo?(dir)
+        Dir.chdir(dir) { `git rev-parse  >/dev/null 2>&1` }
+        $?.exitstatus.zero?
+      end
+
+      # Checks the version information of the source with the given directory.
+      # It raises if the source is not compatible and if there is CocoaPods
+      # update it informs the user.
+      #
+      # @param  [Pathname] dir
+      #         The directory where the source is stored.
+      #
+      # @raise  If the source is not compatible.
+      #
+      # @return [void]
+      #
+      def check_version_information(dir)
+        versions = version_information(dir)
+        unless repo_compatible?(dir)
+          min, max = versions['min'], versions['max']
+          version_msg = ( min == max ) ? min : "#{min} - #{max}"
+          raise Informative, "The `#{dir.basename}` repo requires " \
+          "CocoaPods #{version_msg}\n".red +
+          "Update Cocoapods, or checkout the appropriate tag in the repo."
+        end
+
+        if config.new_version_message? && cocoapods_update?(versions)
+          UI.puts "\nCocoapods #{versions['last']} is available.\n".green
+        end
+      end
+
+      # Returns whether a source is compatible with the current version of
+      # CocoaPods.
+      #
+      # @param  [Pathname] dir
+      #         The directory where the source is stored.
+      #
+      # @return [Bool] whether the source is compatible.
+      #
+      def repo_compatible?(dir)
+        versions = version_information(dir)
+
+        min, max = versions['min'], versions['max']
+        bin_version  = Gem::Version.new(Pod::VERSION)
+        supports_min = !min || bin_version >= Gem::Version.new(min)
+        supports_max = !max || bin_version <= Gem::Version.new(max)
+        supports_min && supports_max
+      end
+
+      # Checks whether there is a CocoaPods given the version information of a
+      # repo.
+      #
+      # @param  [Hash] version_information
+      #         The version information of a repository.
+      #
+      # @return [Bool] whether there is an update.
+      #
+      def cocoapods_update?(version_information)
+        version = version_information['last']
+        version && Gem::Version.new(version) > Gem::Version.new(Pod::VERSION)
+      end
+
+      # Returns the contents of the `CocoaPods-version.yml` file, which stores
+      # information about CocoaPods versions.
+      #
+      # This file is a hash with the following keys:
+      #
+      # - last: the last version of CocoaPods known to the source.
+      # - min: the minimum version of CocoaPods supported by the source.
+      # - max: the maximum version of CocoaPods supported by the source.
+      #
+      # @param  [Pathname] dir
+      #         The directory where the source is stored.
+      #
+      # @return [Hash] the versions information from the repo.
+      #
+      def version_information(dir)
+        require 'yaml'
+        yaml_file  = dir + 'CocoaPods-version.yml'
+        yaml_file.exist? ? YAML.load_file(yaml_file) : {}
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Master repo
+
+      # @return [Pathname] The path of the master repo.
+      #
+      def master_repo_dir
+        config.repos_dir + 'master'
+      end
+
+      # @return [Bool] Checks if the master repo is usable.
+      #
+      # @note   Note this is used to automatically setup the master repo if
+      #         needed.
+      #
+      def master_repo_functional?
+        master_repo_dir.exist? && repo_compatible?(master_repo_dir)
+      end
+    end
+  end
+end

data/lib/cocoapods/user_interface.rb

@@ -1,18 +1,27 @@
+require 'cocoapods/user_interface/error_report'
+
 module Pod
-  require 'colored'
+
+  # Provides support for UI output. It provides support for nested sections of
+  # information and for a verbose mode.
+  #
   module UserInterface
 
-    autoload :UIPod, 'cocoapods/user_interface/ui_pod'
+    require 'colored'
 
     @title_colors      =  %w|yellow green|
     @title_level       =  0
     @indentation_level =  2
     @treat_titles_as_messages = false
+    @warnings = []
 
     class << self
+
       include Config::Mixin
 
-      attr_accessor :indentation_level, :title_level
+      attr_accessor :indentation_level
+      attr_accessor :title_level
+      attr_accessor :warnings
 
       # Prints a title taking an optional verbose prefix and
       # a relative indentation valid for the UI action in the passed
@@ -22,13 +31,34 @@ module Pod
       # to their level. In normal mode titles are printed only if
       # they have nesting level smaller than 2.
       #
-      # TODO: refactor to title (for always visible titles like search)
-      # and sections (titles that reppresent collapsible sections).
+      # @todo Refactor to title (for always visible titles like search)
+      #       and sections (titles that represent collapsible sections).
       #
       def section(title, verbose_prefix = '', relative_indentation = 0)
         if config.verbose?
           title(title, verbose_prefix, relative_indentation)
-        elsif title_level < 2
+        elsif title_level < 1
+          puts title
+        end
+
+        self.indentation_level += relative_indentation
+        self.title_level += 1
+        yield if block_given?
+        self.indentation_level -= relative_indentation
+        self.title_level -= 1
+      end
+
+      # In verbose mode it shows the sections and the contents.
+      # In normal mode it just prints the title.
+      #
+      # @return [void]
+      #
+      def titled_section(title, options = {})
+        relative_indentation = options[:relative_indentation] || 0
+        verbose_prefix = options[:verbose_prefix] || ''
+        if config.verbose?
+          title(title, verbose_prefix, relative_indentation)
+        else
           puts title
         end
 
@@ -39,7 +69,7 @@ module Pod
         self.title_level -= 1
       end
 
-      # A title oposed to a section is always visible
+      # A title opposed to a section is always visible
       #
       def title(title, verbose_prefix = '', relative_indentation = 2)
         if(@treat_titles_as_messages)
@@ -67,7 +97,7 @@ module Pod
       # a relative indentation valid for the UI action in the passed
       # block.
       #
-      # TODO: clean interface.
+      # @todo Clean interface.
       #
       def message(message, verbose_prefix = '', relative_indentation = 2)
         message = verbose_prefix + message if config.verbose?
@@ -106,19 +136,32 @@ module Pod
         puts("\n[!] #{message}".green)
       end
 
-      # Prints an important warning to the user optionally followed by actions
-      # that the user should take.
+      # Stores important warning to the user optionally followed by actions
+      # that the user should take. To print them use #{print_warnings}
       #
       # @param [String]  message The message to print.
       # @param [Array]   actions The actions that the user should take.
       #
       # return [void]
       #
-      def warn(message, actions)
-        puts("\n[!] #{message}".yellow)
-        actions.each do |action|
-          indented = wrap_string(action, "    - ")
-          puts(indented)
+      def warn(message, actions = [], verbose_only = false)
+        warnings << { :message => message, :actions => actions }
+      end
+
+      # Prints the stored warnings. This method is intended to be called at the
+      # end of the execution of the binary.
+      #
+      # @return [void]
+      #
+      def print_warnings
+        return if config.silent? && verbose_only
+        STDOUT.flush
+        warnings.each do |warning|
+          STDERR.puts("\n[!] #{warning[:message]}".yellow)
+          warning[:actions].each do |action|
+            indented = wrap_string(action, "    - ")
+            puts(indented)
+          end
         end
       end
 
@@ -128,19 +171,20 @@ module Pod
       #
       def path(pathname)
         if pathname
-          "`./#{pathname.relative_path_from(config.project_podfile.dirname || Pathname.pwd)}'"
+          path = pathname.relative_path_from(config.podfile_path.dirname || Pathname.pwd)
+          "`#{path}`"
         else
           ''
         end
       end
 
-      # Prints the textual repprensentation of a given set.
+      # Prints the textual representation of a given set.
       #
       def pod(set, mode = :normal)
         if mode == :name
           puts_indented set.name
         else
-          pod = UIPod.new(set)
+          pod = Specification::Set::Presenter.new(set)
           title("\n-> #{pod.name} (#{pod.version})".green, '', 1) do
             puts_indented pod.summary
             labeled('Homepage', pod.homepage)
@@ -217,4 +261,24 @@ module Pod
     end
   end
   UI = UserInterface
+
+  # Redirects cocoapods-core UI.
+  #
+  module CoreUI
+
+    class << self
+
+      # @todo enable in CocoaPods 0.17.0 release
+      #
+      def puts(message)
+        # UI.puts message
+      end
+
+      # @todo enable in CocoaPods 0.17.0 release
+      #
+      def warn(message)
+        # UI.warn message
+      end
+    end
+  end
 end

data/lib/cocoapods/{command → user_interface}/error_report.rb

@@ -4,13 +4,13 @@ require 'rbconfig'
 require 'cgi'
 
 module Pod
-  class Command
+  module UserInterface
     module ErrorReport
       class << self
         def report(error)
           return <<-EOS
 
-          #{'――― MARKDOWN TEMPLATE ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――'.reversed}
+#{'――― MARKDOWN TEMPLATE ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――'.reversed}
 
 ### Report
 
@@ -58,13 +58,13 @@ EOS
         private
 
         def markdown_podfile
-          return '' unless Config.instance.project_podfile && Config.instance.project_podfile.exist?
+          return '' unless Config.instance.podfile_path && Config.instance.podfile_path.exist?
           <<-EOS
 
 ### Podfile
 
 ```ruby
-          #{Config.instance.project_podfile.read.strip}
+          #{Config.instance.podfile_path.read.strip}
 ```
           EOS
         end
@@ -86,7 +86,7 @@ EOS
         end
 
         def repo_information
-          Pod::Source.all.map do |source|
+          SourcesManager.all.map do |source|
             repo = source.repo
             Dir.chdir(repo) do
               url = `git config --get remote.origin.url 2>&1`.strip

data/lib/cocoapods/validator.rb

@@ -0,0 +1,379 @@
+module Pod
+
+  # Validates a Specification.
+  #
+  # Extends the Linter from the Core to add additional which require the
+  # LocalPod and the Installer.
+  #
+  # In detail it checks that the file patterns defined by the user match
+  # actually do match at least a file and that the Pod builds, by installing
+  # it without integration and building the project with xcodebuild.
+  #
+  class Validator
+
+    include Config::Mixin
+
+    # @return [Specification::Linter] the linter instance from CocoaPods
+    #         Core.
+    #
+    attr_reader :linter
+
+    # @param  [Specification, Pathname, String] spec_or_path
+    #         the Specification or the path of the `podspec` file to lint.
+    #
+    def initialize(spec_or_path)
+      @linter = Specification::Linter.new(spec_or_path)
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # @return [Specification] the specification to lint.
+    #
+    def spec
+      @linter.spec
+    end
+
+    # @return [Pathname] the path of the `podspec` file where {#spec} is
+    #         defined.
+    #
+    def file
+      @linter.file
+    end
+
+    # @return [Sandbox::FileAccessor] the file accessor for the spec.
+    #
+    attr_accessor :file_accessor
+
+    #-------------------------------------------------------------------------#
+
+    # Lints the specification adding a {Specification::Linter::Result} for any
+    # failed check to the {#results} list.
+    #
+    # @note   This method shows immediately which pod is being processed and
+    #         overrides the printed line once the result is known.
+    #
+    # @return [Bool] whether the specification passed validation.
+    #
+    def validate
+      @results  = []
+      unless disable_ui_output
+        print " -> #{spec ? spec.name : file.basename}\r" unless config.silent?
+        $stdout.flush
+      end
+
+      perform_linting
+
+      # begin
+      if spec
+        check_repo_path if repo_path
+        perform_extensive_analysis unless quick
+      end
+      # rescue Exception => e
+      #   error "The specification is malformed and crashed the linter."
+      # end
+
+      unless disable_ui_output
+        UI.puts " -> ".send(result_color) << (spec ? spec.name : file.basename.to_s)
+        print_results
+      end
+      validated?
+    end
+
+    def print_results
+      results.each do |result|
+        if result.platforms == [:ios]
+          platform_message = "[iOS] "
+        elsif result.platforms == [:osx]
+          platform_message = "[OSX] "
+        end
+
+      case result.type
+        when :error   then type = "ERROR"
+        when :warning then type = "WARN"
+        when :note    then type = "NOTE"
+        else raise "#{result.type}" end
+        UI.puts "    - #{type.ljust(5)} | #{platform_message}#{result.message}"
+      end
+      UI.puts
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # @!group Configuration
+
+    # @return [Bool] Whether the validator should print the results of the
+    #         validation. This is useful for clients which want to customize
+    #         output.
+    #
+    attr_accessor :disable_ui_output
+
+    # @return [Pathname] whether the validation should be performed against a repo.
+    #
+    attr_accessor :repo_path
+
+    # @return [Bool] whether the validation should skip the checks that
+    #         requires the download of the library.
+    #
+    attr_accessor :quick
+
+    # @return [Bool] whether the linter should not clean up temporary files
+    #         for inspection.
+    #
+    attr_accessor :no_clean
+
+    # @return [Bool] whether the validation should be performed against the root of
+    #         the podspec instead to its original source.
+    #
+    # @note   Uses the `:local` option of the Podfile.
+    #
+    attr_writer :local
+    def local?; @local; end
+
+    # @return [Bool] Whether the validator should fail only on errors or also
+    #         on warnings.
+    #
+    attr_accessor :only_errors
+
+    #-------------------------------------------------------------------------#
+
+    # !@group Lint results
+
+    #
+    #
+    attr_reader :results
+
+    # @return [Boolean]
+    #
+    def validated?
+      result_type != :error && (result_type != :warning || only_errors)
+    end
+
+    # @return [Symbol]
+    #
+    def result_type
+      types = results.map(&:type).uniq
+      if    types.include?(:error)   then :error
+      elsif types.include?(:warning) then :warning
+      else  :note end
+    end
+
+    # @return [Symbol]
+    #
+    def result_color
+      case result_type
+      when :error   then :red
+      when :warning then :yellow
+      else :green end
+    end
+
+    # @return [Pathname] the temporary directory used by the linter.
+    #
+    def validation_dir
+      Pathname.new('/tmp/CocoaPods/Lint')
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@group Lint steps
+
+    #
+    #
+    def perform_linting
+      linter.lint
+      @results.concat(linter.results)
+    end
+
+    #
+    #
+    def check_repo_path
+      expected_path = "#{spec.name}/#{spec.version}/#{spec.name}.podspec"
+      path = file.relative_path_from(repo_path).to_s
+      unless path == expected_path
+        error "Incorrect path, the path is `#{file}` and should be `#{expected_path}`"
+      end
+    end
+
+    #
+    #
+    def perform_extensive_analysis
+      spec.available_platforms.each do |platform|
+        UI.message "\n\n#{spec} - Analyzing on #{platform} platform.".green.reversed
+        @consumer = spec.consumer(platform)
+        setup_validation_environment
+        install_pod
+        build_pod
+        check_file_patterns
+        tear_down_validation_environment
+      end
+    end
+
+    attr_accessor :consumer
+
+    def setup_validation_environment
+      validation_dir.rmtree if validation_dir.exist?
+      validation_dir.mkpath
+      @original_config = Config.instance.clone
+      config.installation_root = validation_dir
+      config.sandbox_root      = validation_dir + 'Pods'
+      config.silent            = !config.verbose
+      config.integrate_targets = false
+      config.generate_docs     = false
+      config.skip_repo_update  = true
+    end
+
+    def tear_down_validation_environment
+      validation_dir.rmtree unless no_clean
+      Config.instance = @original_config
+    end
+
+    # It creates a podfile in memory and builds a library containing the pod
+    # for all available platforms with xcodebuild.
+    #
+    def install_pod
+      podfile = podfile_from_spec(consumer.platform_name, spec.deployment_target(consumer.platform_name))
+      sandbox = Sandbox.new(config.sandbox_root)
+      installer = Installer.new(sandbox, podfile)
+      installer.install!
+
+      file_accessors = installer.libraries.first.file_accessors
+      @file_accessor = file_accessors.find { |accessor| accessor.spec == spec }
+      config.silent
+    end
+
+    # Performs platform specific analysis. It requires to download the source
+    # at each iteration
+    #
+    # @note   Xcode warnings are treaded as notes because the spec maintainer
+    #         might not be the author of the library
+    #
+    # @return [void]
+    #
+    def build_pod
+      if `which xcodebuild`.strip.empty?
+        UI.warn "Skipping compilation with `xcodebuild' because it can't be found.\n".yellow
+      else
+        UI.message "\nBuilding with xcodebuild.\n".yellow do
+          output = Dir.chdir(config.sandbox_root) { xcodebuild }
+          UI.puts output
+          parsed_output  = parse_xcodebuild_output(output)
+          parsed_output.each do |message|
+            if message.include?('error: ')
+              error "[xcodebuild] #{message}"
+            else
+              note "[xcodebuild] #{message}"
+            end
+          end
+        end
+      end
+    end
+
+    # It checks that every file pattern specified in a spec yields
+    # at least one file. It requires the pods to be already present
+    # in the current working directory under Pods/spec.name.
+    #
+    # @return [void]
+    #
+    def check_file_patterns
+      [:source_files, :resources, :preserve_paths].each do |attr_name|
+        # file_attr = Specification::DSL.attributes.values.find{|attr| attr.name == attr_name }
+        if !file_accessor.spec_consumer.send(attr_name).empty? && file_accessor.send(attr_name).empty?
+          error "The `#{attr_name}` pattern did not match any file."
+        end
+      end
+
+      unless file_accessor.license || spec.license && ( spec.license[:type] == 'Public Domain' || spec.license[:text] )
+        warning "Unable to find a license file"
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@group Result Helpers
+
+    def error(message)
+      add_result(:error, message)
+    end
+
+    def warning(message)
+      add_result(:warning, message)
+    end
+
+    def note(message)
+      add_result(:note, message)
+    end
+
+    def add_result(type, message)
+      result = results.find { |r| r.type == type && r.message == message }
+      unless result
+        result = Specification::Linter::Result.new(type, message)
+        results << result
+      end
+      result.platforms << consumer.platform_name if consumer
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@group Helpers
+
+    # @return [Podfile] a podfile that requires the specification on the
+    # current platform.
+    #
+    # @note   The generated podfile takes into account whether the linter is
+    #         in local mode.
+    #
+    def podfile_from_spec(platform_name, deployment_target)
+      name     = spec.name
+      podspec  = file.realpath
+      local    = local?
+      podfile  = Pod::Podfile.new do
+        platform(platform_name, deployment_target)
+        if (local)
+          pod name, :local => podspec.dirname.to_s
+        else
+          pod name, :podspec => podspec.to_s
+        end
+      end
+      podfile
+    end
+
+    # Parse the xcode build output to identify the lines which are relevant
+    # to the linter.
+    #
+    # @param  [String] output the output generated by the xcodebuild tool.
+    #
+    # @note   The indentation and the temporary path is stripped form the
+    #         lines.
+    #
+    # @return [Array<String>] the lines that are relevant to the linter.
+    #
+    def parse_xcodebuild_output(output)
+      lines = output.split("\n")
+      selected_lines = lines.select do |l|
+        l.include?('error: ') &&
+          (l !~ /errors? generated\./) && (l !~ /error: \(null\)/)  ||
+          l.include?('warning: ') && (l !~ /warnings? generated\./) ||
+          l.include?('note: ') && (l !~ /expanded from macro/)
+      end
+      selected_lines.map do |l|
+        new = l.gsub(/\/tmp\/CocoaPods\/Lint\/Pods\//,'')
+        new.gsub!(/^ */,' ')
+      end
+    end
+
+    # @return [String] Executes xcodebuild in the current working directory and
+    #         returns its output (bot STDOUT and STDERR).
+    #
+    def xcodebuild
+      `xcodebuild clean build 2>&1`
+    end
+
+    #-------------------------------------------------------------------------#
+
+  end
+end