cocoapods-core 0.17.0.rc1

data/lib/cocoapods-core/specification/set/presenter.rb

@@ -0,0 +1,229 @@
+require 'active_support/core_ext/array/conversions'
+
+module Pod
+  class Specification
+    class Set
+
+      # Provides support for presenting a Pod described by a {Set} in a
+      # consistent way across clients of CocoaPods-Core.
+      #
+      class Presenter
+
+        # @return   [Set] the set that should be presented.
+        #
+        attr_accessor :set
+
+        # @param    [Set] set @see #set.
+        #
+        def initialize(set)
+          @set = set
+        end
+
+        #-----------------------------------------------------------------------#
+
+        # @!group Set Information
+
+        # @return   [String] the name of the Pod.
+        #
+        def name
+          @set.name
+        end
+
+        # @return   [Version] the highest version of available for the Pod.
+        #
+        def version
+          @set.versions.first
+        end
+
+        # @return   [Array<Version>] all the versions available sorted
+        #           ascendingly.
+        #
+        def versions
+          @set.versions.sort.reverse
+        end
+
+        # @return   [String] all the versions available sorted from the highest
+        #           to the lowest.
+        #
+        # @example  Return example
+        #
+        #           "1.5pre, 1.4 [master repo] - 1.4 [test_repo repo]"
+        #
+        # @note     This method orders the sources by name.
+        #
+        def verions_by_source
+          result = []
+          versions_by_source = @set.versions_by_source
+          @set.sources.sort.each do |source|
+            versions = versions_by_source[source]
+            result << "#{versions.map(&:to_s) * ', '} [#{source.name} repo]"
+          end
+          result * ' - '
+        end
+
+        # @return [Array<String>] The name of the sources that contain the Pod
+        #         sorted alphabetically.
+        #
+        def sources
+          @set.sources.map(&:name).sort
+        end
+
+        #-----------------------------------------------------------------------#
+
+        # @!group Specification Information
+
+        # @return [Specification] the specification of the {Set}. If no
+        #         versions requirements where passed to the set it returns the
+        #         highest available version.
+        #
+        def spec
+          @set.specification
+        end
+
+        # @return   [String] the list of the authors of the Pod in sentence
+        #           format.
+        #
+        # @example  Output example
+        #
+        #           "Author 1, Author 2 and Author 3"
+        #
+        # @note     In ruby 1.8.7 the authors are sorted by name because the
+        #           hash doesn't preserve the order in which they are defined
+        #           in the podspec.
+        #
+        def authors
+          return '' unless spec.authors
+          if RUBY_VERSION == '1.8.7'
+            spec.authors.keys.sort.to_sentence
+          else
+            spec.authors.keys.to_sentence
+          end
+        end
+
+        # @return [String] the homepage of the pod.
+        #
+        def homepage
+          spec.homepage
+        end
+
+        # @return [String] a short description, expected to be 140 characters
+        #         long of the Pod.
+        #
+        def summary
+          spec.summary
+        end
+
+        # @return [String] the description of the Pod, if no description is
+        #         available the summary is returned.
+        #
+        def description
+          spec.description || spec.summary
+        end
+
+        # @return [String] the URL of the source of the Pod.
+        #
+        def source_url
+          url_keys = [:git, :svn, :http, :hg, :local ]
+          key = spec.source.keys.find { |k| url_keys.include?(k) }
+          key ? spec.source[key] : 'No source url'
+        end
+
+        # @return [String] the platforms supported by the Pod.
+        #
+        # @example
+        #
+        #   "iOS"
+        #   "iOS - OS X"
+        #
+        def platform
+          spec.available_platforms.sort { |a,b| a.to_s.downcase <=> b.to_s.downcase }.join(' - ')
+        end
+
+        # @return [String] the type of the license of the Pod.
+        #
+        # @example
+        #
+        #   "MIT"
+        #
+        def license
+          spec.license[:type] if spec.license
+        end
+
+        # @return [Array] an array containing all the subspecs of the Pod.
+        #
+        def subspecs
+          (spec.recursive_subspecs.any? && spec.recursive_subspecs) || nil
+        end
+
+        #-----------------------------------------------------------------------#
+
+        # @!group Statistics
+
+        # @return [Time] the creation date of the first known `podspec` of the
+        #         Pod.
+        #
+        def creation_date
+          Statistics.instance.creation_date(@set)
+        end
+
+        # @return [Integer] the GitHub likes of the repo of the Pod.
+        #
+        def github_watchers
+          Statistics.instance.github_watchers(@set)
+        end
+
+        # @return [Integer] the GitHub forks of the repo of the Pod.
+        #
+        def github_forks
+          Statistics.instance.github_forks(@set)
+        end
+
+        # @return [String] the relative time of the last push of the repo the Pod.
+        #
+        def github_last_activity
+          distance_from_now_in_words(Statistics.instance.github_pushed_at(@set))
+        end
+
+        #-----------------------------------------------------------------------#
+
+        private
+
+        # Computes a human readable string that represents a past date in
+        # relative terms.
+        #
+        # @param    [Time, String] from_time
+        #           the date that should be represented.
+        #
+        # @example  Possible outputs
+        #
+        #           "less than a week ago"
+        #           "15 days ago"
+        #           "3 month ago"
+        #           "more than a year ago"
+        #
+        # @return   [String] a string that represents a past date.
+        #
+        def distance_from_now_in_words(from_time)
+          return nil unless from_time
+          from_time = Time.parse(from_time) unless from_time.is_a?(Time)
+          to_time = Time.now
+          distance_in_days = (((to_time - from_time).abs)/60/60/24).round
+
+          case distance_in_days
+          when 0..7
+            "less than a week ago"
+          when 8..29
+            "#{distance_in_days} days ago"
+          when 30..45
+            "1 month ago"
+          when 46..365
+            "#{(distance_in_days.to_f / 30).round} months ago"
+          else
+            "more than a year ago"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/cocoapods-core/specification/set/statistics.rb

@@ -0,0 +1,277 @@
+module Pod
+  class Specification
+    class Set
+
+      # The statistics class provides information about one or more {Set} that
+      # is not readily available because expensive to compute or provided by a
+      # remote source.
+      #
+      # The class provides also facilities to work with a collection of sets.
+      # It always caches in memory the computed values and it can take an
+      # optional path to cache file that it is responsible of populating and
+      # invalidating.
+      #
+      # To reuse the in memory cache and to minimize the disk access to the
+      # cache file a shared instance is also available.
+      #
+      class Statistics
+
+        # @return [Statistics] the shared statistics instance.
+        #
+        def self.instance
+          @instance ||= new
+        end
+
+        # Allows to set the shared instance.
+        #
+        # @param  [Statistics] instance
+        #         the new shared instance or nil.
+        #
+        # @return [Statistics] the shared statistics instance.
+        #
+        def self.instance=(instance)
+          @instance = instance
+        end
+
+        # @return [Pathname] the path to the optional cache file.
+        #
+        # @note   The cache file can be specified after initialization, but
+        #         it has to be configured before requiring any value, otherwise
+        #         it is ignored.
+        #
+        attr_accessor :cache_file
+
+        # @return [Integer] the number of seconds after which the caches of
+        #         values that might changed are discarded.
+        #
+        # @note   If not specified on initialization defaults to 3 days.
+        #
+        attr_accessor :cache_expiration
+
+        # @param  [Pathname] cache_file       @see cache_file
+        #
+        # @param  [Integer] cache_expiration  @see cache_expiration
+        #
+        def initialize(cache_file = nil, cache_expiration = (60 * 60 * 24 * 3))
+          require 'yaml'
+          # This is to make sure Faraday doesn't warn the user about the
+          # `system_timer` gem missing.
+          old_warn, $-w = $-w, nil
+          begin
+            require 'faraday'
+          ensure
+            $-w = old_warn
+          end
+          require 'octokit'
+
+          @cache_file       = cache_file
+          @cache_expiration = cache_expiration
+        end
+
+        #---------------------------------------------------------------------#
+
+        # @!group Accessing the statistics
+
+        # Computes the date in which the first podspec of a set was committed
+        # on its git source.
+        #
+        # @param  [Set] set
+        #         the set for the Pod whose creation date is needed.
+        #
+        # @note   The set should be generated with only the source that is
+        #         analyzed. If there are more than one the first one is
+        #         processed.
+        #
+        # @note   This method needs to traverse the git history of the repo and
+        #         thus incurs in a performance hit.
+        #
+        # @return [Time] the date in which a Pod appeared for the first time on
+        #         the {Source}.
+        #
+        def creation_date(set)
+          date = compute_creation_date(set)
+          save_cache
+          date
+        end
+
+        # Computes the date in which the first podspec of each given set was
+        # committed on its git source.
+        #
+        # @param  [Array<Set>] sets
+        #         the list of the sets for the Pods whose creation date is
+        #         needed.
+        #
+        # @note   @see creation_date
+        #
+        # @note   This method is optimized for multiple sets because it saves
+        #         the cache file only once.
+        #
+        # @return [Array<Time>] the list of the dates in which the Pods
+        #         appeared for the first time on the {Source}.
+        #
+        def creation_dates(sets)
+          dates = {}
+          sets.each { |set| dates[set.name] = compute_creation_date(set) }
+          save_cache
+          dates
+        end
+
+        # Computes the number of likes that a Pod has on Github.
+        #
+        # @param  [Set] set
+        #         the set of the Pod.
+        #
+        # @return [Integer] the number of likes or nil if the Pod is not hosted
+        #         on GitHub.
+        #
+        def github_watchers(set)
+          github_stats_if_needed(set)
+          get_value(set, :gh_watchers)
+        end
+
+        # Computes the number of forks that a Pod has on Github.
+        #
+        # @param  [Set] set @see github_watchers
+        #
+        # @return [Integer] the number of forks or nil if the Pod is not hosted
+        #         on GitHub.
+        #
+        def github_forks(set)
+          github_stats_if_needed(set)
+          get_value(set, :gh_forks)
+        end
+
+        # Computes the number of likes that a Pod has on Github.
+        #
+        # @param  [Set] set @see github_watchers
+        #
+        # @return [Time] the time of the last push or nil if the Pod is not
+        #         hosted on GitHub.
+        #
+        def github_pushed_at(set)
+          github_stats_if_needed(set)
+          string_time = get_value(set, :pushed_at)
+          Time.parse(string_time) if string_time
+        end
+
+        #---------------------------------------------------------------------#
+
+        private
+
+        # @return [Hash{String => Hash}] the in-memory cache, where for each
+        #         set is stored a hash with the result of the computations.
+        #
+        def cache
+          unless @cache
+            if cache_file && cache_file.exist?
+              @cache = YAML.load(cache_file.read)
+            else
+              @cache = {}
+            end
+          end
+          @cache
+        end
+
+        # Returns the value for the given key of a set stored in the cache, if
+        # available.
+        #
+        # @param  [Set] set
+        #         the set for which the value is needed.
+        #
+        # @param  [Symbol] key
+        #         the key of the value.
+        #
+        # @return [Object] the value or nil.
+        #
+        def get_value(set, key)
+          if cache[set.name] && cache[set.name][key]
+            cache[set.name][key]
+          end
+        end
+
+        # Stores the given value of a set for the given key in the cache.
+        #
+        # @param  [Set] set
+        #         the set for which the value has to be stored.
+        #
+        # @param  [Symbol] key
+        #         the key of the value.
+        #
+        # @param  [Object] value
+        #         the value to store.
+        #
+        # @return [Object] the value or nil.
+        #
+        def set_value(set, key, value)
+          cache[set.name] ||= {}
+          cache[set.name][key] = value
+        end
+
+        # Saves the in-memory cache to the path of cache file if specified.
+        #
+        # @return [void]
+        #
+        def save_cache
+          if cache_file
+            yaml = YAML.dump(cache)
+            File.open(cache_file, 'w') { |f| f.write(yaml) }
+          end
+        end
+
+        # Analyzes the history of the git repository of the {Source} of the
+        # given {Set} to find when its folder was created.
+        #
+        # @param  [Set] set
+        #         the set for which the creation date is needed.
+        #
+        # @return [Time] the date in which a Pod was created.
+        #
+        def compute_creation_date(set)
+          date = get_value(set, :creation_date)
+          unless date
+            Dir.chdir(set.sources.first.repo) do
+              git_log   = `git log --first-parent --format=%ct #{set.name}`
+              creation_date = git_log.split("\n").last.to_i
+              date = Time.at(creation_date)
+            end
+            set_value(set, :creation_date, date)
+          end
+          date
+        end
+
+        # Retrieved the GitHub information from the API for the given set and
+        # stores it in the in-memory cache.
+        #
+        # @note   If there is a valid cache and it was generated withing the
+        #         expiration time frame this method does nothing.
+        #
+        # @param  [Set] set
+        #         the set for which the GitHub information is needed.
+        #
+        # @return [void]
+        #
+        def github_stats_if_needed(set)
+          update_date = get_value(set, :gh_date)
+          return if update_date && update_date > (Time.now - cache_expiration)
+
+          spec    = set.specification
+          url     = spec.source[:git] || ''
+          repo_id = url[/github.com\/([^\/\.]*\/[^\/\.]*)\.*/, 1]
+          return unless repo_id
+
+          begin
+            repo = Octokit.repo(repo_id)
+          rescue
+            return
+          end
+
+          set_value(set, :gh_watchers, repo['watchers'])
+          set_value(set, :gh_forks,    repo['forks'])
+          set_value(set, :pushed_at,   repo['pushed_at'])
+          set_value(set, :gh_date,     Time.now)
+          save_cache
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-core/specification/set.rb

@@ -0,0 +1,171 @@
+require 'active_support/core_ext/array/conversions'
+
+require 'cocoapods-core/specification/set/presenter'
+require 'cocoapods-core/specification/set/statistics'
+
+
+module Pod
+  class Specification
+
+    # A Specification::Set is responsible of handling all the specifications of
+    # a Pod. This class stores the information of the dependencies that required
+    # a Pod in the resolution process.
+    #
+    # @note   The alphabetical order of the sets is used to select a
+    #         specification if multiple are available for a given version.
+    #
+    # @note   The set class is not and should be not aware of the backing store
+    #         of a Source.
+    #
+    class Set
+
+      # @return [String] the name of the Pod.
+      #
+      attr_reader :name
+
+      # @return [Array<Source>] the sources that contain the specifications for
+      #         the available versions of a Pod.
+      #
+      attr_reader :sources
+
+      # @param  [String] name
+      #         the name of the Pod.
+      #
+      # @param  [Array<Source>,Source] sources
+      #         the sources that contain a Pod.
+      #
+      def initialize(name, sources = [])
+        @name    = name
+        sources  = sources.is_a?(Array) ? sources : [sources]
+        @sources = sources.sort_by(&:name)
+        @required_by  = []
+        @dependencies = []
+      end
+
+      # Stores a dependency on the Pod.
+      #
+      # @param  [Dependency] dependency
+      #         a dependency that requires the Pod.
+      #
+      # @param  [String] dependent_name
+      #         the name of the owner of the dependency.  It is used only to
+      #         display the Pod::Informative.
+      #
+      # @raise  If the versions requirement of the dependency are not
+      #         compatible with the previously stored dependencies.
+      #
+      # @todo   This should simply return a boolean. Is cocoaPods that should raise.
+      #
+      # @return [void]
+      #
+      def required_by(dependency, dependent_name)
+        unless @required_by.empty? || dependency.requirement.satisfied_by?(Version.new(required_version.to_s))
+          raise StandardError, "#{dependent_name} tries to activate `#{dependency}', but already activated version `#{required_version}' by #{@required_by.to_sentence}."
+        end
+        @specification = nil
+        @required_by  << dependent_name
+        @dependencies << dependency
+      end
+
+      # @return [Dependency] a dependency that includes all the versions
+      #         requirements of the stored dependencies.
+      #
+      def dependency
+        @dependencies.inject(Dependency.new(name)) do |previous, dependency|
+          previous.merge(dependency.to_root_dependency)
+        end
+      end
+
+      # @return [Specification] the top level specification of the Pod for the
+      #         {#required_version}.
+      #
+      # @note   If multiple sources have a specification for the
+      #         {#required_version} The alphabetical order of their names is
+      #         used to disambiguate.
+      #
+      def specification
+        unless @specification
+          sources = []
+          versions_by_source.each{ |source, versions| sources << source if versions.include?(required_version) }
+          source = sources.sort_by(&:name).first
+          @specification = source.specification(name, required_version)
+        end
+        @specification
+      end
+
+      # @return [Version] the highest version that satisfies the stored
+      #         dependencies.
+      #
+      # @todo   This should simply return nil. CocoaPods should raise instead.
+      #
+      def required_version
+        versions.find { |v| dependency.match?(name, v) } ||
+          (raise StandardError, "Required version (#{dependency}) not found for `#{name}'.\nAvailable versions: #{versions.join(', ')}")
+      end
+
+      # @return [Array<Version>] all the available versions for the Pod, sorted
+      #         from highest to lowest.
+      #
+      def versions
+        versions_by_source.values.flatten.uniq.sort.reverse
+      end
+
+      # @return [Hash{Source => Version}] all the available versions for the
+      #         Pod grouped by source.
+      #
+      def versions_by_source
+        result = {}
+        sources.each do |source|
+          result[source] = source.versions(name)
+        end
+        result
+      end
+
+      def ==(other)
+        self.class === other && @name == other.name && @sources.map(&:name) == other.sources.map(&:name)
+      end
+
+      def to_s
+        "#<#{self.class.name} for `#{name}' with required version `#{required_version}' available at `#{sources.map(&:name) * ', '}'>"
+      end
+      alias_method :inspect, :to_s
+
+      #-------------------------------------------------------------------------#
+
+      # The Set::External class handles Pods from external sources. Pods from
+      # external sources don't use the {Source} and are initialized by a given
+      # specification.
+      #
+      # @note External sources *don't* support subspecs.
+      #
+      class External < Set
+
+        attr_reader :specification
+
+        def initialize(spec)
+          @specification = spec.root
+          super(@specification.name)
+        end
+
+        def ==(other)
+          self.class === other && @specification == other.specification
+        end
+
+        def required_by(dependency, dependent_name)
+          before = @specification
+          super(dependency, dependent_name)
+        ensure
+          @specification = before
+        end
+
+        def specification_path
+          raise StandardError, "specification_path"
+        end
+
+        def versions
+          [@specification.version]
+        end
+      end
+    end
+  end
+end