cocoapods 0.14.0 → 0.15.0

data/lib/cocoapods/specification/set.rb

@@ -2,77 +2,145 @@ require 'active_support/core_ext/array/conversions'
 
 module Pod
   class Specification
+
+    # A Specification::Set is resposible of handling all the specifications of
+    # a Pod. This class stores the information of the dependencies that reuired
+    # a Pod in the resolution process.
+    #
+    # @note The alpahbetical 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
-      attr_reader :pod_dir
 
-      def initialize(pod_dir)
-        @pod_dir = pod_dir
-        @required_by = []
+      # @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
 
+      # @return [void]                  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.
+      #
+      # @raises If the versions requirement of the dependency are not
+      #         compatible with the previously stored dependencies.
+      #
       def required_by(dependency, dependent_name)
         unless @required_by.empty? || dependency.requirement.satisfied_by?(Gem::Version.new(required_version.to_s))
-          raise Informative, "#{dependent_name} tries to activate `#{dependency}', " \
-                             "but already activated version `#{required_version}' " \
-                             "by #{@required_by.to_sentence}."
+          raise Informative, "#{dependent_name} tries to activate `#{dependency}', but already activated version `#{required_version}' by #{@required_by.to_sentence}."
         end
         @specification = nil
-        @required_by << dependent_name
+        @required_by  << dependent_name
         @dependencies << dependency
       end
 
-      def specification_by_name(name)
-        specification.top_level_parent.subspec_by_name(name)
-      end
-
+      # @return [Dependency] A dependency including all the versions
+      #                      requirements of the stored dependencies.
+      #
       def dependency
         @dependencies.inject(Dependency.new(name)) do |previous, dependency|
           previous.merge(dependency.to_top_level_spec_dependency)
         end
       end
 
-      def name
-        @pod_dir.basename.to_s
-      end
-
-      def specification_path
-        @pod_dir + required_version.to_s + "#{name}.podspec"
+      # @return [Specification] The specification for the given subspec name,
+      #                         from {specification}.
+      #
+      # @param [String] name    The name of the specification. It can be the
+      #                         name of the top level parent or the name of a
+      #                         subspec.
+      #
+      # @see specification
+      #
+      def specification_by_name(name)
+        specification.top_level_parent.subspec_by_name(name)
       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 alpahbetical order of their names is used
+      #       to disambiguate.
+      #
       def specification
-        @specification ||= Specification.from_file(specification_path)
+        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 the first version that matches the current dependency.
+      # @return [Version] The highest version that satisfies {dependency}.
+      #
       def required_version
         versions.find { |v| dependency.match?(name, v) } ||
           raise(Informative, "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 groupped by source.
+      #
+      def versions_by_source
+        result = {}
+        sources.each do |source|
+          result[source] = source.versions(name)
+        end
+        result
+      end
+
       def ==(other)
-        self.class === other && @pod_dir == other.pod_dir
+        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}' at `#{@pod_dir}'>"
+        "#<#{self.class.name} for `#{name}' with required version `#{required_version}' available at `#{sources.map(&:name) * ', '}'>"
       end
       alias_method :inspect, :to_s
 
-      # Returns Pod::Version instances, for each version directory, sorted from
-      # highest version to lowest.
-      def versions
-        @pod_dir.children.map do |v|
-          basename = v.basename.to_s
-          Version.new(basename) if v.directory? && basename[0,1] != '.'
-        end.compact.sort.reverse
-      end
-
+      # The Set::External class handles Pods from external sources. Pods from
+      # external sources don't use the {Pod::Sources} and are intialized by a
+      # given specification.
+      #
+      # @note External sources *don't* support subspecs.
+      #
       class External < Set
         def initialize(specification)
           @specification = specification
-          @required_by = []
-          @dependencies = []
+          @required_by   = []
+          @dependencies  = []
         end
 
         def name
@@ -80,7 +148,7 @@ module Pod
         end
 
         def ==(other)
-          self.class === other && name == other.name
+          self.class === other && @specification == other.specification
         end
 
         def required_by(dependency, dependent_name)

data/lib/cocoapods/specification/statistics.rb

@@ -78,7 +78,7 @@ module Pod
       def compute_creation_date(set, save = true)
         date = get_value(set, :creation_date)
         unless date
-          Dir.chdir(set.pod_dir.dirname) do
+          Dir.chdir(set.sources.first.repo) do
             date = Time.at(`git log --first-parent --format=%ct #{set.name}`.split("\n").last.to_i)
           end
           set_value(set, :creation_date, date)

data/lib/cocoapods/user_interface.rb

@@ -0,0 +1,215 @@
+module Pod
+  require 'colored'
+  module UserInterface
+
+    autoload :UIPod, 'cocoapods/user_interface/ui_pod'
+
+    @title_colors      =  %w|yellow green|
+    @title_level       =  0
+    @indentation_level =  2
+    @treat_titles_as_messages = false
+
+    class << self
+      include Config::Mixin
+
+      attr_accessor :indentation_level, :title_level
+
+      # Prints a title taking an optional verbose prefix and
+      # a relative indentation valid for the UI action in the passed
+      # block.
+      #
+      # In verbose mode titles are printed with a color according
+      # 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).
+      #
+      def section(title, verbose_prefix = '', relative_indentation = 0)
+        if config.verbose?
+          title(title, verbose_prefix, relative_indentation)
+        elsif title_level < 2
+          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
+
+      # A title oposed to a section is always visible
+      #
+      def title(title, verbose_prefix = '', relative_indentation = 2)
+        if(@treat_titles_as_messages)
+          message(title, verbose_prefix)
+        else
+          title = verbose_prefix + title if config.verbose?
+          title = "\n#{title}" if @title_level < 2
+          if (color = @title_colors[@title_level])
+            title = title.send(color)
+          end
+          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
+
+      # def title(title, verbose_prefix = '', relative_indentation = 2)
+      # end
+
+      # Prints a verbose message taking an optional verbose prefix and
+      # a relative indentation valid for the UI action in the passed
+      # block.
+      #
+      # TODO: clean interface.
+      #
+      def message(message, verbose_prefix = '', relative_indentation = 2)
+        message = verbose_prefix + message if config.verbose?
+        puts_indented message if config.verbose?
+
+        self.indentation_level += relative_indentation
+        yield if block_given?
+        self.indentation_level -= relative_indentation
+      end
+
+      # Prints an info to the user. The info is always displayed.
+      # It respects the current indentation level only in verbose
+      # mode.
+      #
+      # Any title printed in the optional block is treated as a message.
+      #
+      def info(message)
+        indentation = config.verbose? ? self.indentation_level : 0
+        indented = wrap_string(message, " " * indentation)
+        puts(indented)
+
+        self.indentation_level += 2
+        @treat_titles_as_messages = true
+        yield if block_given?
+        @treat_titles_as_messages = false
+        self.indentation_level -= 2
+      end
+
+      # Prints an important message to the user.
+      #
+      # @param [String] message The message to print.
+      #
+      # return [void]
+      #
+      def notice(message)
+        puts("\n[!] #{message}".green)
+      end
+
+      # Prints an important warning to the user optionally followed by actions
+      # that the user should take.
+      #
+      # @param [String]  message The message to print.
+      # @param [Actions] 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)
+        end
+      end
+
+      # Returns a string containing relative location of a path from the Podfile.
+      # The returned path is quoted. If the argument is nit it returns the
+      # empty string.
+      #
+      def path(pathname)
+        if pathname
+          "`./#{pathname.relative_path_from(config.project_podfile.dirname || Pathname.pwd)}'"
+        else
+          ''
+        end
+      end
+
+      # Prints the textual repprensentation of a given set.
+      #
+      def pod(set, mode = :normal)
+        if mode == :name
+          puts_indented set.name
+        else
+          pod = UIPod.new(set)
+          title("\n-> #{pod.name} (#{pod.version})".green, '', 1) do
+            puts_indented pod.summary
+            labeled('Homepage', pod.homepage)
+            labeled('Source',   pod.source_url)
+            labeled('Versions', pod.verions_by_source)
+            if mode == :stats
+              labeled('Pushed',   pod.github_last_activity)
+              labeled('Authors',  pod.authors) if pod.authors =~ /,/
+              labeled('Author',   pod.authors) if pod.authors !~ /,/
+              labeled('License',  pod.license)
+              labeled('Platform', pod.platform)
+              labeled('Watchers', pod.github_watchers)
+              labeled('Forks',    pod.github_forks)
+            end
+            labeled('Sub specs', pod.subspecs)
+          end
+        end
+      end
+
+      # Prints a message with a label.
+      #
+      def labeled(label, value)
+        if value
+          ''.tap do |t|
+            t << "    - #{label}:".ljust(16)
+            if value.is_a?(Array)
+              separator = "\n      - "
+              puts_indented t << separator << value.join(separator)
+            else
+              puts_indented t << value.to_s << "\n"
+            end
+          end
+        end
+      end
+
+      # @!group Basic printing
+
+      # Prints a message unless config is silent.
+      #
+      def puts(message = '')
+        super(message) unless config.silent?
+      end
+
+      # Prints a message respecting the current indentation level and
+      # wrapping it to the terminal width if necessary.
+      #
+      def puts_indented(message = '')
+        indented = wrap_string(message, " " * self.indentation_level)
+        puts(indented)
+      end
+
+      private
+
+      # @!group Helpers
+
+      # Wraps a string taking into account the width of the terminal and an
+      # option indent. Adapted from http://blog.macromates.com/2006/wrapping-text-with-regular-expressions/
+      #
+      # @param [String] txt     The string to wrap
+      #
+      # @param [String] indent  The string to use to indent the result.
+      #
+      # @return [String]        The formatted string.
+      #
+      def wrap_string(txt, indent = '')
+        width = `stty size`.split(' ')[1].to_i - indent.length
+        txt.strip.gsub(/(.{1,#{width}})( +|$)\n?|(.{#{width}})/, indent + "\\1\\3\n")
+      end
+    end
+  end
+  UI = UserInterface
+end

data/lib/cocoapods/user_interface/ui_pod.rb

@@ -0,0 +1,130 @@
+require 'active_support/core_ext/array/conversions'
+
+module Pod
+  module UserInterface
+    class UIPod
+      attr_accessor :set
+
+      def initialize(set)
+        @set = set
+      end
+
+      # set information
+      def name
+        @set.name
+      end
+
+      def version
+        @set.versions.first
+      end
+
+      def versions
+        @set.versions.sort.reverse
+      end
+
+      def verions_by_source
+        result = []
+        @set.versions_by_source.each do |source, versions|
+          result << "#{versions.map(&:to_s) * ', '} [#{source.name} repo]"
+        end
+        result * ' - '
+      end
+
+      # @return [Array<String>]
+      #
+      def sources
+        @set.sources.map(&:name).sort
+      end
+
+      # specification information
+      def spec
+        @set.specification
+      end
+
+      def authors
+        spec.authors.keys.to_sentence
+      end
+
+      def homepage
+        spec.homepage
+      end
+
+      def description
+        spec.description
+      end
+
+      def summary
+        spec.summary
+      end
+
+      def source_url
+        spec.source.reject {|k,_| k == :commit || k == :tag }.values.first
+      end
+
+      def platform
+        spec.available_platforms.sort { |a,b| a.to_s.downcase <=> b.to_s.downcase }.join(' - ')
+      end
+
+      def license
+        spec.license[:type] if spec.license
+      end
+
+      # will return array of all subspecs (recursevly) or nil
+      def subspecs
+        (spec.recursive_subspecs.any? && spec.recursive_subspecs) || nil
+      end
+
+      # Statistics information
+      def creation_date
+        Pod::Specification::Statistics.instance.creation_date(@set)
+      end
+
+      def github_watchers
+        Pod::Specification::Statistics.instance.github_watchers(@set)
+      end
+
+      def github_forks
+        Pod::Specification::Statistics.instance.github_forks(@set)
+      end
+
+      def github_last_activity
+        distance_from_now_in_words(Pod::Specification::Statistics.instance.github_pushed_at(@set))
+      end
+
+      def ==(other)
+        self.class === other && @set == other.set
+      end
+
+      def eql?(other)
+        self.class === other && name.eql?(other.name)
+      end
+
+      def hash
+        name.hash
+      end
+
+      private
+
+      def distance_from_now_in_words(from_time)
+        return nil unless from_time
+        from_time = Time.parse(from_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
+