xcocoapods 1.5.3

data/lib/cocoapods/installer/xcode/pods_project_generator/target_installer_helper.rb

@@ -0,0 +1,68 @@
+module Pod
+  class Installer
+    class Xcode
+      class PodsProjectGenerator
+        module TargetInstallerHelper
+          # @param [Generator] generator
+          #        the generator to use for generating the content.
+          #
+          # @param [Pathname] path
+          #        the pathname to save the content into.
+          #
+          # Saves the content the provided path unless the path exists and the contents are exactly the same.
+          #
+          def update_changed_file(generator, path)
+            if path.exist?
+              contents = generator.generate.to_s
+              content_stream = StringIO.new(contents)
+              identical = File.open(path, 'rb') { |f| FileUtils.compare_stream(f, content_stream) }
+              return if identical
+
+              File.open(path, 'w') { |f| f.write(contents) }
+            else
+              path.dirname.mkpath
+              generator.save_as(path)
+            end
+          end
+
+          # Creates the Info.plist file which sets public framework attributes
+          #
+          # @param  [Sandbox] sandbox @see #sandbox
+          #         The sandbox where the generated Info.plist file should be saved.
+          #
+          # @param  [Pathname] path
+          #         the path to save the generated Info.plist file.
+          #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to link the generated Info.plist file into.
+          #
+          # @param  [Version] version
+          #         the version to use for when generating this Info.plist file.
+          #
+          # @param  [Platform] platform
+          #         the platform to use for when generating this Info.plist file.
+          #
+          # @param  [Symbol] bundle_package_type
+          #         the CFBundlePackageType of the target this Info.plist file is for.
+          #
+          # @return [void]
+          #
+          def create_info_plist_file_with_sandbox(sandbox, path, native_target, version, platform, bundle_package_type = :fmwk)
+            UI.message "- Generating Info.plist file at #{UI.path(path)}" do
+              generator = Generator::InfoPlistFile.new(version, platform, bundle_package_type)
+              update_changed_file(generator, path)
+
+              relative_path_string = path.relative_path_from(sandbox.root).to_s
+              native_target.build_configurations.each do |c|
+                c.build_settings['INFOPLIST_FILE'] = relative_path_string
+              end
+            end
+          end
+
+          module_function :update_changed_file
+          module_function :create_info_plist_file_with_sandbox
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/xcode/target_validator.rb

@@ -0,0 +1,147 @@
+module Pod
+  class Installer
+    class Xcode
+      # The {Xcode::TargetValidator} ensures that the pod and aggregate target
+      # configuration is valid for installation.
+      #
+      class TargetValidator
+        # @return [Array<AggregateTarget>] The aggregate targets that should be
+        #                                  validated.
+        #
+        attr_reader :aggregate_targets
+
+        # @return [Array<PodTarget>] The pod targets that should be validated.
+        #
+        attr_reader :pod_targets
+
+        # Create a new TargetValidator with aggregate and pod targets to
+        # validate.
+        #
+        # @param [Array<AggregateTarget>] aggregate_targets
+        #                                 The aggregate targets to validate.
+        #
+        # @param [Array<PodTarget>] pod_targets
+        #                           The pod targets to validate.
+        #
+        def initialize(aggregate_targets, pod_targets)
+          @aggregate_targets = aggregate_targets
+          @pod_targets = pod_targets
+        end
+
+        # Perform the validation steps for the provided aggregate and pod
+        # targets.
+        #
+        def validate!
+          verify_no_duplicate_framework_and_library_names
+          verify_no_static_framework_transitive_dependencies
+          verify_swift_pods_swift_version
+          verify_swift_pods_have_module_dependencies
+        end
+
+        private
+
+        def verify_no_duplicate_framework_and_library_names
+          aggregate_targets.each do |aggregate_target|
+            aggregate_target.user_build_configurations.keys.each do |config|
+              pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
+              file_accessors = pod_targets.flat_map(&:file_accessors)
+
+              frameworks = file_accessors.flat_map(&:vendored_frameworks).uniq.map(&:basename)
+              frameworks += pod_targets.select { |pt| pt.should_build? && pt.requires_frameworks? }.map(&:product_module_name).uniq
+              verify_no_duplicate_names(frameworks, aggregate_target.label, 'frameworks')
+
+              libraries = file_accessors.flat_map(&:vendored_libraries).uniq.map(&:basename)
+              libraries += pod_targets.select { |pt| pt.should_build? && !pt.requires_frameworks? }.map(&:product_name)
+              verify_no_duplicate_names(libraries, aggregate_target.label, 'libraries')
+            end
+          end
+        end
+
+        def verify_no_duplicate_names(names, label, type)
+          duplicates = names.map { |n| n.to_s.downcase }.group_by { |f| f }.select { |_, v| v.size > 1 }.keys
+
+          unless duplicates.empty?
+            raise Informative, "The '#{label}' target has " \
+              "#{type} with conflicting names: #{duplicates.to_sentence}."
+          end
+        end
+
+        def verify_no_static_framework_transitive_dependencies
+          aggregate_targets.each do |aggregate_target|
+            next unless aggregate_target.requires_frameworks?
+
+            aggregate_target.user_build_configurations.keys.each do |config|
+              dynamic_pod_targets = aggregate_target.pod_targets_for_build_configuration(config).reject(&:static_framework?)
+
+              dependencies = dynamic_pod_targets.select(&:should_build?).flat_map(&:dependencies)
+              depended_upon_targets = dynamic_pod_targets.select { |t| dependencies.include?(t.pod_name) && !t.should_build? }
+
+              static_libs = depended_upon_targets.flat_map(&:file_accessors).flat_map(&:vendored_static_artifacts)
+              unless static_libs.empty?
+                raise Informative, "The '#{aggregate_target.label}' target has " \
+                  "transitive dependencies that include static binaries: (#{static_libs.to_sentence})"
+              end
+
+              static_framework_deps = dynamic_pod_targets.select(&:should_build?).flat_map(&:recursive_dependent_targets).select(&:static_framework?)
+              unless static_framework_deps.empty?
+                raise Informative, "The '#{aggregate_target.label}' target has " \
+                  "transitive dependencies that include static frameworks: (#{static_framework_deps.flat_map(&:name).to_sentence})"
+              end
+            end
+          end
+        end
+
+        def verify_swift_pods_swift_version
+          error_message_for_target_definition = lambda do |target_definition|
+            "`#{target_definition.name}` (Swift #{target_definition.swift_version})"
+          end
+          swift_pod_targets = pod_targets.select(&:uses_swift?)
+          error_messages = swift_pod_targets.map do |pod_target|
+            next unless pod_target.spec_swift_version.nil?
+            swift_target_definitions = pod_target.target_definitions.reject { |target| target.swift_version.blank? }
+            next if swift_target_definitions.uniq(&:swift_version).count == 1
+            if swift_target_definitions.empty?
+              "- `#{pod_target.name}` does not specify a Swift version and none of the targets " \
+                "(#{pod_target.target_definitions.map { |td| "`#{td.name}`" }.to_sentence}) integrating it have the " \
+                '`SWIFT_VERSION` attribute set. Please contact the author or set the `SWIFT_VERSION` attribute in at ' \
+                'least one of the targets that integrate this pod.'
+            else
+              target_errors = swift_target_definitions.map(&error_message_for_target_definition).to_sentence
+              "- `#{pod_target.name}` is integrated by multiple targets that use a different Swift version: #{target_errors}."
+            end
+          end.compact
+
+          unless error_messages.empty?
+            raise Informative, "Unable to determine Swift version for the following pods:\n\n #{error_messages.join('\n')}"
+          end
+        end
+
+        def verify_swift_pods_have_module_dependencies
+          error_messages = []
+          pod_targets.each do |pod_target|
+            next unless pod_target.uses_swift?
+
+            non_module_dependencies = []
+            pod_target.dependent_targets.each do |dependent_target|
+              next if !dependent_target.should_build? || dependent_target.defines_module?
+              non_module_dependencies << dependent_target.name
+            end
+
+            next if non_module_dependencies.empty?
+
+            error_messages << "The Swift pod `#{pod_target.name}` depends upon #{non_module_dependencies.map { |d| "`#{d}`" }.to_sentence}, " \
+                              'which do not define modules. ' \
+                              'To opt into those targets generating module maps '\
+                              '(which is necessary to import them from Swift when building as static libraries), ' \
+                              'you may set `use_modular_headers!` globally in your Podfile, '\
+                              'or specify `:modular_headers => true` for particular dependencies.'
+          end
+          return if error_messages.empty?
+
+          raise Informative, 'The following Swift pods cannot yet be integrated '\
+                             "as static libraries:\n\n#{error_messages.join("\n\n")}"
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/open-uri.rb

@@ -0,0 +1,33 @@
+# rubocop:disable Style/FileName
+
+require 'open-uri'
+
+# Allow OpenURI to follow http to https redirects.
+#
+module OpenURI
+  # Whether {#open} should follow a redirect.
+  #
+  # Inspiration from: https://gist.github.com/1271420
+  # Relevant issue:   http://redmine.ruby-lang.org/issues/3719
+  # Source here:      https://github.com/ruby/ruby/blob/trunk/lib/open-uri.rb
+  #
+  # This test is intended to forbid a redirection from http://... to
+  # file:///etc/passwd, file:///dev/zero, etc.  CVE-2011-1521
+  # https to http redirect is also forbidden intentionally.
+  # It avoids sending secure cookie or referrer by non-secure HTTP protocol.
+  # (RFC 2109 4.3.1, RFC 2965 3.3, RFC 2616 15.1.3)
+  # However this is ad hoc.  It should be extensible/configurable.
+  #
+  # @param [URI::Generic] uri1
+  #        the origin uri from where the redirect origins
+  #
+  # @param [URI::Generic] uri2
+  #        the target uri where to where the redirect points to
+  #
+  # @return [Bool]
+  #
+  def self.redirectable?(uri1, uri2)
+    uri1.scheme.downcase == uri2.scheme.downcase ||
+      (/\A(?:http|ftp)\z/i =~ uri1.scheme && /\A(?:https?|ftp)\z/i =~ uri2.scheme)
+  end
+end

data/lib/cocoapods/project.rb

@@ -0,0 +1,414 @@
+require 'xcodeproj'
+require 'active_support/core_ext/string/inflections'
+
+module Pod
+  # The Pods project.
+  #
+  # Model class which provides helpers for working with the Pods project
+  # through the installation process.
+  #
+  class Project < Xcodeproj::Project
+    # @return [PBXGroup] The group for the support files of the aggregate
+    #         targets.
+    #
+    attr_reader :support_files_group
+
+    # @return [PBXGroup] The group for the Pods.
+    #
+    attr_reader :pods
+
+    # @return [PBXGroup] The group for Development Pods.
+    #
+    attr_reader :development_pods
+
+    # Initialize a new instance
+    #
+    # @param  [Pathname, String] path @see #path
+    # @param  [Bool] skip_initialization
+    #         Whether the project should be initialized from scratch.
+    # @param  [Int] object_version
+    #         Object version to use for serialization, defaults to Xcode 3.2 compatible.
+    #
+    def initialize(path, skip_initialization = false,
+        object_version = Xcodeproj::Constants::DEFAULT_OBJECT_VERSION)
+      super(path, skip_initialization, object_version)
+      @support_files_group = new_group('Targets Support Files')
+      @refs_by_absolute_path = {}
+      @variant_groups_by_path_and_name = {}
+      @pods = new_group('Pods')
+      @development_pods = new_group('Development Pods')
+      self.symroot = LEGACY_BUILD_ROOT
+    end
+
+    # Generates a list of new UUIDs that created objects can be assigned.
+    #
+    # @note Overridden to generate UUIDs in a much faster way, since we don't need to check for collisions
+    #       (as the Pods project is regenerated each time, and thus all UUIDs will have come from this method)
+    #
+    # @param [Integer] count
+    #        The number of UUIDs to generate
+    #
+    # @return [Void]
+    #
+    def generate_available_uuid_list(count = 100)
+      start = @generated_uuids.size
+      uniques = Array.new(count) { |i| format('%011X0', start + i) }
+      @generated_uuids += uniques
+      @available_uuids += uniques
+    end
+
+    public
+
+    # @!group Legacy Xcode build root
+    #-------------------------------------------------------------------------#
+
+    LEGACY_BUILD_ROOT = '${SRCROOT}/../build'
+
+    # @param [String] symroot
+    #        The build root that is used when Xcode is configured to not use the
+    #        workspace’s build root. Defaults to `${SRCROOT}/../build`.
+    #
+    # @return [void]
+    #
+    def symroot=(symroot)
+      root_object.build_configuration_list.build_configurations.each do |config|
+        config.build_settings['SYMROOT'] = symroot
+      end
+    end
+
+    public
+
+    # @!group Pod Groups
+    #-------------------------------------------------------------------------#
+
+    # Creates a new group for the Pod with the given name and configures its
+    # path.
+    #
+    # @param  [String] pod_name
+    #         The name of the Pod.
+    #
+    # @param  [#to_s] path
+    #         The path to the root of the Pod.
+    #
+    # @param  [Bool] development
+    #         Wether the group should be added to the Development Pods group.
+    #
+    # @param  [Bool] absolute
+    #         Wether the path of the group should be set as absolute.
+    #
+    # @return [PBXGroup] The new group.
+    #
+    def add_pod_group(pod_name, path, development = false, absolute = false)
+      raise '[BUG]' if pod_group(pod_name)
+
+      parent_group = development ? development_pods : pods
+      source_tree = absolute ? :absolute : :group
+
+      group = parent_group.new_group(pod_name, path, source_tree)
+      group
+    end
+
+    # @return [Array<PBXGroup>] Returns all the group of the Pods.
+    #
+    def pod_groups
+      pods.children.objects + development_pods.children.objects
+    end
+
+    # Returns the group for the Pod with the given name.
+    #
+    # @param  [String] pod_name
+    #         The name of the Pod.
+    #
+    # @return [PBXGroup] The group.
+    #
+    def pod_group(pod_name)
+      pod_groups.find { |group| group.name == pod_name }
+    end
+
+    # @return [Hash] The names of the specification subgroups by key.
+    #
+    SPEC_SUBGROUPS = {
+      :resources  => 'Resources',
+      :frameworks => 'Frameworks',
+      :developer  => 'Pod',
+    }
+
+    # Returns the group for the specification with the give name creating it if
+    # needed.
+    #
+    # @param [String] spec_name
+    #                 The full name of the specification.
+    #
+    # @return [PBXGroup] The group.
+    #
+    def group_for_spec(spec_name, subgroup_key = nil)
+      pod_name = Specification.root_name(spec_name)
+      group = pod_group(pod_name)
+      raise "[Bug] Unable to locate group for Pod named `#{pod_name}`" unless group
+      if spec_name != pod_name
+        subspecs_names = spec_name.gsub(pod_name + '/', '').split('/')
+        subspecs_names.each do |name|
+          group = group[name] || group.new_group(name)
+        end
+      end
+
+      if subgroup_key
+        subgroup_name = SPEC_SUBGROUPS[subgroup_key]
+        raise ArgumentError, "Unrecognized subgroup key `#{subgroup_key}`" unless subgroup_name
+        group = group[subgroup_name] || group.new_group(subgroup_name)
+      end
+
+      group
+    end
+
+    # Returns the support files group for the Pod with the given name.
+    #
+    # @param  [String] pod_name
+    #         The name of the Pod.
+    #
+    # @return [PBXGroup] The group.
+    #
+    def pod_support_files_group(pod_name, dir)
+      group = pod_group(pod_name)
+      support_files_group = group['Support Files']
+      unless support_files_group
+        support_files_group = group.new_group('Support Files', dir)
+      end
+      support_files_group
+    end
+
+    public
+
+    # @!group File references
+    #-------------------------------------------------------------------------#
+
+    # Adds a file reference to given path as a child of the given group.
+    #
+    # @param  [Array<Pathname,String>] absolute_path
+    #         The path of the file.
+    #
+    # @param  [PBXGroup] group
+    #         The group for the new file reference.
+    #
+    # @param  [Bool] reflect_file_system_structure
+    #         Whether group structure should reflect the file system structure.
+    #         If yes, where needed, intermediate groups are created, similar to
+    #         how mkdir -p operates.
+    #
+    # @param  [Pathname] base_path
+    #         The base path for newly created groups when reflect_file_system_structure is true.
+    #         If nil, the provided group's real_path is used.
+    #
+    # @return [PBXFileReference] The new file reference.
+    #
+    def add_file_reference(absolute_path, group, reflect_file_system_structure = false, base_path = nil)
+      file_path_name = absolute_path.is_a?(Pathname) ? absolute_path : Pathname(absolute_path)
+      if ref = reference_for_path(file_path_name)
+        return ref
+      end
+
+      group = group_for_path_in_group(file_path_name, group, reflect_file_system_structure, base_path)
+      ref = group.new_file(file_path_name.realpath)
+      @refs_by_absolute_path[file_path_name.to_s] = ref
+    end
+
+    # Returns the file reference for the given absolute path.
+    #
+    # @param  [#to_s] absolute_path
+    #         The absolute path of the file whose reference is needed.
+    #
+    # @return [PBXFileReference] The file reference.
+    # @return [Nil] If no file reference could be found.
+    #
+    def reference_for_path(absolute_path)
+      absolute_path = absolute_path.is_a?(Pathname) ? absolute_path : Pathname(absolute_path)
+      unless absolute_path.absolute?
+        raise ArgumentError, "Paths must be absolute #{absolute_path}"
+      end
+
+      refs_by_absolute_path[absolute_path.to_s] ||= refs_by_absolute_path[absolute_path.realpath.to_s]
+    end
+
+    # Adds a file reference to the Podfile.
+    #
+    # @param  [#to_s] podfile_path
+    #         The path of the Podfile.
+    #
+    # @return [PBXFileReference] The new file reference.
+    #
+    def add_podfile(podfile_path)
+      new_file(podfile_path, :project).tap do |podfile_ref|
+        mark_ruby_file_ref(podfile_ref)
+      end
+    end
+
+    # Sets the syntax of the provided file reference to be Ruby, in the case that
+    # the file does not already have a ".rb" file extension (ex. the Podfile)
+    #
+    # @param  [PBXFileReference] file_ref
+    #         The file reference to change
+    #
+    def mark_ruby_file_ref(file_ref)
+      file_ref.xc_language_specification_identifier = 'xcode.lang.ruby'
+      file_ref.explicit_file_type = 'text.script.ruby'
+      file_ref.last_known_file_type = 'text'
+    end
+
+    # Adds a new build configuration to the project and populates it with
+    # default settings according to the provided type.
+    #
+    # @note   This method extends the original Xcodeproj implementation to
+    #         include a preprocessor definition named after the build
+    #         setting. This is done to support the TargetEnvironmentHeader
+    #         specification of Pods available only on certain build
+    #         configurations.
+    #
+    # @param  [String] name
+    #         The name of the build configuration.
+    #
+    # @param  [Symbol] type
+    #         The type of the build configuration used to populate the build
+    #         settings, must be :debug or :release.
+    #
+    # @return [XCBuildConfiguration] The new build configuration.
+    #
+    def add_build_configuration(name, type)
+      build_configuration = super
+      settings = build_configuration.build_settings
+      definitions = settings['GCC_PREPROCESSOR_DEFINITIONS'] || ['$(inherited)']
+      defines = [defininition_for_build_configuration(name)]
+      defines << 'DEBUG' if type == :debug
+      defines.each do |define|
+        value = "#{define}=1"
+        unless definitions.include?(value)
+          definitions.unshift(value)
+        end
+      end
+      settings['GCC_PREPROCESSOR_DEFINITIONS'] = definitions
+
+      if type == :debug
+        settings['SWIFT_ACTIVE_COMPILATION_CONDITIONS'] = 'DEBUG'
+      end
+
+      build_configuration
+    end
+
+    # @param  [String] name
+    #         The name of the build configuration.
+    #
+    # @return [String] The preprocessor definition to set for the configuration.
+    #
+    def defininition_for_build_configuration(name)
+      "POD_CONFIGURATION_#{name.underscore}".gsub(/[^a-zA-Z0-9_]/, '_').upcase
+    end
+
+    private
+
+    # @!group Private helpers
+    #-------------------------------------------------------------------------#
+
+    # @return [Hash{String => PBXFileReference}] The file references grouped
+    #         by absolute path.
+    #
+    attr_reader :refs_by_absolute_path
+
+    # @return [Hash{[Pathname, String] => PBXVariantGroup}] The variant groups
+    #         grouped by absolute path of parent dir and name.
+    #
+    attr_reader :variant_groups_by_path_and_name
+
+    # Returns the group for an absolute file path in another group.
+    # Creates subgroups to reflect the file system structure if
+    # reflect_file_system_structure is set to true.
+    # Makes a variant group if the path points to a localized file inside a
+    # *.lproj directory. To support Apple Base Internationalization, the same
+    # variant group is returned for interface files and strings files with
+    # the same name.
+    #
+    # @param  [Pathname] absolute_pathname
+    #         The pathname of the file to get the group for.
+    #
+    # @param  [PBXGroup] group
+    #         The parent group used as the base of the relative path.
+    #
+    # @param  [Bool] reflect_file_system_structure
+    #         Whether group structure should reflect the file system structure.
+    #         If yes, where needed, intermediate groups are created, similar to
+    #         how mkdir -p operates.
+    #
+    # @param  [Pathname] base_path
+    #         The base path for the newly created group. If nil, the provided group's real_path is used.
+    #
+    # @return [PBXGroup] The appropriate group for the filepath.
+    #         Can be PBXVariantGroup, if the file is localized.
+    #
+    def group_for_path_in_group(absolute_pathname, group, reflect_file_system_structure, base_path = nil)
+      unless absolute_pathname.absolute?
+        raise ArgumentError, "Paths must be absolute #{absolute_pathname}"
+      end
+      unless base_path.nil? || base_path.absolute?
+        raise ArgumentError, "Paths must be absolute #{base_path}"
+      end
+
+      relative_base = base_path.nil? ? group.real_path : base_path.realdirpath
+      relative_pathname = absolute_pathname.relative_path_from(relative_base)
+      relative_dir = relative_pathname.dirname
+
+      # Add subgroups for directories, but treat .lproj as a file
+      if reflect_file_system_structure
+        path = relative_base
+        relative_dir.each_filename do |name|
+          break if name.to_s.downcase.include? '.lproj'
+          next if name == '.'
+          # Make sure groups have the correct absolute path set, as intermittent
+          # directories may not be included in the group structure
+          path += name
+          group = group.children.find { |c| c.display_name == name } || group.new_group(name, path)
+        end
+      end
+
+      # Turn files inside .lproj directories into a variant group
+      if relative_dir.basename.to_s.downcase.include? '.lproj'
+        group_name = variant_group_name(absolute_pathname)
+        lproj_parent_dir = absolute_pathname.dirname.dirname
+        group = @variant_groups_by_path_and_name[[lproj_parent_dir, group_name]] ||=
+                  group.new_variant_group(group_name, lproj_parent_dir)
+      end
+
+      group
+    end
+
+    # Returns the name to be used for a the variant group for a file at a given path.
+    # The path must be localized (within an *.lproj directory).
+    #
+    # @param  [Pathname] The localized path to get a variant group name for.
+    #
+    # @return [String] The variant group name.
+    #
+    def variant_group_name(path)
+      unless path.to_s.downcase.include?('.lproj/')
+        raise ArgumentError, 'Only localized resources can be added to variant groups.'
+      end
+
+      # When using Base Internationalization for XIBs and Storyboards a strings
+      # file is generated with the same name as the XIB/Storyboard in each .lproj
+      # directory:
+      #   Base.lproj/MyViewController.xib
+      #   fr.lproj/MyViewController.strings
+      #
+      # In this scenario we want the variant group to be the same as the XIB or Storyboard.
+      #
+      # Base Internationalization: https://developer.apple.com/library/ios/documentation/MacOSX/Conceptual/BPInternational/InternationalizingYourUserInterface/InternationalizingYourUserInterface.html
+      if path.extname.downcase == '.strings'
+        %w(.xib .storyboard).each do |extension|
+          possible_interface_file = path.dirname.dirname + 'Base.lproj' + path.basename.sub_ext(extension)
+          return possible_interface_file.basename.to_s if possible_interface_file.exist?
+        end
+      end
+
+      path.basename.to_s
+    end
+
+    #-------------------------------------------------------------------------#
+  end
+end