cocoapods-square-stable 0.19.3

data/lib/cocoapods/sandbox/file_accessor.rb

@@ -0,0 +1,217 @@
+module Pod
+  class Sandbox
+
+    # Resolves the file patterns of a specification against its root directory,
+    # taking into account any exclude pattern and the default extensions to use
+    # for directories.
+    #
+    # @note The FileAccessor always returns absolute paths.
+    #
+    class FileAccessor
+
+      HEADER_EXTENSIONS = Xcodeproj::Constants::HEADER_FILES_EXTENSIONS
+
+      # @return [Sandbox::PathList] the directory where the source of the Pod
+      #         is located.
+      #
+      attr_reader :path_list
+
+      # @return [Specification::Consumer] the consumer of the specification for
+      #         which the file patterns should be resolved.
+      #
+      attr_reader :spec_consumer
+
+      # @param [Sandbox::PathList] path_list @see path_list
+      # @param [Specification::Consumer] spec_consumer @see spec_consumer
+      #
+      def initialize(path_list, spec_consumer)
+        @path_list = path_list
+        @spec_consumer = spec_consumer
+
+        unless @spec_consumer
+          raise Informative, "Attempt to initialize File Accessor without a specification consumer."
+        end
+      end
+
+      # @return [Pathname] the directory which contains the files of the Pod.
+      #
+      def root
+        path_list.root
+      end
+
+      # @return [Specification] the specification.
+      #
+      def spec
+        spec_consumer.spec
+      end
+
+      # @return [Specification] the platform used to consume the specification.
+      #
+      def platform_name
+        spec_consumer.platform_name
+      end
+
+      # @return [String] A string suitable for debugging.
+      #
+      def inspect
+        "<#{self.class} spec=#{spec.name} platform=#{platform_name} root=#{path_list.root}>"
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Paths
+
+      # @return [Array<Pathname>] the source files of the specification.
+      #
+      def source_files
+        paths_for_attribute(:source_files)
+      end
+
+      # @return [Array<Pathname>] the headers of the specification.
+      #
+      def headers
+        extensions = HEADER_EXTENSIONS
+        source_files.select { |f| extensions.include?(f.extname) }
+      end
+
+      # @return [Array<Pathname>] the public headers of the specification.
+      #
+      def public_headers
+        public_headers = paths_for_attribute(:public_header_files)
+        private_headers = paths_for_attribute(:private_header_files)
+        if public_headers.nil? || public_headers.empty?
+          header_files = headers
+        else
+          header_files = public_headers
+        end
+        header_files - private_headers
+      end
+
+      # @return [Hash{ Symbol => Array<Pathname> }] the resources of the
+      #         specification grouped by destination.
+      #
+      def resources
+        paths_for_attribute(:resources, true)
+      end
+
+      # @return [Array<Pathname>] the files of the specification to preserve.
+      #
+      def preserve_paths
+        paths_for_attribute(:preserve_paths, true)
+      end
+
+      # @return [Pathname] The of the prefix header file of the specification.
+      #
+      def prefix_header
+        if spec_consumer.prefix_header_file
+          path_list.root + spec_consumer.prefix_header_file
+        end
+      end
+
+      # @return [Pathname] The path of the auto-detected README file.
+      #
+      def readme
+        path_list.glob(%w[ readme{*,.*} ]).first
+      end
+
+      # @return [Pathname] The path of the license file as indicated in the
+      #         specification or auto-detected.
+      #
+      def license
+        if spec_consumer.spec.root.license[:file]
+          path_list.root + spec_consumer.spec.root.license[:file]
+        else
+          path_list.glob(%w[ licen{c,s}e{*,.*} ]).first
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Private helpers
+
+      # Returns the list of the paths founds in the file system for the
+      # attribute with given name. It takes into account any dir pattern and
+      # any file excluded in the specification.
+      #
+      # @param  [Symbol] attribute
+      #         the name of the attribute.
+      #
+      # @return [Array<Pathname>] the paths.
+      #
+      def paths_for_attribute(attribute, include_dirs = false)
+        file_patterns = spec_consumer.send(attribute)
+        options = {
+          :exclude_patterns => spec_consumer.exclude_files,
+          :dir_pattern => glob_for_attribute(attribute),
+          :include_dirs => include_dirs,
+        }
+        expanded_paths(file_patterns, options)
+      end
+
+      # Returns the pattern to use to glob a directory for an attribute.
+      #
+      # @param  [Symbol] attribute
+      #         the name of the attribute
+      #
+      # @return [String] the glob pattern.
+      #
+      # @todo   Move to the cocoapods-core so it appears in the docs?
+      #
+      def glob_for_attribute(attrbute)
+        globs = {
+          :source_files => '*.{h,hpp,hh,m,mm,c,cpp}'.freeze,
+          :public_header_files => "*.{#{ HEADER_EXTENSIONS * ',' }}".freeze,
+        }
+        globs[attrbute]
+      end
+
+      # Matches the given patterns to the file present in the root of the path
+      # list.
+      #
+      # @param [Array<String, FileList>] patterns
+      #         The patterns to expand.
+      #
+      # @param  [String] dir_pattern
+      #         The pattern to add to directories.
+      #
+      # @param  [Array<String>] exclude_patterns
+      #         The exclude patterns to pass to the PathList.
+      #
+      # @raise  [Informative] If the pod does not exists.
+      #
+      # @return [Array<Pathname>] A list of the paths.
+      #
+      # @todo   Implement case insensitive search
+      #
+      def expanded_paths(patterns, options = {})
+        return [] if patterns.empty?
+
+        file_lists = patterns.select { |p| p.is_a?(FileList) }
+        glob_patterns = patterns - file_lists
+
+        result = []
+        result << path_list.glob(glob_patterns, options)
+        result << file_lists.map do |file_list|
+          file_list.prepend_patterns(path_list.root)
+          file_list.glob
+        end
+
+        unless file_lists.empty?
+          # TODO Restore warning in 0.17 proper
+          # UI.warn "[#{spec_consumer.spec.name}] The usage of Rake FileList is deprecated. Use `exclude_files`."
+        end
+
+        result.flatten.compact.uniq
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end
+
+

data/lib/cocoapods/sandbox/headers_store.rb

@@ -0,0 +1,96 @@
+module Pod
+  class Sandbox
+
+    # Provides support for managing a header directory. It also keeps track of
+    # the header search paths.
+    #
+    class HeadersStore
+
+      # @return [Pathname] the absolute path of this header directory.
+      #
+      def root
+        @sandbox.root + @relative_path
+      end
+
+      # @return [Sandbox] the sandbox where this header directory is stored.
+      #
+      attr_reader :sandbox
+
+      # @param  [Sandbox] @see sandbox
+      #
+      # @param  [String] relative_path
+      #         the relative path to the sandbox root and hence to the Pods
+      #         project.
+      #
+      def initialize(sandbox, relative_path)
+        @sandbox       = sandbox
+        @relative_path = relative_path
+        @search_paths  = [relative_path]
+      end
+
+      # @return [Array<String>] All the search paths of the header directory in
+      #         xcconfig format. The paths are specified relative to the pods
+      #         root with the `${PODS_ROOT}` variable.
+      #
+      def search_paths
+        @search_paths.uniq.map { |path| "${PODS_ROOT}/#{path}" }
+      end
+
+      # Removes the directory as it is regenerated from scratch during each
+      # installation.
+      #
+      # @return [void]
+      #
+      def implode!
+        root.rmtree if root.exist?
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Adding headers
+
+      # Adds a header to the directory.
+      #
+      # @param  [Pathname] namespace_path
+      #         the path where the header file should be stored relative to the
+      #         headers directory.
+      #
+      # @param  [Pathname] relative_header_path
+      #         the path of the header file relative to the sandbox.
+      #
+      # @note   This method adds the files to the search paths.
+      #
+      # @return [Pathname]
+      #
+      def add_files(namespace, relative_header_paths)
+        add_search_path(namespace)
+        namespaced_path = root + namespace
+        namespaced_path.mkpath unless File.exist?(namespaced_path)
+
+        relative_header_paths.map do |relative_header_path|
+          source = (@sandbox.root + relative_header_path).relative_path_from(namespaced_path)
+          Dir.chdir(namespaced_path) do
+            FileUtils.ln_sf(source, relative_header_path.basename)
+          end
+          namespaced_path + relative_header_path.basename
+        end
+      end
+
+      # Adds an header search path to the sandbox.
+      #
+      # @param  [Pathname] path
+      #         the path tho add.
+      #
+      # @return [void]
+      #
+      def add_search_path(path)
+        @search_paths << Pathname.new(@relative_path) + path
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end

data/lib/cocoapods/sandbox/path_list.rb

@@ -0,0 +1,208 @@
+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_accessor :root
+
+      # @param  [Pathname] root The root of the PathList.
+      #
+      def initialize(root)
+        @root = root
+      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
+        root_length  = root.to_s.length+1
+        escaped_root = escape_path_for_glob(root)
+        paths  = Dir.glob(escaped_root + "**/*", File::FNM_DOTMATCH)
+        absolute_dirs  = paths.select { |path| File.directory?(path) }
+        relative_dirs  = absolute_dirs.map  { |p| p[root_length..-1] }
+        absolute_paths = paths.reject { |p| p == "#{root}/." || p == "#{root}/.." }
+        relative_paths = absolute_paths.map { |p| p[root_length..-1] }
+        @files = relative_paths - relative_dirs
+        @dirs  = relative_dirs.map { |d| d.gsub(/\/\.\.?$/,'') }.reject { |d| d == '.' || d == '..' } .uniq
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Globbing
+
+      # @return [Array<Pathname>] Similar to {glob} but returns the absolute
+      #         paths.
+      #
+      def glob(patterns, options = {})
+        relative_glob(patterns, options).map {|p| root + p }
+      end
+
+      # @return [Array<Pathname>] 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  [String] dir_pattern
+      #         An optional pattern to append to a pattern, if it is the path
+      #         to a directory.
+      #
+      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
+
+        list = Array(patterns).map do |pattern|
+          if pattern.is_a?(String)
+            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|
+                if p.respond_to? 'force_encoding'
+                   p.force_encoding('UTF-8')
+                   path.force_encoding('UTF-8')
+                end
+                File.fnmatch(p, path, File::FNM_CASEFOLD | File::FNM_PATHNAME)
+              end
+            end
+          else
+            full_list.select { |path| path.match(pattern) }
+          end
+        end.flatten
+
+        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.map do |old_pattern|
+              values.map do |value|
+                old_pattern.gsub(set, value)
+              end
+            end.flatten
+          end
+          patterns
+        end
+      end
+
+      # Escapes the glob metacharacters from a given path so it can used in
+      # Dir#glob and similar methods.
+      #
+      # @note   See CocoaPods/CocoaPods#862.
+      #
+      # @param  [String, Pathname] path
+      #         The path to escape.
+      #
+      # @return [Pathname] The escaped path.
+      #
+      def escape_path_for_glob(path)
+        result = path.to_s
+        characters_to_escape = ['[', ']', '{', '}', '?', '*']
+        characters_to_escape.each do |character|
+          result.gsub!(character, "\\#{character}" )
+        end
+        Pathname.new(result)
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end