cocoapods-core 0.17.0.rc1

data/lib/cocoapods-core/source.rb

@@ -0,0 +1,284 @@
+require 'cocoapods-core/source/validator'
+
+module Pod
+
+  # The Source class is responsible to manage a collection of podspecs.
+  #
+  # The backing store of the podspecs collection is an implementation detail
+  # abstracted from the rest of CocoaPods.
+  #
+  # The default implementation uses a git repo as a backing store, where the
+  # podspecs are namespaced as:
+  #
+  #     "#{SPEC_NAME}/#{VERSION}/#{SPEC_NAME}.podspec"
+  #
+  class Source
+
+    # @return [Pathname] the location of the repo of the source.
+    #
+    attr_reader :repo
+
+    # @param  [Pathname] repo @see #repo.
+    #
+    def initialize(repo)
+      @repo = repo
+    end
+
+    # @return [String] the name of the source.
+    #
+    def name
+      @repo.basename.to_s
+    end
+
+    alias_method :to_s, :name
+
+
+    # @return [Integer] compares a source with another one for sorting
+    #         purposes.
+    #
+    # @note   Source are compared by the alphabetical order of their name, and
+    #         this convention should be used in any case where sources need to
+    #         be disambiguated.
+    #
+    def <=> (other)
+      name <=> other.name
+    end
+
+    #---------------------------------------------------------------------------#
+
+    # @!group Queering the source
+
+    # @return [Array<String>] the list of the name of all the Pods.
+    #
+    def pods
+      @repo.children.map do |child|
+        child.basename.to_s if child.directory? && child.basename.to_s != '.git'
+      end.compact
+    end
+
+    # @return [Array<Sets>] the sets of all the Pods.
+    #
+    def pod_sets
+      pods.map { |pod| Specification::Set.new(pod, self) }
+    end
+
+    # @return [Array<Version>] all the available versions for the Pod, sorted
+    #         from highest to lowest.
+    #
+    # @param  [String] name
+    #         the name of the Pod.
+    #
+    def versions(name)
+      pod_dir = repo + name
+      return unless pod_dir.exist?
+      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
+
+    # @return [Specification] the specification for a given version of Pod.
+    #
+    # @param  [String] name
+    #         the name of the Pod.
+    #
+    # @param  [Version,String] version
+    #         the version for the specification.
+    #
+    def specification(name, version)
+      path = repo + name + version.to_s
+      specification_path = path + "#{name}.podspec.yaml"
+      unless specification_path.exist?
+        specification_path = path + "#{name}.podspec"
+      end
+      Specification.from_file(specification_path)
+    end
+
+    # @return [Array<Specification>] all the specifications contained by the
+    #         source.
+    #
+    def all_specs
+      specs = pods.map do |name|
+        begin
+          versions(name).map { |version| specification(name, version) }
+        rescue DSLError => e
+          CoreUI.warn "Skipping `#{name}` because the podspec contains errors."
+          next
+        end
+      end
+      specs.flatten.compact
+    end
+
+    #---------------------------------------------------------------------------#
+
+    # @!group Searching the source
+
+    # @return [Set] a set for a given dependency. The set is identified by the
+    #               name of the dependency and takes into account subspecs.
+    #
+    def search(dependency)
+      pod_sets.find do |set|
+        # First match the (top level) name, which does not yet load the spec from disk
+        set.name == dependency.root_name &&
+          # Now either check if it's a dependency on the top level spec, or if it's not
+          # check if the requested subspec exists in the top level spec.
+          set.specification.subspec_by_name(dependency.name)
+      end
+    end
+
+    # @return [Array<Set>] The list of the sets that contain the search term.
+    #
+    # @param  [String] query
+    #         the search term.
+    #
+    # @param  [Bool] full_text_search
+    #         whether the search should be limited to the name of the Pod or
+    #         should include also the author, the summary, and the description.
+    #
+    # @note   full text search requires to load the specification for each pod,
+    #         hence is considerably slower.
+    #
+    def search_by_name(query, full_text_search = false)
+      pod_sets.map do |set|
+        if full_text_search
+          begin
+            s = set.specification
+            text = "#{s.name} #{s.authors} #{s.summary} #{s.description}"
+          rescue
+            CoreUI.warn "Skipping `#{set.name}` because the podspec contains errors."
+          end
+        else
+          text = set.name
+        end
+        set if text && text.downcase.include?(query.downcase)
+      end.compact
+    end
+
+    #---------------------------------------------------------------------------#
+
+    # @!group Representations
+
+    # @return [Hash{String=>{String=>Specification}}] the static representation
+    #         of all the specifications grouped first by name and then by
+    #         version.
+    #
+    def to_hash
+      hash = {}
+      all_specs.each do |spec|
+        print '.'
+        hash[spec.name] ||= {}
+        hash[spec.name][spec.version.version] = spec.to_hash
+      end
+      hash
+    end
+
+    # @return [String] the YAML encoded {to_hash} representation.
+    #
+    def to_yaml
+      require 'yaml'
+      to_hash.to_yaml
+    end
+
+    # @return [String] the JSON encoded {to_hash} representation.
+    #
+    def to_json
+      require 'json'
+      to_hash.to_json
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # 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 [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.
+      #
+      # @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
+
+      # @return [Array<Pathname>] the directories where the sources are stored.
+      #
+      # @raise  If the repos dir doesn't exits.
+      #
+      def dirs
+        repos_dir.children.select(&:directory?)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,356 @@
+require 'active_support/core_ext/string/strip.rb'
+
+module Pod
+  class Specification
+
+    # Allows to conveniently access a Specification programmatically.
+    #
+    # It takes care of:
+    #
+    # - standardizing the attributes
+    # - handling multi-platform values
+    # - handle default values
+    # - handle inherited values
+    #
+    # This class allows to store the values of the attributes in the
+    # Specification as specified in the DSL. The benefits is reduced reliance
+    # on meta programming to access the attributes and the possibility of
+    # serializing a specification back exactly as defined in a file.
+    #
+    class Consumer
+
+      # @return [Specification] The specification to consume.
+      #
+      attr_reader :spec
+
+      # @return [Symbol] The name of the platform for which the specification
+      #         needs to be consumed.
+      #
+      attr_reader :platform_name
+
+      # @param  [Specification] spec @see spec
+      # @param  [Symbol, Platform] platform
+      #         The platform for which the specification needs to be consumed.
+      #
+      def initialize(spec, platform)
+        @spec = spec
+        @platform_name = platform.is_a?(Symbol) ? platform : platform.name
+
+        unless spec.supported_on_platform?(platform)
+          raise StandardError, "#{to_s} is not compatible with #{platform}."
+        end
+      end
+
+      # Creates a method to access the contents of the attribute.
+      #
+      # @param  [Symbol] name
+      #         the name of the attribute.
+      #
+      # @macro  [attach]
+      #         @!method $1
+      #
+      def self.spec_attr_accessor(name)
+        define_method(name) do
+          value_for_attribute(name)
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Regular attributes
+
+      # @return [Bool] Whether the source files of the specification require to
+      #         be compiled with ARC.
+      #
+      spec_attr_accessor :requires_arc
+      alias_method :requires_arc?, :requires_arc
+
+      # @return [Array<String>] A list of frameworks that the user’s target
+      #         needs to link against
+      #
+      spec_attr_accessor :frameworks
+
+      # @return [Array<String>] A list of frameworks that the user’s target
+      #         needs to **weakly** link against
+      #
+      spec_attr_accessor :weak_frameworks
+
+      # @return [Array<String>] A list of libraries that the user’s target
+      #         needs to link against
+      #
+      spec_attr_accessor :libraries
+
+      # @return [Array<String>] the list of compiler flags needed by the
+      #         specification files.
+      #
+      spec_attr_accessor :compiler_flags
+
+      # @return [Hash{String => String}] the xcconfig flags for the current
+      #         specification.
+      #
+      spec_attr_accessor :xcconfig
+
+      # @return [String] The contents of the prefix header.
+      #
+      spec_attr_accessor :prefix_header_contents
+
+      # @return [String] The path of the prefix header file.
+      #
+      spec_attr_accessor :prefix_header_file
+
+      # @return [String] the headers directory.
+      #
+      spec_attr_accessor :header_dir
+
+      # @return [String] the directory from where to preserve the headers
+      #         namespacing.
+      #
+      spec_attr_accessor :header_mappings_dir
+
+      #-----------------------------------------------------------------------#
+
+      # @!group File patterns
+
+      # @return [Array<String>] the source files of the Pod.
+      #
+      spec_attr_accessor :source_files
+
+      # @return [Array<String>] the public headers of the Pod.
+      #
+      spec_attr_accessor :public_header_files
+
+      # @return [Array<String>] A hash where the key represents the
+      #         paths of the resources to copy and the values the paths of
+      #         the resources that should be copied.
+      #
+      spec_attr_accessor :resources
+
+      # @return [Array<String>] The file patterns that the
+      #         Pod should ignore.
+      #
+      spec_attr_accessor :exclude_files
+
+      # @return [Array<String>] The paths that should be not
+      #         cleaned.
+      #
+      spec_attr_accessor :preserve_paths
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Dependencies
+
+      # @return [Array<Dependency>] the dependencies on other Pods.
+      #
+      def dependencies
+        value = value_for_attribute(:dependencies)
+        value.map do |name, requirements|
+          Dependency.new(name, requirements)
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # Returns the value for the attribute with the given name for the
+      # specification. It takes into account inheritance, multi-platform
+      # attributes and default values.
+      #
+      # @param  [Symbol] attr_name
+      #         The name of the attribute.
+      #
+      # @return [String, Array, Hash] the value for the attribute.
+      #
+      def value_for_attribute(attr_name)
+        attr = Specification::DSL.attributes[attr_name]
+        value = value_with_inheritance(spec, attr)
+        value ||= attr.default(platform_name)
+        value ||= attr.container.new if attr.container
+        value
+      end
+
+      # Returns the value of a given attribute taking into account inheritance.
+      #
+      # @param  [Specification] the_spec
+      #         the specification for which the value is needed.
+      #
+      # @param  [Specification::DSL::Attribute] attr
+      #         the attribute for which that value is needed.
+      #
+      # @return [String, Array, Hash] the value for the attribute.
+      #
+      def value_with_inheritance(the_spec, attr)
+        value = raw_value_for_attribute(the_spec, attr)
+        if the_spec.root? || !attr.inherited?
+          return value
+        end
+
+        parent_value = value_with_inheritance(the_spec.parent, attr)
+        merge_values(attr, parent_value, value)
+      end
+
+      # Returns the value of a given attribute taking into account multi
+      # platform values.
+      #
+      # @param  [Specification] the_spec
+      #         the specification for which the value is needed.
+      #
+      # @param  [Specification::DSL::Attribute] attr
+      #         the attribute for which that value is needed.
+      #
+      # @return [String, Array, Hash] The value for an attribute.
+      #
+      def raw_value_for_attribute(the_spec, attr)
+        value = the_spec.attributes_hash[attr.name.to_s]
+        value = prepare_value(attr, value)
+
+        if attr.multi_platform? && the_spec.attributes_hash[platform_name.to_s]
+          platform_value = the_spec.attributes_hash[platform_name.to_s][attr.name.to_s]
+          platform_value = prepare_value(attr, platform_value)
+          value = merge_values(attr, value, platform_value)
+        end
+        value
+      end
+
+      # Merges the values of an attribute, either because the attribute is
+      # multi platform or because it is inherited.
+      #
+      # @param  [Specification::DSL::Attribute] attr
+      #         the attribute for which that value is needed.
+      #
+      # @param  [String, Array, Hash] existing_value
+      #         the current value (the value of the parent or non-multiplatform
+      #         value).
+      #
+      # @param  [String, Array, Hash] new_value
+      #         the value to append (the value of the spec or the
+      #         multi-platform value).
+      #
+      # @return [String, Array, Hash] The merged value.
+      #
+      def merge_values(attr, existing_value, new_value)
+        return existing_value if new_value.nil?
+        return new_value if existing_value.nil?
+
+        if attr.types.include?(TrueClass)
+          new_value.nil? ? existing_value : new_value
+        elsif attr.container == Array
+          r = [*existing_value] + [*new_value]
+          r.compact
+        elsif attr.container == Hash
+          existing_value = existing_value.merge(new_value) do |_, old, new|
+            if new.is_a?(Array) || old.is_a?(Array)
+              r = [*old] + [*new]
+              r.compact
+            else
+              old + ' ' + new
+            end
+          end
+        else
+          value
+        end
+      end
+
+      # Wraps a value in an Array if needed and calls the prepare hook to
+      # allow further customization of a value before storing it in the
+      # instance variable.
+      #
+      # @note   Only array containers are wrapped. To automatically wrap
+      #         values for attributes with hash containers a prepare hook
+      #         should be used.
+      #
+      # @return [Object] the customized value of the original one if no
+      #         prepare hook was defined.
+      #
+      def prepare_value(attr, value)
+        if attr.container ==  Array
+          if value.class == Rake::FileList
+            value = [value]
+          else
+            value = [*value].compact
+          end
+        end
+
+        hook_name = prepare_hook_name(attr)
+        if self.respond_to?(hook_name, true)
+          value = self.send(hook_name, value)
+        else
+          value
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # Converts the keys of the given hash to a string.
+      #
+      # @todo   Removed if not used by `resources_bundle`
+      #
+      # @param  [Object] value
+      #         the value that needs to be stripped from the Symbols.
+      #
+      # @return [Hash] the hash with the strings instead of the keys.
+      #
+      # def convert_keys_to_symbol(value)
+      #   return unless value
+      #   result = {}
+      #   value.each do |key, subvalue|
+      #     subvalue = convert_keys_to_symbol(subvalue) if subvalue.is_a?(Hash)
+      #     result[key.to_sym] = subvalue
+      #   end
+      #   result
+      # end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Preparing Values
+      #
+      # Raw values need to be prepared as soon as they are read so they can be
+      # safely merged to support multi platform attributes and inheritance
+
+      # @return [String] the name of the prepare hook for this attribute.
+      #
+      # @note   The hook is called after the value has been wrapped in an
+      #         array (if needed according to the container) but before
+      #         validation.
+      #
+      def prepare_hook_name(attr)
+        "_prepare_#{attr.name}"
+      end
+
+      # Converts the prefix header to a string if specified as an array.
+      #
+      # @param  [String, Array] value.
+      #         The value of the attribute as specified by the user.
+      #
+      # @return [String] the prefix header.
+      #
+      def _prepare_prefix_header_contents(value)
+        value.is_a?(Array) ? value * "\n" : value
+      end
+
+      # Converts the resources file patterns to a hash defaulting to the
+      # resource key if they are defined as an Array or a String.
+      #
+      # @param  [String, Array, Hash] value.
+      #         The value of the attribute as specified by the user.
+      #
+      # @return [Hash] the resources.
+      #
+      # def _prepare_resources_bundle(value)
+      #   value = { :resources => value } unless value.is_a?(Hash)
+      #   result = {}
+      #   value.each do |key, patterns|
+      #     result[key] = [*patterns].compact
+      #   end
+      #   result
+      # end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end