cocoapods-core 0.30.0 → 1.15.2

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

@@ -1,266 +0,0 @@
-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'
-
-          @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.data_provider.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 = GitHub.repo(url) if url
-
-          if repo
-            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
-end

data/lib/cocoapods-core/yaml_converter.rb

@@ -1,192 +0,0 @@
-module Pod
-
-  # Converts objects to their YAML representation.
-  #
-  # This class was created for the need having control on how the YAML is
-  # representation is generated. In details it provides:
-  #
-  # - sorting for hashes in ruby 1.8.x
-  # - ability to hint the sorting of the keys of a dictionary when converting
-  #   it. In this case the keys are also separated by an additional new line
-  #   feed for readability.
-  #
-  # @note This class misses important features necessary for a correct YAML
-  #       serialization and thus it is safe to use only for the Lockfile.
-  #       The missing features include:
-  #       - Strings are never quoted even when ambiguous.
-  #
-  class YAMLConverter
-
-    class << self
-
-      # Returns the YAML representation of the given object. If the given object
-      # is an Hash it accepts an optional hint for sorting the keys.
-      #
-      # @param  [String, Symbol, Array, Hash] object
-      #         the object to convert
-      #
-      # @param  [Array] hash_keys_hint
-      #         an array to use as a hint for sorting the keys of the object to
-      #         convert if it is an hash.
-      #
-      # @return [String] the YAML representation of the given object.
-      #
-      def convert(value)
-        result = process_according_to_class(value)
-        result << "\n"
-      end
-
-      def convert_hash(value, hash_keys_hint, line_separator = "\n")
-        result = process_hash(value, hash_keys_hint, line_separator)
-        result << "\n"
-      end
-
-      #-----------------------------------------------------------------------#
-
-      private
-
-      # Implementation notes:
-      #
-      # - each of the methods returns a YAML partial without an ending new
-      #   line.
-      # - if a partial needs to be indented is responsibility of the method
-      #   using it.
-      #
-      # ---
-
-      # @!group Private Helpers
-
-      # @return [String] the YAML representation of the given object.
-      #
-      def process_according_to_class(value, hash_keys_hint = nil)
-        case value
-        when String     then value
-        when Symbol     then ":#{value}"
-        when TrueClass  then 'true'
-        when FalseClass then 'false'
-        when Array      then process_array(value)
-        when Hash       then process_hash(value, hash_keys_hint)
-        else
-          raise StandardError, "Unsupported class for YAML conversion " \
-            "#{value.class}"
-        end
-      end
-
-      # Converts an array to YAML after sorting it.
-      #
-      # @param  [Array] array
-      #         the array to convert.
-      #
-      # @return [String] the YAML representation of the given object.
-      #
-      def process_array(array)
-        result = []
-        sorted_array(array).each do |array_value|
-          result << process_according_to_class(array_value)
-        end
-        "- #{result * "\n- "}"
-      end
-
-      # Converts a hash to YAML after sorting its keys. Optionally accepts a
-      # hint for sorting the keys.
-      #
-      # @note   If a hint for sorting the keys is provided the array is assumed
-      #         to be the root object and the keys are separated by an
-      #         additional new line feed for readability.
-      #
-      # @note   If the value of a given key is a String it displayed inline,
-      #         otherwise it is displayed below and indented.
-      #
-      # @param  [Hash] hash
-      #         the hash to convert.
-      #
-      # @return [String] the YAML representation of the given object.
-      #
-      def process_hash(hash, hash_keys_hint = nil, line_separator = "\n")
-        keys = sorted_array_with_hint(hash.keys, hash_keys_hint)
-        key_lines = []
-        keys.each do |key|
-          key_value = hash[key]
-          processed = process_according_to_class(key_value)
-          processed_key = process_according_to_class(key)
-          case key_value
-          when Array, Hash
-            key_partial_yaml = processed.lines.map { |line| "  #{line}" } * ""
-            key_lines << "#{processed_key}:\n#{key_partial_yaml}"
-          else
-            key_lines << "#{processed_key}: #{processed}"
-          end
-        end
-        key_lines * line_separator
-      end
-
-      #-----------------------------------------------------------------------#
-
-      private
-
-      # @!group Array Sorting
-
-      # Sorts an array using another one as a sort hint. All the values of the
-      # hint which appear in the array will be returned respecting the order in
-      # the hint. If any other key is present in the original array they are
-      # sorted using the {#sorted_array} method.
-      #
-      # @param  [Array] array
-      #         The array which needs to be sorted.
-      #
-      # @param  [Array] sort_hint
-      #         The array which should be used to sort the keys.
-      #
-      # @return [Array] The sorted Array.
-      #
-      def sorted_array_with_hint(array, sort_hint)
-        if sort_hint
-          hinted = sort_hint & array
-          remaining = array - sort_hint
-          hinted + sorted_array(remaining)
-        else
-          sorted_array(array)
-        end
-      end
-
-      # Sorts an array according to the string representation of it values.
-      # This method allows to sort arrays which contains strings or hashes.
-      #
-      # @note   If the value contained in the array is another Array or a Hash
-      #         the first value of the collection is used for sorting, as this
-      #         method is more useful, for arrays which contains a collection
-      #         composed by one object.
-      #
-      # @todo   This stuff is here only because the Lockfile intermixes strings
-      #         and hashes for the `PODS` key. The Lockfile should be more
-      #         consistent.
-      #
-      # @return [Array] The sorted array.
-      #
-      def sorted_array(array)
-        array.sort do |x, y|
-          x_string = sorting_string(x)
-          y_string = sorting_string(y)
-          x_string <=> y_string
-        end
-      end
-
-      # Returns the string representation of a value useful for sorting.
-      #
-      # @param  [String, Symbol, Array, Hash] value
-      #         The value which needs to be sorted
-      #
-      # @return [String] A string useful to compare the value with other ones.
-      #
-      def sorting_string(value)
-        return "" unless value
-        case value
-        when String then value.downcase
-        when Symbol then sorting_string(value.to_s)
-        when Array  then sorting_string(value.first)
-        when Hash   then value.keys.map { |key| key.to_s.downcase }.sort.first
-        end
-      end
-    end
-  end
-end