cocoapods 0.39.0.beta.1 → 0.39.0.beta.2

data/lib/cocoapods/installer/analyzer/specs_state.rb

@@ -1,76 +0,0 @@
-module Pod
-  class Installer
-    class Analyzer
-      # This class represents the state of a collection of Pods.
-      #
-      # @note The names of the pods stored by this class are always the **root**
-      #       name of the specification.
-      #
-      # @note The motivation for this class is to ensure that the names of the
-      #       subspecs are added instead of the name of the Pods.
-      #
-      class SpecsState
-        # Initialize a new instance
-        #
-        # @param  [Hash{Symbol=>String}] pods_by_state
-        #         The name of the pods grouped by their state
-        #         (`:added`, `:removed`, `:changed` or `:unchanged`).
-        #
-        def initialize(pods_by_state = nil)
-          @added     = []
-          @deleted   = []
-          @changed   = []
-          @unchanged = []
-
-          if pods_by_state
-            @added     = pods_by_state[:added]     || []
-            @deleted   = pods_by_state[:removed]   || []
-            @changed   = pods_by_state[:changed]   || []
-            @unchanged = pods_by_state[:unchanged] || []
-          end
-        end
-
-        # @return [Array<String>] the names of the pods that were added.
-        #
-        attr_accessor :added
-
-        # @return [Array<String>] the names of the pods that were changed.
-        #
-        attr_accessor :changed
-
-        # @return [Array<String>] the names of the pods that were deleted.
-        #
-        attr_accessor :deleted
-
-        # @return [Array<String>] the names of the pods that were unchanged.
-        #
-        attr_accessor :unchanged
-
-        # Displays the state of each pod.
-        #
-        # @return [void]
-        #
-        def print
-          added    .sort.each { |pod| UI.message('A'.green  + " #{pod}", '', 2) }
-          deleted  .sort.each { |pod| UI.message('R'.red    + " #{pod}", '', 2) }
-          changed  .sort.each { |pod| UI.message('M'.yellow + " #{pod}", '', 2) }
-          unchanged.sort.each { |pod| UI.message('-'        + " #{pod}", '', 2) }
-        end
-
-        # Adds the name of a Pod to the give state.
-        #
-        # @param  [String] name
-        #         the name of the Pod.
-        #
-        # @param  [Symbol] state
-        #         the state of the Pod.
-        #
-        # @return [void]
-        #
-        def add_name(name, state)
-          send(state) << name
-        end
-      end
-    end
-  end
-end

data/lib/cocoapods/installer/analyzer/target_inspection_result.rb

@@ -1,41 +0,0 @@
-module Pod
-  class Installer
-    class Analyzer
-      class TargetInspectionResult
-        # @return [TargetDefinition] the target definition, whose project was
-        #         inspected
-        #
-        attr_accessor :target_definition
-
-        # @return [Pathname] the path of the user project that the
-        #         #target_definition should integrate
-        #
-        attr_accessor :project_path
-
-        # @return [Array<String>] the uuid of the user's targets
-        #
-        attr_accessor :project_target_uuids
-
-        # @return [Hash{String=>Symbol}] A hash representing the user build
-        #         configurations where each key corresponds to the name of a
-        #         configuration and its value to its type (`:debug` or
-        #         `:release`).
-        #
-        attr_accessor :build_configurations
-
-        # @return [Platform] the platform of the user targets
-        #
-        attr_accessor :platform
-
-        # @return [Array<String>] the architectures used by user's targets
-        #
-        attr_accessor :archs
-
-        # @return [Bool] whether frameworks are recommended for the integration
-        #         due to the presence of Swift source in the user's targets
-        #
-        attr_accessor :recommends_frameworks
-      end
-    end
-  end
-end

data/lib/cocoapods/installer/analyzer/target_inspector.rb

@@ -1,203 +0,0 @@
-module Pod
-  class Installer
-    class Analyzer
-      class TargetInspector
-        # @return [TargetDefinition] the target definition to inspect
-        #
-        attr_accessor :target_definition
-
-        # @return [Pathname] the root of the CocoaPods installation where the
-        #         Podfile is located
-        attr_accessor :installation_root
-
-        # Initialize a new instance
-        #
-        # @param [TargetDefinition] target_definition
-        #        @see #target_definition
-        #
-        # @param [Pathname] installation_root
-        #        @see #installation_root
-        #
-        def initialize(target_definition, installation_root)
-          @target_definition = target_definition
-          @installation_root = installation_root
-        end
-
-        # Inspect the #target_definition
-        #
-        # @return [TargetInspectionResult]
-        #
-        def compute_results
-          project_path = compute_project_path
-          user_project = Xcodeproj::Project.open(project_path)
-          targets = compute_targets(user_project)
-
-          result = TargetInspectionResult.new
-          result.target_definition = target_definition
-          result.project_path = project_path
-          result.project_target_uuids = targets.map(&:uuid)
-          result.build_configurations = compute_build_configurations(targets)
-          result.platform = compute_platform(targets)
-          result.archs = compute_archs(targets)
-          result
-        end
-
-        #-----------------------------------------------------------------------#
-
-        private
-
-        # Returns the path of the user project that the #target_definition
-        # should integrate.
-        #
-        # @raise  If the project is implicit and there are multiple projects.
-        #
-        # @raise  If the path doesn't exits.
-        #
-        # @return [Pathname] the path of the user project.
-        #
-        def compute_project_path
-          if target_definition.user_project_path
-            path = installation_root + target_definition.user_project_path
-            path = "#{path}.xcodeproj" unless File.extname(path) == '.xcodeproj'
-            path = Pathname.new(path)
-            unless path.exist?
-              raise Informative, 'Unable to find the Xcode project ' \
-              "`#{path}` for the target `#{target_definition.label}`."
-            end
-          else
-            xcodeprojs = installation_root.children.select { |e| e.fnmatch('*.xcodeproj') }
-            if xcodeprojs.size == 1
-              path = xcodeprojs.first
-            else
-              raise Informative, 'Could not automatically select an Xcode project. ' \
-                "Specify one in your Podfile like so:\n\n" \
-                "    xcodeproj 'path/to/Project.xcodeproj'\n"
-            end
-          end
-          path
-        end
-
-        # Returns a list of the targets from the project of #target_definition
-        # that needs to be integrated.
-        #
-        # @note   The method first looks if there is a target specified with
-        #         the `link_with` option of the {TargetDefinition}. Otherwise
-        #         it looks for the target that has the same name of the target
-        #         definition.  Finally if no target was found the first
-        #         encountered target is returned (it is assumed to be the one
-        #         to integrate in simple projects).
-        #
-        # @param  [Xcodeproj::Project] user_project
-        #         the user project
-        #
-        # @return [Array<PBXNativeTarget>]
-        #
-        def compute_targets(user_project)
-          native_targets = user_project.native_targets
-          if link_with = target_definition.link_with
-            targets = native_targets.select { |t| link_with.include?(t.name) }
-            raise Informative, "Unable to find the targets named #{link_with.map { |x| "`#{x}`" }.to_sentence}" \
-              "to link with target definition `#{target_definition.name}`" if targets.empty?
-          elsif target_definition.link_with_first_target?
-            targets = [native_targets.first].compact
-            raise Informative, 'Unable to find a target' if targets.empty?
-          else
-            target = native_targets.find { |t| t.name == target_definition.name.to_s }
-            targets = [target].compact
-            raise Informative, "Unable to find a target named `#{target_definition.name}`" if targets.empty?
-          end
-          targets
-        end
-
-        # @param  [Array<PBXNativeTarget] the user's targets of the project of
-        #         #target_definition which needs to be integrated
-        #
-        # @return [Hash{String=>Symbol}] A hash representing the user build
-        #         configurations where each key corresponds to the name of a
-        #         configuration and its value to its type (`:debug` or `:release`).
-        #
-        def compute_build_configurations(user_targets)
-          if user_targets
-            user_targets.flat_map { |t| t.build_configurations.map(&:name) }.each_with_object({}) do |name, hash|
-              hash[name] = name == 'Debug' ? :debug : :release
-            end.merge(target_definition.build_configurations || {})
-          else
-            target_definition.build_configurations || {}
-          end
-        end
-
-        # @param  [Array<PBXNativeTarget] the user's targets of the project of
-        #         #target_definition which needs to be integrated
-        #
-        # @return [Platform] The platform of the user's targets
-        #
-        # @note   This resolves to the lowest deployment target across the user
-        #         targets.
-        #
-        # @todo   Is assigning the platform to the target definition the best way
-        #         to go?
-        #
-        def compute_platform(user_targets)
-          return target_definition.platform if target_definition.platform
-          name = nil
-          deployment_target = nil
-
-          user_targets.each do |target|
-            name ||= target.platform_name
-            raise Informative, 'Targets with different platforms' unless name == target.platform_name
-            if !deployment_target || deployment_target > Version.new(target.deployment_target)
-              deployment_target = Version.new(target.deployment_target)
-            end
-          end
-
-          target_definition.set_platform(name, deployment_target)
-          Platform.new(name, deployment_target)
-        end
-
-        # Computes the architectures relevant for the user's targets.
-        #
-        # @param  [Array<PBXNativeTarget] the user's targets of the project of
-        #         #target_definition which needs to be integrated
-        #
-        # @return [Array<String>]
-        #
-        def compute_archs(user_targets)
-          user_targets.flat_map do |target|
-            Array(target.common_resolved_build_setting('ARCHS'))
-          end.compact.uniq.sort
-        end
-
-        # Checks if any of the targets for the {TargetDefinition} computed before
-        # by #compute_user_project_targets is recommended to be build as a framework
-        # due the presence of Swift source code in any of the source build phases.
-        #
-        # @param  [TargetDefinition] target_definition
-        #         the target definition
-        #
-        # @param  [Array<PBXNativeTarget>] native_targets
-        #         the targets which are checked for presence of Swift source code
-        #
-        # @return [Boolean] Whether the user project targets to integrate into
-        #         uses Swift
-        #
-        def compute_recommends_frameworks(target_definition, native_targets)
-          file_predicate = nil
-          file_predicate = proc do |file_ref|
-            if file_ref.respond_to?(:last_known_file_type)
-              file_ref.last_known_file_type == 'sourcecode.swift'
-            elsif file_ref.respond_to?(:files)
-              file_ref.files.any?(&file_predicate)
-            else
-              false
-            end
-          end
-          target_definition.platform.supports_dynamic_frameworks? || native_targets.any? do |target|
-            target.source_build_phase.files.any? do |build_file|
-              file_predicate.call(build_file.file_ref)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cocoapods/installer/target_installer/aggregate_target_installer.rb

@@ -1,186 +0,0 @@
-module Pod
-  class Installer
-    # Creates the targets which aggregate the Pods libraries in the Pods
-    # project and the relative support files.
-    #
-    class AggregateTargetInstaller < TargetInstaller
-      # Creates the target in the Pods project and the relative support files.
-      #
-      # @return [void]
-      #
-      def install!
-        UI.message "- Installing target `#{target.name}` #{target.platform}" do
-          add_target
-          create_support_files_dir
-          create_support_files_group
-          create_xcconfig_file
-          if target.requires_frameworks?
-            create_info_plist_file
-            create_module_map
-            create_umbrella_header
-          end
-          create_embed_frameworks_script
-          create_bridge_support_file
-          create_copy_resources_script
-          create_acknowledgements
-          create_dummy_source
-        end
-      end
-
-      #-----------------------------------------------------------------------#
-
-      private
-
-      # @return [TargetDefinition] the target definition of the library.
-      #
-      def target_definition
-        target.target_definition
-      end
-
-      # Ensure that vendored static frameworks and libraries are not linked
-      # twice to the aggregate target, which shares the xcconfig of the user
-      # target.
-      #
-      def custom_build_settings
-        settings = {
-          'OTHER_LDFLAGS'      => '',
-          'OTHER_LIBTOOLFLAGS' => '',
-          'PODS_ROOT'          => '$(SRCROOT)',
-          'SKIP_INSTALL'       => 'YES',
-        }
-        super.merge(settings)
-      end
-
-      # Creates the group that holds the references to the support files
-      # generated by this installer.
-      #
-      # @return [void]
-      #
-      def create_support_files_group
-        parent = project.support_files_group
-        name = target.name
-        dir = target.support_files_dir
-        @support_files_group = parent.new_group(name, dir)
-      end
-
-      # Generates the contents of the xcconfig file and saves it to disk.
-      #
-      # @return [void]
-      #
-      def create_xcconfig_file
-        native_target.build_configurations.each do |configuration|
-          path = target.xcconfig_path(configuration.name)
-          gen = Generator::XCConfig::AggregateXCConfig.new(target, configuration.name)
-          gen.save_as(path)
-          target.xcconfigs[configuration.name] = gen.xcconfig
-          xcconfig_file_ref = add_file_to_support_group(path)
-          configuration.base_configuration_reference = xcconfig_file_ref
-        end
-      end
-
-      # Generates the bridge support metadata if requested by the {Podfile}.
-      #
-      # @note   The bridge support metadata is added to the resources of the
-      #         target because it is needed for environments interpreted at
-      #         runtime.
-      #
-      # @return [void]
-      #
-      def create_bridge_support_file
-        if target.podfile.generate_bridge_support?
-          path = target.bridge_support_path
-          headers = native_target.headers_build_phase.files.map { |bf| sandbox.root + bf.file_ref.path }
-          generator = Generator::BridgeSupport.new(headers)
-          generator.save_as(path)
-          add_file_to_support_group(path)
-          @bridge_support_file = path.relative_path_from(sandbox.root)
-        end
-      end
-
-      # Uniqued Resources grouped by config
-      #
-      # @return [Hash{ Symbol => Array<Pathname> }]
-      #
-      def resources_by_config
-        library_targets = target.pod_targets.reject do |pod_target|
-          pod_target.should_build? && pod_target.requires_frameworks?
-        end
-        resources_by_config = {}
-        target.user_build_configurations.keys.each do |config|
-          file_accessors = library_targets.select { |t| t.include_in_build_config?(target_definition, config) }.flat_map(&:file_accessors)
-          resource_paths = file_accessors.flat_map { |accessor| accessor.resources.flat_map { |res| res.relative_path_from(project.path.dirname) } }
-          resource_bundles = file_accessors.flat_map { |accessor| accessor.resource_bundles.keys.map { |name| "${BUILT_PRODUCTS_DIR}/#{name.shellescape}.bundle" } }
-          resources_by_config[config] = (resource_paths + resource_bundles).uniq
-          resources_by_config[config] << bridge_support_file if bridge_support_file
-        end
-        resources_by_config
-      end
-
-      # Creates a script that copies the resources to the bundle of the client
-      # target.
-      #
-      # @note   The bridge support file needs to be created before the prefix
-      #         header, otherwise it will not be added to the resources script.
-      #
-      # @return [void]
-      #
-      def create_copy_resources_script
-        path = target.copy_resources_script_path
-        generator = Generator::CopyResourcesScript.new(resources_by_config, target.platform)
-        generator.save_as(path)
-        add_file_to_support_group(path)
-      end
-
-      # Creates a script that embeds the frameworks to the bundle of the client
-      # target.
-      #
-      # @note   We can't use Xcode default copy bundle resource phase, because
-      #         we need to ensure that we only copy the resources, which are
-      #         relevant for the current build configuration.
-      #
-      # @return [void]
-      #
-      def create_embed_frameworks_script
-        path = target.embed_frameworks_script_path
-        frameworks_by_config = {}
-        target.user_build_configurations.keys.each do |config|
-          relevant_pod_targets = target.pod_targets.select do |pod_target|
-            pod_target.include_in_build_config?(target_definition, config)
-          end
-          frameworks_by_config[config] = relevant_pod_targets.flat_map do |pod_target|
-            frameworks = pod_target.file_accessors.flat_map(&:vendored_dynamic_artifacts).map { |fw| "${PODS_ROOT}/#{fw.relative_path_from(sandbox.root)}" }
-            frameworks << "#{target_definition.label}/#{pod_target.product_name}" if pod_target.should_build? && pod_target.requires_frameworks?
-            frameworks
-          end
-        end
-        generator = Generator::EmbedFrameworksScript.new(frameworks_by_config)
-        generator.save_as(path)
-        add_file_to_support_group(path)
-      end
-
-      # Generates the acknowledgement files (markdown and plist) for the target.
-      #
-      # @return [void]
-      #
-      def create_acknowledgements
-        basepath = target.acknowledgements_basepath
-        Generator::Acknowledgements.generators.each do |generator_class|
-          path = generator_class.path_from_basepath(basepath)
-          file_accessors = target.pod_targets.map(&:file_accessors).flatten
-          generator = generator_class.new(file_accessors)
-          generator.save_as(path)
-          add_file_to_support_group(path)
-        end
-      end
-
-      # @return [Pathname] the path of the bridge support file relative to the
-      #         sandbox.
-      #
-      # @return [Nil] if no bridge support file was generated.
-      #
-      attr_reader :bridge_support_file
-
-      #-----------------------------------------------------------------------#
-    end
-  end
-end