xcocoapods 1.5.3

data/lib/cocoapods/installer/installation_options.rb

@@ -0,0 +1,158 @@
+require 'active_support/hash_with_indifferent_access'
+
+module Pod
+  class Installer
+    # Represents the installation options the user can customize via a
+    # `Podfile`.
+    #
+    class InstallationOptions
+      # Parses installation options from a podfile.
+      #
+      # @param  [Podfile] podfile the podfile to parse installation options
+      #         from.
+      #
+      # @raise  [Informative] if `podfile` does not specify a `CocoaPods`
+      #         install.
+      #
+      # @return [Self]
+      #
+      def self.from_podfile(podfile)
+        name, options = podfile.installation_method
+        unless name.downcase == 'cocoapods'
+          raise Informative, "Currently need to specify a `cocoapods` install, you chose `#{name}`."
+        end
+        new(options)
+      end
+
+      # Defines a new installation option.
+      #
+      # @param  [#to_s] name the name of the option.
+      #
+      # @param  default the default value for the option.
+      #
+      # @param [Boolean] boolean whether the option has a boolean value.
+      #
+      # @return [void]
+      #
+      # @!macro [attach] option
+      #
+      #   @note this option defaults to $2.
+      #
+      #   @return the $1 $0 for installation.
+      #
+      def self.option(name, default, boolean: true)
+        name = name.to_s
+        raise ArgumentError, "The `#{name}` option is already defined" if defaults.key?(name)
+        defaults[name] = default
+        attr_accessor name
+        alias_method "#{name}?", name if boolean
+      end
+
+      # @return [Hash<Symbol,Object>] all known installation options and their
+      #         default values.
+      #
+      def self.defaults
+        @defaults ||= {}
+      end
+
+      # @return [Array<Symbol>] the names of all known installation options.
+      #
+      def self.all_options
+        defaults.keys
+      end
+
+      # Initializes the installation options with a hash of options from a
+      # Podfile.
+      #
+      # @param  [Hash] options the options to parse.
+      #
+      # @raise  [Informative] if `options` contains any unknown keys.
+      #
+      def initialize(options = {})
+        options = ActiveSupport::HashWithIndifferentAccess.new(options)
+        unknown_keys = options.keys - self.class.all_options.map(&:to_s)
+        raise Informative, "Unknown installation options: #{unknown_keys.to_sentence}." unless unknown_keys.empty?
+        self.class.defaults.each do |key, default|
+          value = options.fetch(key, default)
+          send("#{key}=", value)
+        end
+      end
+
+      # @param  [Boolean] include_defaults whether values that match the default
+      #         for their option should be included. Defaults to `true`.
+      #
+      # @return [Hash] the options, keyed by option name.
+      #
+      def to_h(include_defaults: true)
+        self.class.defaults.reduce(ActiveSupport::HashWithIndifferentAccess.new) do |hash, (option, default)|
+          value = send(option)
+          hash[option] = value if include_defaults || value != default
+          hash
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && to_h == other.to_h
+      end
+
+      alias_method :eql, :==
+
+      def hash
+        to_h.hash
+      end
+
+      option :clean, true
+      option :deduplicate_targets, true
+      option :deterministic_uuids, true
+      option :integrate_targets, true
+      option :lock_pod_sources, true
+      option :warn_for_multiple_pod_sources, true
+      option :share_schemes_for_development_pods, false
+
+      module Mixin
+        module ClassMethods
+          # Delegates the creation of {#installation_options} to the `Podfile`
+          # returned by the given block.
+          #
+          # @param  blk a block that returns the `Podfile` to create
+          #         installation options from.
+          #
+          # @return [Void]
+          #
+          def delegate_installation_options(&blk)
+            define_method(:installation_options) do
+              @installation_options ||= InstallationOptions.from_podfile(instance_eval(&blk))
+            end
+          end
+
+          # Delegates the installation options attributes directly to
+          # {#installation_options}.
+          #
+          # @return [Void]
+          #
+          def delegate_installation_option_attributes!
+            define_method(:respond_to_missing?) do |name, *args|
+              installation_options.respond_to?(name, *args) || super
+            end
+
+            define_method(:method_missing) do |name, *args, &blk|
+              if installation_options.respond_to?(name)
+                installation_options.send(name, *args, &blk)
+              else
+                super
+              end
+            end
+          end
+        end
+
+        # @return [InstallationOptions] The installation options.
+        #
+        attr_accessor :installation_options
+
+        def self.included(mod)
+          mod.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/pod_source_installer.rb

@@ -0,0 +1,202 @@
+require 'active_support/core_ext/string/strip'
+
+module Pod
+  class Installer
+    # Controller class responsible of installing the activated specifications
+    # of a single Pod.
+    #
+    # @note This class needs to consider all the activated specs of a Pod.
+    #
+    class PodSourceInstaller
+      UNENCRYPTED_PROTOCOLS = %w(http git).freeze
+
+      # @return [Sandbox] The installation target.
+      #
+      attr_reader :sandbox
+
+      # @return [Hash{Symbol=>Array}] The specifications that need to be
+      #         installed grouped by platform.
+      #
+      attr_reader :specs_by_platform
+
+      # @return [Boolean] Whether the installer is allowed to touch the cache.
+      #
+      attr_reader :can_cache
+      alias_method :can_cache?, :can_cache
+
+      # Initialize a new instance
+      #
+      # @param [Sandbox] sandbox @see #sandbox
+      # @param [Hash{Symbol=>Array}] specs_by_platform @see #specs_by_platform
+      # @param [Boolean] can_cache @see #can_cache
+      #
+      def initialize(sandbox, specs_by_platform, can_cache: true)
+        @sandbox = sandbox
+        @specs_by_platform = specs_by_platform
+        @can_cache = can_cache
+      end
+
+      # @return [String] A string suitable for debugging.
+      #
+      def inspect
+        "<#{self.class} sandbox=#{sandbox.root} pod=#{root_spec.name}"
+      end
+
+      # @return [String] The name of the pod this installer is installing.
+      #
+      def name
+        root_spec.name
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Installation
+
+      # Creates the target in the Pods project and the relative support files.
+      #
+      # @return [void]
+      #
+      def install!
+        download_source unless predownloaded? || local?
+        PodSourcePreparer.new(root_spec, root).prepare! if local?
+      end
+
+      # Cleans the installations if appropriate.
+      #
+      # @return [void]
+      #
+      def clean!
+        clean_installation unless local?
+      end
+
+      # Locks the source files if appropriate.
+      #
+      # @return [void]
+      #
+      def lock_files!(file_accessors)
+        return if local?
+        FileUtils.chmod('u-w', source_files(file_accessors))
+      end
+
+      # Unlocks the source files if appropriate.
+      #
+      # @return [void]
+      #
+      def unlock_files!(file_accessors)
+        return if local?
+        FileUtils.chmod('u+w', source_files(file_accessors))
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Installation Steps
+
+      # Downloads the source of the Pod.
+      #
+      # @return [void]
+      #
+      def download_source
+        verify_source_is_secure(root_spec)
+        download_result = Downloader.download(download_request, root, :can_cache => can_cache?)
+
+        if (specific_source = download_result.checkout_options) && specific_source != root_spec.source
+          sandbox.store_checkout_source(root_spec.name, specific_source)
+        end
+      end
+
+      # Verify the source of the spec is secure, which is used to show a warning to the user if that isn't the case
+      # This method doesn't verify all protocols, but currently only prohibits unencrypted 'http://' and 'git://''
+      # connections.
+      #
+      # @return [void]
+      #
+      def verify_source_is_secure(root_spec)
+        return if root_spec.source.nil? || (root_spec.source[:http].nil? && root_spec.source[:git].nil?)
+        source = if !root_spec.source[:http].nil?
+                   URI(root_spec.source[:http].to_s)
+                 elsif !root_spec.source[:git].nil?
+                   git_source = root_spec.source[:git].to_s
+                   return unless git_source =~ /^#{URI.regexp}$/
+                   URI(git_source)
+                 end
+        if UNENCRYPTED_PROTOCOLS.include?(source.scheme)
+          UI.warn "'#{root_spec.name}' uses the unencrypted '#{source.scheme}' protocol to transfer the Pod. " \
+                'Please be sure you\'re in a safe network with only trusted hosts. ' \
+                'Otherwise, please reach out to the library author to notify them of this security issue.'
+        end
+      end
+
+      def download_request
+        Downloader::Request.new(
+          :spec => root_spec,
+          :released => released?,
+        )
+      end
+
+      # Removes all the files not needed for the installation according to the
+      # specs by platform.
+      #
+      # @return [void]
+      #
+      def clean_installation
+        cleaner = Sandbox::PodDirCleaner.new(root, specs_by_platform)
+        cleaner.clean!
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Convenience methods.
+
+      # @return [Array<Specifications>] the specification of the Pod used in
+      #         this installation.
+      #
+      def specs
+        specs_by_platform.values.flatten
+      end
+
+      # @return [Specification] the root specification of the Pod.
+      #
+      def root_spec
+        specs.first.root
+      end
+
+      # @return [Pathname] the folder where the source of the Pod is located.
+      #
+      def root
+        sandbox.pod_dir(root_spec.name)
+      end
+
+      # @return [Boolean] whether the source has been pre downloaded in the
+      #         resolution process to retrieve its podspec.
+      #
+      def predownloaded?
+        sandbox.predownloaded_pods.include?(root_spec.name)
+      end
+
+      # @return [Boolean] whether the pod uses the local option and thus
+      #         CocoaPods should not interfere with the files of the user.
+      #
+      def local?
+        sandbox.local?(root_spec.name)
+      end
+
+      def released?
+        !local? && !predownloaded? && sandbox.specification(root_spec.name) != root_spec
+      end
+
+      # @return [Array<Pathname>] The paths of the source files
+      #
+      def source_files(file_accessors)
+        file_accessors.flat_map(&:source_files)
+      end
+
+      #-----------------------------------------------------------------------#
+    end
+  end
+end

data/lib/cocoapods/installer/pod_source_preparer.rb

@@ -0,0 +1,77 @@
+module Pod
+  class Installer
+    # Controller class responsible of executing the prepare command
+    # of a single Pod.
+    #
+    class PodSourcePreparer
+      # @return [Specification] the root specification of the Pod.
+      #
+      attr_reader :spec
+
+      # @return [Pathname] the folder where the source of the Pod is located.
+      #
+      attr_reader :path
+
+      # Initialize a new instance
+      #
+      # @param [Specification] spec the root specification of the Pod.
+      # @param [Pathname] path the folder where the source of the Pod is located.
+      #
+      def initialize(spec, path)
+        raise "Given spec isn't a root spec, but must be." unless spec.root?
+        @spec = spec
+        @path = path
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Preparation
+
+      # Executes the prepare command if there is one.
+      #
+      # @return [void]
+      #
+      def prepare!
+        run_prepare_command
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Preparation Steps
+
+      extend Executable
+      executable :bash
+
+      # Runs the prepare command bash script of the spec.
+      #
+      # @note   Unsets the `CDPATH` env variable before running the
+      #         shell script to avoid issues with relative paths
+      #         (issue #1694).
+      #
+      # @return [void]
+      #
+      def run_prepare_command
+        return unless spec.prepare_command
+        UI.section(' > Running prepare command', '', 1) do
+          Dir.chdir(path) do
+            begin
+              ENV.delete('CDPATH')
+              ENV['COCOAPODS_VERSION'] = Pod::VERSION
+              prepare_command = spec.prepare_command.strip_heredoc.chomp
+              full_command = "\nset -e\n" + prepare_command
+              bash!('-c', full_command)
+            ensure
+              ENV.delete('COCOAPODS_VERSION')
+            end
+          end
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+    end
+  end
+end

data/lib/cocoapods/installer/podfile_validator.rb

@@ -0,0 +1,139 @@
+module Pod
+  class Installer
+    # Validate the podfile before installing to catch errors and
+    # problems
+    #
+    class PodfileValidator
+      # @return [Podfile] The podfile being validated
+      #
+      attr_reader :podfile
+
+      # @return [Array<String>] any errors that have occured during the validation
+      #
+      attr_reader :errors
+
+      # @return [Array<String>] any warnings that have occured during the validation
+      #
+      attr_reader :warnings
+
+      # Initialize a new instance
+      #
+      # @param [Podfile] podfile
+      #        The podfile to validate
+      #
+      # @param [Analyzer::PodfileDependencyCache] podfile_dependency_cache
+      #        An (optional) cache of all the dependencies in the podfile
+      #
+      def initialize(podfile, podfile_dependency_cache = Analyzer::PodfileDependencyCache.from_podfile(podfile))
+        @podfile = podfile
+        @podfile_dependency_cache = podfile_dependency_cache
+        @errors = []
+        @warnings = []
+        @validated = false
+      end
+
+      # Validate the podfile
+      # Errors are added to the errors array
+      #
+      def validate
+        validate_pod_directives
+        validate_no_abstract_only_pods!
+        validate_dependencies_are_present!
+        validate_no_duplicate_targets!
+
+        @validated = true
+      end
+
+      # Wether the podfile is valid is not
+      # NOTE: Will execute `validate` if the podfile
+      # has not yet been validated
+      #
+      def valid?
+        validate unless @validated
+
+        @validated && errors.empty?
+      end
+
+      # A message describing any errors in the
+      # validation
+      #
+      def message
+        errors.join("\n")
+      end
+
+      private
+
+      def add_error(error)
+        errors << error
+      end
+
+      def add_warning(warning)
+        warnings << warning
+      end
+
+      def validate_pod_directives
+        @podfile_dependency_cache.podfile_dependencies.each do |dependency|
+          validate_conflicting_external_sources!(dependency)
+        end
+      end
+
+      def validate_conflicting_external_sources!(dependency)
+        external_source = dependency.external_source
+        return false if external_source.nil?
+
+        available_downloaders = Downloader.downloader_class_by_key.keys
+        specified_downloaders = external_source.select { |key| available_downloaders.include?(key) }
+        if specified_downloaders.size > 1
+          add_error "The dependency `#{dependency.name}` specifies more than one download strategy(#{specified_downloaders.keys.join(',')})." \
+            'Only one is allowed'
+        end
+
+        pod_spec_or_path = external_source[:podspec].present? || external_source[:path].present?
+        if pod_spec_or_path && specified_downloaders.size > 0
+          add_error "The dependency `#{dependency.name}` specifies `podspec` or `path` in combination with other" \
+            ' download strategies. This is not allowed'
+        end
+      end
+
+      # Warns the user if the podfile is empty.
+      #
+      # @note   The workspace is created in any case and all the user projects
+      #         are added to it, however the projects are not integrated as
+      #         there is no way to discern between target definitions which are
+      #         empty and target definitions which just serve the purpose to
+      #         wrap other ones. This is not an issue because empty target
+      #         definitions generate empty libraries.
+      #
+      # @return [void]
+      #
+      def validate_dependencies_are_present!
+        if @podfile_dependency_cache.target_definition_list.all?(&:empty?)
+          add_warning 'The Podfile does not contain any dependencies.'
+        end
+      end
+
+      # Verifies that no dependencies in the Podfile will end up not being built
+      # at all. In other words, all dependencies _must_ belong to a non-abstract
+      # target, or be inherited by a target where `inheritance == complete`.
+      #
+      def validate_no_abstract_only_pods!
+        all_dependencies = @podfile_dependency_cache.podfile_dependencies
+        concrete_dependencies = @podfile_dependency_cache.target_definition_list.reject(&:abstract?).flat_map { |td| @podfile_dependency_cache.target_definition_dependencies(td) }
+        abstract_only_dependencies = all_dependencies - concrete_dependencies
+        abstract_only_dependencies.each do |dep|
+          add_error "The dependency `#{dep}` is not used in any concrete target."
+        end
+      end
+
+      def validate_no_duplicate_targets!
+        @podfile_dependency_cache.target_definition_list.group_by { |td| [td.name, td.user_project_path] }.
+          each do |(name, project), definitions|
+          next unless definitions.size > 1
+          error = "The target `#{name}` is declared twice"
+          error << " for the project `#{project}`" if project
+          add_error(error << '.')
+        end
+      end
+    end
+  end
+end