cocoapods-core 0.17.0.rc5 → 0.17.0.rc6

data/lib/cocoapods-core/source/acceptor.rb

@@ -0,0 +1,159 @@
+module Pod
+  class Source
+
+    # Checks whether a podspec can be accepted by a source. The check takes
+    # into account the introduction of 0.0.1 version if there are already
+    # tagged ones or whether there is change in the source.
+    #
+    class Acceptor
+
+      # @return [Source] the source where the podspec should be added.
+      #
+      attr_reader :source
+
+      # @param  [Pathname] repo @see Source#repo.
+      #
+      def initialize(repo)
+        @source = Source.new(repo)
+      end
+
+      public
+
+      # @!group Actions
+      #-----------------------------------------------------------------------#
+
+      # Checks whether the given specification can be accepted.
+      #
+      # @return [Array<String>] A list of errors. If the list is empty the
+      #         specification should be accepted.
+      #
+      def analyze(spec, previous_spec = nil)
+        errors = []
+        check_spec_source_change(spec, errors)
+        check_if_untagged_version_is_acceptable(spec, errors)
+        check_commit_change_for_untagged_version(spec, previous_spec, errors)
+        check_dependencies(spec, errors)
+        errors
+      end
+
+      # Checks whether the specification at the given path can be accepted.
+      #
+      # @return [Array<String>] A list of errors. If the list is empty the
+      #         specification should be accepted.
+      #
+      def analyze_path(spec_path)
+        spec = Specification.from_file(spec_path)
+        analyze(spec)
+      rescue
+        ["Unable to load the specification."]
+      end
+
+      private
+
+      # @!group Private helpers
+      #-----------------------------------------------------------------------#
+
+      # Checks whether the source of the proposed specification is different
+      # from the one of the reference specification.
+      #
+      # @return [void]
+      #
+      def check_spec_source_change(spec, errors)
+        return unless spec
+        return unless reference_spec(spec)
+        keys = Spec::DSL::SOURCE_KEYS.keys
+        source = spec.source.values_at(*keys).compact.first
+        old_source = reference_spec(spec).source.values_at(*keys).compact.first
+        unless source == old_source
+          errors << "The source of the spec doesn't match with the recorded ones." \
+            "Source: `#{source}`. Previous: `#{old_source}`.\n " \
+            "Please contact the specs repo maintainers if the library changed " \
+            "location."
+        end
+      end
+
+      # Checks there are already tagged specifications if the specification has
+      # a git source and doesn't specify a tag (i.e. rejects 0.0.1 specs if
+      # they are not admissible anymore).
+      #
+      # @return [void]
+      #
+      def check_if_untagged_version_is_acceptable(spec, errors)
+        return if !spec.source[:git] || spec.source[:tag]
+        return unless related_specifications(spec)
+        has_tagged_spec = related_specifications(spec).any? { |s| s.version != '0.0.1' }
+        if has_tagged_spec
+          errors << "There is already at least one versioned specification so " \
+            "untagged versions cannot be accepted."
+        end
+      end
+
+      # If the previous specification for the given file is passed it is
+      # checked for any attempt to update the commit of a 0.0.1 version.
+      #
+      # @return [void]
+      #
+      def check_commit_change_for_untagged_version(spec, previous_spec, errors)
+        return unless previous_spec
+        return unless spec.version == Version.new('0.0.1')
+        unless spec.source[:commit] == previous_spec.source[:commit]
+          errors << "Attempt to rewrite the commit of a 0.0.1 version."
+        end
+      end
+
+      # Checks that there is a specification available for the dependencies of
+      # the given specification.
+      #
+      # @return [void]
+      #
+      def check_dependencies(spec, errors)
+        spec.dependencies.each do |dep|
+          set = source.search(dep)
+          unless set && set.specification
+            errors << "Unable to find a specification for the `#{dep}` dependency."
+          end
+        end
+      end
+
+      private
+
+      # @!group Source helpers
+      #-----------------------------------------------------------------------#
+
+      # Returns the specifications related to the given spec.
+      #
+      # @param  [Specification] spec
+      #         The specification for which the siblings specs are needed.
+      #
+      # @return [Array<Specification>] The other specifications of the Pod.
+      #
+      # @return [Nil] If there are no other specifications stored.
+      #
+      def related_specifications(spec)
+        versions = source.versions(spec.name)
+        return unless versions
+        specs = versions.sort.map { |v| source.specification(spec.name, v) }
+        specs.delete(spec)
+        specs
+      end
+
+      # Returns the most representative specification for the Pod of the given
+      # spec.
+      #
+      # @param  [Specification] spec
+      #         The specification for which the representative spec is needed.
+      #
+      # @return [Specification] The specification with the highest version.
+      #
+      # @return [Nil] If there are no other specifications stored.
+      #
+      def reference_spec(spec)
+        specs = related_specifications(spec)
+        specs.last if specs
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end

data/lib/cocoapods-core/source/aggregate.rb

@@ -0,0 +1,229 @@
+module Pod
+  class Source
+
+    # The Aggregate manages a directory of sources repositories.
+    #
+    class Aggregate
+
+      # @return [Pathname] the directory were the repositories are stored.
+      #
+      attr_reader :repos_dir
+
+      # @param [Pathname] repos_dir @see repos_dir.
+      #
+      def initialize(repos_dir)
+        @repos_dir = repos_dir
+      end
+
+      # @return [Array<Source>] all the sources.
+      #
+      def all
+        @sources ||= dirs.map { |repo| Source.new(repo) }.sort_by(&:name)
+      end
+
+      # @return [Array<String>] the names of all the pods available.
+      #
+      def all_pods
+        all.map(&:pods).flatten.uniq
+      end
+
+      # @return [Array<Set>] the sets for all the pods available.
+      #
+      # @note   Implementation detail: The sources don't cache their values
+      #         because they might change in response to an update. Therefore
+      #         this method to prevent slowness caches the values before
+      #         processing them.
+      #
+      def all_sets
+        pods_by_source = {}
+        all.each do |source|
+          pods_by_source[source] = source.pods
+        end
+        sources = pods_by_source.keys
+        pods = pods_by_source.values.flatten.uniq
+
+        pods.map do |pod|
+          pod_sources = sources.select{ |s| pods_by_source[s].include?(pod) }.compact
+          Specification::Set.new(pod, pod_sources)
+        end
+      end
+
+      # @return [Array<Pathname>] the directories where the sources are stored.
+      #
+      # @note   If the repos dir doesn't exits this will return an empty array.
+      #
+      # @raise  If the repos dir doesn't exits.
+      #
+      def dirs
+        if repos_dir.exist?
+          repos_dir.children.select(&:directory?)
+        else
+          []
+        end
+      end
+
+      # Returns a set configured with the source which contains the highest
+      # version in the aggregate.
+      #
+      # @param  [String] name
+      #         The name of the Pod.
+      #
+      # @return [Set] The most representative set for the Pod with the given
+      #         name.
+      #
+      def represenative_set(name)
+        representative_source = nil
+        highest_version = nil
+        all.each do |source|
+          source_versions = source.versions(name)
+          if source_versions
+            source_version = source_versions.first
+            if highest_version.nil? || (highest_version < source_version)
+              highest_version = source_version
+              representative_source = source
+            end
+          end
+        end
+        Specification::Set.new(name, representative_source)
+      end
+
+      public
+
+      # @!group Search
+      #-----------------------------------------------------------------------#
+
+      # @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.
+      #
+      # @see    Source#search
+      #
+      def search(dependency)
+        sources = all.select { |s| !s.search(dependency).nil? }
+        Specification::Set.new(dependency.root_name, sources) unless sources.empty?
+      end
+
+      # @return [Array<Set>]  the sets that contain the search term.
+      #
+      # @raise  If no source including the set can be found.
+      #
+      # @todo   Clients should raise not this method.
+      #
+      # @see    Source#search_by_name
+      #
+      def search_by_name(query, full_text_search = false)
+        pods_by_source = {}
+        result = []
+        all.each { |s| pods_by_source[s] = s.search_by_name(query, full_text_search).map(&:name) }
+        root_spec_names = pods_by_source.values.flatten.uniq
+        root_spec_names.each do |pod|
+          sources = []
+          pods_by_source.each{ |source, pods| sources << source if pods.include?(pod) }
+          result << Specification::Set.new(pod, sources)
+        end
+        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
+
+      public
+
+      # @!group Search Index
+      #-----------------------------------------------------------------------#
+
+      # Generates from scratch the search data for all the sources of the
+      # aggregate. This operation can take a considerable amount of time
+      # (seconds) as it needs to evaluate the most representative podspec
+      # for each Pod.
+      #
+      # @return [Hash{String=>Hash}] The search data of every set grouped by
+      #         name.
+      #
+      def generate_search_index
+        result = {}
+        all_sets.each do |set|
+          result[set.name] = search_data_from_set(set)
+        end
+        result
+      end
+
+      # Updates inline the given search data with the information stored in all
+      # the sources. The update skips the Pods for which the version of the
+      # search data is the same of the highest version known to the aggregate.
+      # This can lead to updates in podspecs being skipped until a new version
+      # is released.
+      #
+      # @note   This procedure is considerably faster as it only needs to
+      #         load the most representative spec of the new or updated Pods.
+      #
+      # @return [Hash{String=>Hash}] The search data of every set grouped by
+      #         name.
+      #
+      def update_search_index(search_data)
+        enumerated_names = []
+        all_sets.each do |set|
+          enumerated_names << set.name
+          set_data = search_data[set.name]
+          has_data = set_data && set_data['version']
+          needs_update = !has_data || Version.new(set_data['version']) < set.required_version
+          if needs_update
+            search_data[set.name] = search_data_from_set(set)
+          end
+        end
+
+        stored_names = search_data.keys
+        delted_names = stored_names - enumerated_names
+        delted_names.each do |name|
+          search_data.delete(name)
+        end
+
+        search_data
+      end
+
+      private
+
+      # @!group Private helpers
+      #-----------------------------------------------------------------------#
+
+      # Returns the search related information from the most representative
+      # specification of the set following keys:
+      #
+      #   - version
+      #   - summary
+      #   - description
+      #   - authors
+      #
+      # @param  [Set] set
+      #         The set for which the information is needed.
+      #
+      # @note   If the specification can't load an empty hash is returned and
+      #         a warning is printed.
+      #
+      # @note   For compatibility with non Ruby clients a strings are used
+      #         instead of symbols for the keys.
+      #
+      # @return [Hash{String=>String}] A hash with the search information.
+      #
+      def search_data_from_set(set)
+        result = {}
+        spec = set.specification
+        result['version'] = spec.version.to_s
+        result['summary'] = spec.summary
+        result['description'] = spec.description
+        result['authors'] = spec.authors.keys.sort * ', '
+        result
+      rescue
+        CoreUI.warn "Skipping `#{set.name}` because the podspec contains errors."
+        result
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end

data/lib/cocoapods-core/source/health_reporter.rb

@@ -0,0 +1,208 @@
+module Pod
+  class Source
+
+    # Checks a source for errors and warnings.
+    #
+    class HealthReporter
+
+      # @return [Source] the source to check.
+      #
+      attr_reader :source
+
+      # @param  [Pathname] repo @see Source#repo.
+      #
+      def initialize(repo)
+        @source = Source.new(repo)
+        @errors = {}
+        @linter_results = {}
+      end
+
+      # @return [Bool] Whether the more strict validation of the master repo
+      #         should be used. Specifically The master repo treats certain
+      #         warnings as errors.
+      #
+      attr_accessor :master_repo_mode
+
+      public
+
+      # @!group Configuration
+      #-----------------------------------------------------------------------#
+
+      # Allows to specify an optional callback which is called before
+      # analysing every spec. Suitable for UI.
+      #
+      # @param  [Proc] A callback which is called before checking any
+      #         specification. It receives the name and the version of the
+      #         spec.
+      #
+      # @return [void]
+      #
+      def pre_check(&block)
+        @pre_check_callback = block
+      end
+
+      public
+
+      # @!group Actions
+      #-----------------------------------------------------------------------#
+
+      # Analyzes all the specification files in the source.
+      #
+      # @return [HealthReport] A report which contains the information about the
+      #         state of the source.
+      #
+      def analyze
+        @report = HealthReport.new(source)
+
+        source.pods.each do |name|
+          source.versions(name).each do |version|
+            @pre_check_callback.call(name, version) if @pre_check_callback
+            spec_path = source.specification_path(name, version)
+            spec = lint_spec(name, version, spec_path)
+            check_spec_path(name, version, spec) if spec
+            report.analyzed_paths << spec_path
+          end
+        end
+
+        check_stray_specs
+        report
+      end
+
+      # @return [HealtReport] The report produced by the analysis.
+      #
+      attr_reader :report
+
+      private
+
+      # @!group Private helpers
+      #-----------------------------------------------------------------------#
+
+      # Checks the validity of the specification with the linter.
+      #
+      # @param  [String] name
+      #         The name of the Pod.
+      #
+      # @param  [Version] version
+      #         The version of the specification.
+      #
+      # @param  [Pathname] spec_path
+      #         The path of the specification to check.
+      #
+      # @return [Specification] The specification loaded by the linter.
+      # @return [Nil] If the specifications raised during evaluation.
+      #
+      def lint_spec(name, version, spec_path)
+        linter = Specification::Linter.new(spec_path)
+        linter.master_repo_mode = master_repo_mode
+        linter.lint
+        linter.results.each do |result|
+          type = result.type == :error ? :error : :warning
+          report.add_message(type, result.message, name, version)
+        end
+        linter.spec
+      end
+
+      # Ensures that the name and the version of the specification correspond
+      # to the ones expected by the repo given its path.
+      #
+      # @param  [String] name
+      #         The name of the Pod.
+      #
+      # @param  [Version] version
+      #         The version of the specification.
+      #
+      # @param  [Specification] spec
+      #         The specification to check.
+      #
+      # @return [void]
+      #
+      def check_spec_path(name, version, spec)
+        unless spec.name == name && spec.version == version
+          report.add_message(:error, "Incorrect path", name)
+        end
+      end
+
+      # Checks for any stray specification in the repo.
+      #
+      # @param  [Array<Pathname>] analyzed_paths
+      #         The specification to check.
+      #
+      # @return [void]
+      #
+      def check_stray_specs
+        all_paths = Pathname.glob(source.repo + '**/*.podspec{,.yaml}')
+        stray_specs = all_paths - report.analyzed_paths
+        stray_specs.each do |path|
+          report.add_message(:error, "Stray spec", path)
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # Encapsulates the information about the state of a repo.
+      #
+      class HealthReport
+
+        # @return [Source] the source analyzed.
+        #
+        attr_reader :source
+
+        # @param [Source] @see source.
+        #
+        def initialize(source)
+          @source = source
+          @analyzed_paths = []
+          @pods_by_error = {}
+          @pods_by_warning = {}
+        end
+
+        # @return [Array<Pathname>] The list of the analyzed paths.
+        #
+        attr_accessor :analyzed_paths
+
+        # @return [Hash{ String => Hash }] The pods (the version grouped by
+        #         name) grouped by an error message.
+        #
+        attr_accessor :pods_by_error
+
+        # @return [Hash{ String => Hash }] The pods (the version grouped by
+        #         name) grouped by a warning message.
+        #
+        attr_accessor :pods_by_warning
+
+        # Adds a message with the given type for the specification with the
+        # given name and version.
+        #
+        # @param  [Symbol] type
+        #         The type of message. Either `:error` or `:warning`.
+        #
+        # @param  [String] message
+        #         The contents of the message.
+        #
+        # @param  [String] spec_name
+        #         The name of the Pod.
+        #
+        # @param  [String] spec_version
+        #         The version of the specification.
+        #
+        # @return [void]
+        #
+        def add_message(type, message, spec_name, spec_version = nil)
+          if type == :error
+            pods_by_error[message] ||= {}
+            pods_by_error[message][spec_name] ||= []
+            pods_by_error[message][spec_name] << spec_version
+          else
+            pods_by_warning[message] ||= {}
+            pods_by_warning[message][spec_name] ||= []
+            pods_by_warning[message][spec_name] << spec_version
+          end
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end
+