xcocoapods 1.5.3

data/lib/cocoapods/sandbox/path_list.rb

@@ -0,0 +1,220 @@
+require 'active_support/multibyte/unicode'
+require 'find'
+
+module Pod
+  class Sandbox
+    # The PathList class is designed to perform multiple glob matches against
+    # a given directory. Basically, it generates a list of all the children
+    # paths and matches the globs patterns against them, resulting in just one
+    # access to the file system.
+    #
+    # @note   A PathList once it has generated the list of the paths this is
+    #         updated only if explicitly requested by calling
+    #         {#read_file_system}
+    #
+    class PathList
+      # @return [Pathname] The root of the list whose files and directories
+      #         are used to perform the matching operations.
+      #
+      attr_reader :root
+
+      # Initialize a new instance
+      #
+      # @param  [Pathname] root @see #root
+      #
+      def initialize(root)
+        root_dir = ActiveSupport::Multibyte::Unicode.normalize(root.to_s)
+        @root = Pathname.new(root_dir)
+        @glob_cache = {}
+      end
+
+      # @return [Array<String>] The list of absolute the path of all the files
+      #         contained in {root}.
+      #
+      def files
+        read_file_system unless @files
+        @files
+      end
+
+      # @return [Array<String>] The list of absolute the path of all the
+      #         directories contained in {root}.
+      #
+      def dirs
+        read_file_system unless @dirs
+        @dirs
+      end
+
+      # @return [void] Reads the file system and populates the files and paths
+      #         lists.
+      #
+      def read_file_system
+        unless root.exist?
+          raise Informative, "Attempt to read non existent folder `#{root}`."
+        end
+
+        dirs = []
+        files = []
+        root_length = root.cleanpath.to_s.length + File::SEPARATOR.length
+        Find.find(root.to_s) do |f|
+          directory = File.directory?(f)
+          f = f.slice(root_length, f.length - root_length)
+          next if f.nil?
+
+          (directory ? dirs : files) << f
+        end
+
+        dirs.sort_by!(&:upcase)
+        files.sort_by!(&:upcase)
+
+        @dirs = dirs
+        @files = files
+        @glob_cache = {}
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Globbing
+
+      # Similar to {glob} but returns the absolute paths.
+      #
+      # @param  [String,Array<String>] patterns
+      #         @see #relative_glob
+      #
+      # @param  [Hash] options
+      #         @see #relative_glob
+      #
+      # @return [Array<Pathname>]
+      #
+      def glob(patterns, options = {})
+        cache_key = options.merge(:patterns => patterns)
+        @glob_cache[cache_key] ||= relative_glob(patterns, options).map { |p| root.join(p) }
+      end
+
+      # The list of relative paths that are case insensitively matched by a
+      # given pattern. This method emulates {Dir#glob} with the
+      # {File::FNM_CASEFOLD} option.
+      #
+      # @param  [String,Array<String>] patterns
+      #         A single {Dir#glob} like pattern, or a list of patterns.
+      #
+      # @param  [Hash] options
+      #
+      # @option options [String] :dir_pattern
+      #         An optional pattern to append to a pattern, if it is the path
+      #         to a directory.
+      #
+      # @option options [Array<String>] :exclude_patterns
+      #         Exclude specific paths given by those patterns.
+      #
+      # @option options [Array<String>] :include_dirs
+      #         Additional paths to take into account for matching.
+      #
+      # @return [Array<Pathname>]
+      #
+      def relative_glob(patterns, options = {})
+        return [] if patterns.empty?
+
+        dir_pattern = options[:dir_pattern]
+        exclude_patterns = options[:exclude_patterns]
+        include_dirs = options[:include_dirs]
+
+        if include_dirs
+          full_list = files + dirs
+        else
+          full_list = files
+        end
+        patterns_array = Array(patterns)
+        exact_matches = (full_list & patterns_array).to_set
+
+        unless patterns_array.empty?
+          list = patterns_array.flat_map do |pattern|
+            if exact_matches.include?(pattern)
+              pattern
+            else
+              if directory?(pattern) && dir_pattern
+                pattern += '/' unless pattern.end_with?('/')
+                pattern += dir_pattern
+              end
+              expanded_patterns = dir_glob_equivalent_patterns(pattern)
+              full_list.select do |path|
+                expanded_patterns.any? do |p|
+                  File.fnmatch(p, path, File::FNM_CASEFOLD | File::FNM_PATHNAME)
+                end
+              end
+            end
+          end
+        end
+
+        list = list.map { |path| Pathname.new(path) }
+        if exclude_patterns
+          exclude_options = { :dir_pattern => '**/*', :include_dirs => include_dirs }
+          list -= relative_glob(exclude_patterns, exclude_options)
+        end
+        list
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Private helpers
+
+      # @return [Bool] Wether a path is a directory. The result of this method
+      #         computed without accessing the file system and is case
+      #         insensitive.
+      #
+      # @param  [String, Pathname] sub_path The path that could be a directory.
+      #
+      def directory?(sub_path)
+        sub_path = sub_path.to_s.downcase.sub(/\/$/, '')
+        dirs.any? { |dir| dir.downcase == sub_path }
+      end
+
+      # @return [Array<String>] An array of patterns converted from a
+      #         {Dir.glob} pattern to patterns that {File.fnmatch} can handle.
+      #         This is used by the {#relative_glob} method to emulate
+      #         {Dir.glob}.
+      #
+      #   The expansion provides support for:
+      #
+      #   - Literals
+      #
+      #       dir_glob_equivalent_patterns('{file1,file2}.{h,m}')
+      #       => ["file1.h", "file1.m", "file2.h", "file2.m"]
+      #
+      #   - Matching the direct children of a directory with `**`
+      #
+      #       dir_glob_equivalent_patterns('Classes/**/file.m')
+      #       => ["Classes/**/file.m", "Classes/file.m"]
+      #
+      # @param [String] pattern   A {Dir#glob} like pattern.
+      #
+      def dir_glob_equivalent_patterns(pattern)
+        pattern = pattern.gsub('/**/', '{/**/,/}')
+        values_by_set = {}
+        pattern.scan(/\{[^}]*\}/) do |set|
+          values = set.gsub(/[{}]/, '').split(',')
+          values_by_set[set] = values
+        end
+
+        if values_by_set.empty?
+          [pattern]
+        else
+          patterns = [pattern]
+          values_by_set.each do |set, values|
+            patterns = patterns.flat_map do |old_pattern|
+              values.map do |value|
+                old_pattern.gsub(set, value)
+              end
+            end
+          end
+          patterns
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+    end
+  end
+end

data/lib/cocoapods/sandbox/pod_dir_cleaner.rb

@@ -0,0 +1,85 @@
+module Pod
+  class Sandbox
+    class PodDirCleaner
+      attr_reader :root
+      attr_reader :specs_by_platform
+
+      def initialize(root, specs_by_platform)
+        @root = root
+        @specs_by_platform = specs_by_platform
+      end
+
+      # Removes all the files not needed for the installation according to the
+      # specs by platform.
+      #
+      # @return [void]
+      #
+      def clean!
+        clean_paths.each { |path| FileUtils.rm_rf(path) } if root.exist?
+      end
+
+      private
+
+      # @return [Array<Sandbox::FileAccessor>] the file accessors for all the
+      #         specifications on their respective platform.
+      #
+      def file_accessors
+        @file_accessors ||= specs_by_platform.flat_map do |platform, specs|
+          specs.flat_map { |spec| Sandbox::FileAccessor.new(path_list, spec.consumer(platform)) }
+        end
+      end
+
+      # @return [Sandbox::PathList] The path list for this Pod.
+      #
+      def path_list
+        @path_list ||= Sandbox::PathList.new(root)
+      end
+
+      # Finds the absolute paths, including hidden ones, of the files
+      # that are not used by the pod and thus can be safely deleted.
+      #
+      # @note   Implementation detail: Don't use `Dir#glob` as there is an
+      #         unexplained issue (#568, #572 and #602).
+      #
+      # @todo   The paths are down-cased for the comparison as issues similar
+      #         to #602 lead the files not being matched and so cleaning all
+      #         the files. This solution might create side effects.
+      #
+      # @return [Array<Strings>] The paths that can be deleted.
+      #
+      def clean_paths
+        cached_used = used_files
+        glob_options = File::FNM_DOTMATCH | File::FNM_CASEFOLD
+        files = Pathname.glob(root + '**/*', glob_options).map(&:to_s)
+
+        files.reject do |candidate|
+          candidate = candidate.downcase
+          candidate.end_with?('.', '..') || cached_used.any? do |path|
+            path = path.downcase
+            path.include?(candidate) || candidate.include?(path)
+          end
+        end
+      end
+
+      # @return [Array<String>] The absolute path of all the files used by the
+      #         specifications (according to their platform) of this Pod.
+      #
+      def used_files
+        files = [
+          file_accessors.map(&:vendored_frameworks),
+          file_accessors.map(&:vendored_libraries),
+          file_accessors.map(&:resource_bundle_files),
+          file_accessors.map(&:license),
+          file_accessors.map(&:prefix_header),
+          file_accessors.map(&:preserve_paths),
+          file_accessors.map(&:readme),
+          file_accessors.map(&:resources),
+          file_accessors.map(&:source_files),
+          file_accessors.map(&:module_map),
+        ]
+
+        files.flatten.compact.map(&:to_s).uniq
+      end
+    end
+  end
+end

data/lib/cocoapods/sandbox/podspec_finder.rb

@@ -0,0 +1,23 @@
+module Pod
+  class Sandbox
+    class PodspecFinder
+      attr_reader :root
+
+      def initialize(root)
+        @root = root
+      end
+
+      def podspecs
+        return @specs_by_name if @specs_by_name
+        @specs_by_name = {}
+        spec_files = Pathname.glob(root + '{,*}.podspec{,.json}')
+        spec_files.sort_by { |p| -p.to_path.split(File::SEPARATOR).size }.each do |file|
+          spec = Specification.from_file(file)
+          spec.validate_cocoapods_version
+          @specs_by_name[spec.name] = spec
+        end
+        @specs_by_name
+      end
+    end
+  end
+end

data/lib/cocoapods/sources_manager.rb

@@ -0,0 +1,157 @@
+require 'cocoapods-core/source'
+require 'set'
+
+module Pod
+  class Source
+    class Manager
+      # Returns the source whose {Source#url} is equal to `url`, adding the repo
+      # in a manner similarly to `pod repo add` if it is not found.
+      #
+      # @raise  If no source with the given `url` could be created,
+      #
+      # @return [Source] The source whose {Source#url} is equal to `url`,
+      #
+      # @param  [String] url
+      #         The URL of the source.
+      #
+      def find_or_create_source_with_url(url)
+        unless source = source_with_url(url)
+          name = name_for_url(url)
+          # Hack to ensure that `repo add` output is shown.
+          previous_title_level = UI.title_level
+          UI.title_level = 0
+          begin
+            if name =~ /^master(-\d+)?$/
+              Command::Setup.parse([]).run
+            else
+              Command::Repo::Add.parse([name, url]).run
+            end
+          rescue Informative => e
+            message = "Unable to add a source with url `#{url}` " \
+              "named `#{name}`.\n"
+            message << "(#{e})\n" if Config.instance.verbose?
+            message << 'You can try adding it manually in ' \
+              "`#{Config.instance.repos_dir}` or via `pod repo add`."
+            raise Informative, message
+          ensure
+            UI.title_level = previous_title_level
+          end
+          source = source_with_url(url)
+        end
+
+        raise "Unable to create a source with URL #{url}" unless source
+
+        source
+      end
+
+      # Returns the source whose {Source#name} or {Source#url} is equal to the
+      # given `name_or_url`.
+      #
+      # @return [Source] The source whose {Source#name} or {Source#url} is equal to the
+      #                  given `name_or_url`.
+      #
+      # @param  [String] name_or_url
+      #                  The name or the URL of the source.
+      #
+      def source_with_name_or_url(name_or_url)
+        all.find { |s| s.name == name_or_url } ||
+          find_or_create_source_with_url(name_or_url)
+      end
+
+      # @return [Pathname] The path where the search index should be stored.
+      #
+      def search_index_path
+        @search_index_path ||= Config.instance.search_index_file
+      end
+
+      # @!group Updating Sources
+
+      # 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] source_name
+      #
+      # @param  [Bool] show_output
+      #
+      # @return [void]
+      #
+      def update(source_name = nil, show_output = false)
+        if source_name
+          sources = [git_source_named(source_name)]
+        else
+          sources =  git_sources
+        end
+
+        changed_spec_paths = {}
+        sources.each do |source|
+          UI.section "Updating spec repo `#{source.name}`" do
+            changed_source_paths = source.update(show_output)
+            changed_spec_paths[source] = changed_source_paths if changed_source_paths.count > 0
+            source.verify_compatibility!
+          end
+        end
+        # Perform search index update operation in background.
+        update_search_index_if_needed_in_background(changed_spec_paths)
+      end
+    end
+
+    extend Executable
+    executable :git
+
+    def git(args, include_error: false)
+      Executable.capture_command('git', args, :capture => include_error ? :merge : :out).first.strip
+    end
+
+    def update_git_repo(show_output = false)
+      Config.instance.with_changes(:verbose => show_output) do
+        args = %W(-C #{repo} fetch origin)
+        args.push('--progress') if show_output
+        git!(args)
+        current_branch = git!(%W(-C #{repo} rev-parse --abbrev-ref HEAD)).strip
+        git!(%W(-C #{repo} reset --hard origin/#{current_branch}))
+      end
+    rescue
+      raise Informative, 'CocoaPods was not able to update the ' \
+        "`#{name}` repo. If this is an unexpected issue " \
+        'and persists you can inspect it running ' \
+        '`pod repo update --verbose`'
+    end
+  end
+
+  class MasterSource
+    def update_git_repo(show_output = false)
+      if repo.join('.git', 'shallow').file?
+        UI.info "Performing a deep fetch of the `#{name}` specs repo to improve future performance" do
+          git!(%W(-C #{repo} fetch --unshallow))
+        end
+      end
+      super
+    end
+
+    def verify_compatibility!
+      super
+      latest_cocoapods_version = metadata.latest_cocoapods_version && Gem::Version.create(metadata.latest_cocoapods_version)
+      return unless Config.instance.new_version_message? &&
+        latest_cocoapods_version &&
+        latest_cocoapods_version > Gem::Version.new(Pod::VERSION)
+
+      rc = latest_cocoapods_version.prerelease?
+      install_message = !Pathname(__FILE__).dirname.writable? ? 'sudo ' : ''
+      install_message << 'gem install cocoapods'
+      install_message << ' --pre' if rc
+      message = [
+        '',
+        "CocoaPods #{latest_cocoapods_version} is available.".green,
+        "To update use: `#{install_message}`".green,
+        ("[!] This is a test version we'd love you to try.".yellow if rc),
+        '',
+        'For more information, see https://blog.cocoapods.org ' \
+        'and the CHANGELOG for this version at ' \
+        "https://github.com/CocoaPods/CocoaPods/releases/tag/#{latest_cocoapods_version}".green,
+        '',
+        '',
+      ].compact.join("\n")
+      UI.puts(message)
+    end
+  end
+end