cocoapods-project-gen 0.1.0 → 0.2.3

data/lib/cocoapods-project-gen/gen/pod/project_gen_helper.rb

@@ -0,0 +1,341 @@
+module ProjectGen
+  module Helper
+    include Pod
+
+    def self.app_target_name(platform)
+      "App-#{platform.string_name}"
+    end
+
+    private
+
+    # The specifications matching the specified pod name
+    #
+    # @param  [String] pod_name the name of the pod
+    #
+    # @return [Hash{Specification => Array<Taget>}] the specifications grouped by platform
+    #
+    def specs_for_pods
+      @installer.pod_targets.each_with_object({}) do |pod_target, hash|
+        hash[pod_target.root_spec] ||= []
+        hash[pod_target.root_spec] << pod_target
+      end
+    end
+
+    def setup_gen_environment
+      project_gen_dir.rmtree if project_gen_dir.exist?
+      project_gen_dir.mkpath
+      @original_config = Pod::Config.instance.clone
+      config.installation_root   = project_gen_dir
+      config.silent              = !config.verbose
+    end
+
+    # !@group Lint steps
+    def perform_linting
+      podspecs.each do |podspec|
+        linter = Pod::Specification::Linter.new(podspec)
+        linter.lint
+        @results.results.concat(linter.results.to_a)
+      end
+    end
+
+    def podspecs
+      return @podspecs if defined? @podspecs
+
+      additional_podspec_pods = external_podspecs ? Dir.glob(external_podspecs) : []
+      additional_path_pods = include_podspecs ? Dir.glob(include_podspecs) : []
+      @podspecs = (additional_podspec_pods + additional_path_pods).uniq.each_with_object({}) do |path, hash|
+        spec = Pod::Specification.from_file(path)
+        old_spec = hash[spec.name]
+        if old_spec && use_latest
+          hash[spec.name] = [old_spec, spec].max { |old, new| old.version <=> new.version }
+        else
+          hash[spec.name] = spec
+        end
+      end.values
+    end
+
+    def include_specifications
+      (include_podspecs ? Dir.glob(include_podspecs) : []).map do |path|
+        Pod::Specification.from_file(path)
+      end
+    end
+
+    # Returns a list of platforms to lint for a given Specification
+    #
+    # @return [Array<Platform>] platforms to lint for the given specification
+    #
+    def determine_platforms
+      return @determine_platforms if defined?(@determine_platforms) && @determine_platforms == @platform
+
+      platforms = podspecs.flat_map(&:available_platforms).uniq
+      platforms = platforms.map do |platform|
+        default = Pod::Podfile::TargetDefinition::PLATFORM_DEFAULTS[platform.name]
+        deployment_target = podspecs.flat_map do |library_spec|
+          subspecs = determine_subspecs[library_spec]
+          if subspecs && !subspecs.empty?
+            subspecs.map { |s| Pod::Version.new(s.deployment_target(platform.name) || default) }
+          else
+            Pod::Version.new(library_spec.deployment_target(platform.name) || default)
+          end
+        end.max
+        if platform.name == :ios && use_frameworks
+          minimum = Pod::Version.new('8.0')
+          deployment_target = [deployment_target, minimum].max
+        end
+        Pod::Platform.new(platform.name, deployment_target)
+      end.uniq
+
+      unless @platforms.empty?
+        # Validate that the platforms specified are actually supported by the spec
+        platforms = @platforms.map do |platform|
+          matching_platform = platforms.find { |p| p.name == platform.name }
+          unless matching_platform
+            raise Informative, "Platform `#{platform}` is not supported by specification `#{spec}`."
+          end
+
+          matching_platform
+        end.uniq
+      end
+      @platform = platforms
+      @determine_platforms = platforms
+    end
+
+    def determine_subspecs
+      return @determine_subspecs if defined? @determine_subspecs
+      return {} if @only_subspecs.nil?
+
+      subspecs = @only_subspecs.dup
+      ha = podspecs.each_with_object({}) do |podspec, hash|
+        return hash if subspecs.empty?
+
+        base_name = podspec.name
+        s_s = []
+        subspecs.delete_if { |ss| s_s << podspec.subspec_by_name(ss, false) if ss.split('/').shift == base_name }
+        s_s.compact!
+        hash[podspec] = s_s unless s_s.empty?
+      end
+      subspecs.each { |s| results.warning('subspecs', "#{s} should use NAME/NAME.") }
+      @determine_subspecs = ha
+    end
+
+    def validate_vendored_dynamic_frameworks
+      platform = determine_platforms.find { |pl| pl.name == :ios }
+      targets = relative_pod_targets_from_platfrom(platform)
+      targets.flat_map(&:file_accessors).each do |file_accessor|
+        deployment_target = platform.deployment_target
+        dynamic_frameworks = file_accessor.vendored_dynamic_frameworks
+        dynamic_libraries = file_accessor.vendored_dynamic_libraries
+        if (dynamic_frameworks.count.positive? || dynamic_libraries.count.positive?) && platform.name == :ios &&
+           (deployment_target.nil? || deployment_target.major < 8)
+          error('dynamic', 'Dynamic frameworks and libraries are only supported on iOS 8.0 and onwards.')
+        end
+      end
+    end
+
+    def create_app_project
+      p_path = project_gen_dir + 'App.xcodeproj'
+      app_project = if p_path.exist?
+                      Xcodeproj::Project.open(p_path)
+                    else
+                      Xcodeproj::Project.new(File.join(project_gen_dir, 'App.xcodeproj'))
+                    end
+      determine_platforms.each do |platform|
+        app_target = Pod::Generator::AppTargetHelper.add_app_target(app_project, platform.name,
+                                                                    platform.deployment_target.to_s, Helper.app_target_name(platform))
+        sandbox = Pod::Sandbox.new(config.sandbox_root)
+        info_plist_path = app_project.path.dirname.+("App/#{Helper.app_target_name(platform)}-Info.plist")
+        Pod::Installer::Xcode::PodsProjectGenerator::TargetInstallerHelper.create_info_plist_file_with_sandbox(sandbox,
+                                                                                                               info_plist_path,
+                                                                                                               app_target,
+                                                                                                               '1.0.0',
+                                                                                                               Pod::Platform.new(platform.name),
+                                                                                                               :appl,
+                                                                                                               build_setting_value: "$(SRCROOT)/App/#{Helper.app_target_name(platform)}-Info.plist")
+        Pod::Generator::AppTargetHelper.add_swift_version(app_target, derived_swift_version)
+        app_target.build_configurations.each do |config|
+          # Lint will fail if a AppIcon is set but no image is found with such name
+          # Happens only with Static Frameworks enabled but shouldn't be set anyway
+          config.build_settings.delete('ASSETCATALOG_COMPILER_APPICON_NAME')
+          # Ensure this is set generally but we have seen an issue with ODRs:
+          # see: https://github.com/CocoaPods/CocoaPods/issues/10933
+          config.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'org.cocoapods.${PRODUCT_NAME:rfc1034identifier}'
+        end
+      end
+      app_project.save
+      app_project.recreate_user_schemes
+    end
+
+    # It creates a podfile in memory and builds a library containing the pod
+    # for all available platforms with xcodebuild.
+    #
+    def install_pod
+      %i[validate_targets generate_pods_project integrate_user_project
+         perform_post_install_actions].each { |m| @installer.send(m) }
+      configure_pod_targets(@installer.target_installation_results)
+
+      determine_platforms.each do |platform|
+        validate_dynamic_framework_support(platform.name, @installer.aggregate_targets, platform.deployment_target.to_s)
+      end
+      @installer.pods_project.save
+    end
+
+    # @param [Array<Hash{String, TargetInstallationResult}>] target_installation_results
+    #        The installation results to configure
+    #
+    def configure_pod_targets(target_installation_results)
+      target_installation_results.first.values.each do |pod_target_installation_result|
+        pod_target = pod_target_installation_result.target
+        native_target = pod_target_installation_result.native_target
+        native_target.build_configuration_list.build_configurations.each do |build_configuration|
+          (build_configuration.build_settings['OTHER_CFLAGS'] ||= '$(inherited)') << ' -Wincomplete-umbrella'
+          next unless pod_target.uses_swift?
+
+          # The Swift version for the target being validated can be overridden by `--swift-version` or the
+          # `.swift-version` file so we always use the derived Swift version.
+          #
+          # For dependencies, if the derived Swift version is supported then it is the one used. Otherwise, the Swift
+          # version for dependencies is inferred by the target that is integrating them.
+          swift_version = pod_target.spec_swift_versions.map(&:to_s).find do |v|
+            v == derived_swift_version
+          end || pod_target.swift_version
+          build_configuration.build_settings['SWIFT_VERSION'] = swift_version
+        end
+        pod_target_installation_result.test_specs_by_native_target.each do |test_native_target, test_spec|
+          next unless pod_target.uses_swift_for_spec?(test_spec)
+
+          test_native_target.build_configuration_list.build_configurations.each do |build_configuration|
+            swift_version = pod_target == validation_pod_target ? derived_swift_version : pod_target.swift_version
+            build_configuration.build_settings['SWIFT_VERSION'] = swift_version
+          end
+        end
+      end
+    end
+
+    # Produces an error of dynamic frameworks were requested but are not supported by the deployment target
+    #
+    # @param [Array<AggregateTarget>] aggregate_targets
+    #        The aggregate targets installed by the installer
+    #
+    # @param [String,Version] deployment_target
+    #        The deployment target of the installation
+    #
+    def validate_dynamic_framework_support(platform_name, aggregate_targets, deployment_target)
+      return unless platform_name == :ios
+      return unless deployment_target.nil? || Pod::Version.new(deployment_target).major < 8
+
+      aggregate_targets.each do |target|
+        next unless target.pod_targets.any?(&:uses_swift?)
+
+        uses_xctest = target.spec_consumers.any? do |c|
+          (c.frameworks + c.weak_frameworks).include? 'XCTest'
+        end
+        unless uses_xctest
+          error('swift',
+                'Swift support uses dynamic frameworks and is therefore only supported on iOS > 8.')
+        end
+      end
+    end
+
+    # @return [Boolean]
+    #
+    def validated?
+      results.result_type != :error && (results.result_type != :warning || allow_warnings)
+    end
+
+    # Returns the pod target for the pod being relatived. Installation must have occurred before this can be invoked.
+    #
+    def relative_pod_targets_from_platfrom(platform)
+      @installer.pod_targets.select { |pt| pt.platform.name == platform.name }
+    end
+
+    # @param  [String] platform_name
+    #         the name of the platform, which should be declared
+    #         in the Podfile.
+    #
+    # @param  [String] deployment_target
+    #         the deployment target, which should be declared in
+    #         the Podfile.
+    #
+    # @param  [Boolean] use_frameworks
+    #         whether frameworks should be used for the installation
+    #
+    # @param [Array<String>] test_spec_names
+    #         the test spec names to include in the podfile.
+    #
+    # @return [Podfile] a podfile that requires the specification on the
+    #         current platform.
+    #
+    # @note   The generated podfile takes into account whether the linter is
+    #         in local mode.
+    #
+    def podfile_from_spec(use_frameworks = true, use_modular_headers = false, use_static_frameworks = false)
+      urls = source_urls
+      all_podspec_pods = podspecs
+      platforms = determine_platforms
+      d_subspecs = determine_subspecs
+      Pod::Podfile.new do
+        install! 'cocoapods', deterministic_uuids: false, warn_for_unused_master_specs_repo: false
+        # By default inhibit warnings for all pods, except the one being validated.
+        inhibit_all_warnings!
+        urls.each { |u| source(u) }
+        platforms.each do |platform|
+          app_name = ProjectGen::Helper.app_target_name(platform)
+          target(app_name) do
+            if use_static_frameworks
+              use_frameworks!(linkage: :static)
+            else
+              use_frameworks!(use_frameworks)
+            end
+            use_modular_headers! if use_modular_headers
+            platform(platform.name, platform.deployment_target.to_s)
+
+            all_podspec_pods.each do |podspec|
+              subspecs = d_subspecs[podspec]
+              if subspecs && !subspecs.empty?
+                subspecs.each do |s|
+                  if s.supported_on_platform?(platform)
+                    pod s.name, podspec: s.defined_in_file.to_s,
+                                inhibit_warnings: false
+                  end
+                end
+              elsif podspec.supported_on_platform?(platform)
+                pod podspec.name, podspec: podspec.defined_in_file.to_s,
+                                  inhibit_warnings: false
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def add_app_project_import
+      app_project = Xcodeproj::Project.open(project_gen_dir + 'App.xcodeproj')
+      app_project.targets.each do |app_target|
+        platform = determine_platforms.find { |pl| pl.name == app_target.platform_name }
+        pod_targets = relative_pod_targets_from_platfrom(platform)
+        pod_targets.each do |pod_target|
+          Pod::Generator::AppTargetHelper.add_app_project_import(app_project, app_target, pod_target, platform.name,
+                                                                 Helper.app_target_name(platform))
+        end
+        Pod::Generator::AppTargetHelper.add_xctest_search_paths(app_target) if pod_targets.any? do |pt|
+          pt.spec_consumers.any? do |c|
+            c.frameworks.include?('XCTest') || c.weak_frameworks.include?('XCTest')
+          end
+        end
+        Pod::Generator::AppTargetHelper.add_empty_swift_file(app_project, app_target) if pod_targets.any?(&:uses_swift?)
+        app_project.save
+        Xcodeproj::XCScheme.share_scheme(app_project.path, Helper.app_target_name(platform))
+        pod_targets.each do |pod_target|
+          if shares_pod_target_xcscheme?(pod_target)
+            Xcodeproj::XCScheme.share_scheme(@installer.pods_project.path,
+                                             pod_target.label)
+          end
+        end
+      end
+    end
+
+    def shares_pod_target_xcscheme?(pod_target)
+      Pathname.new(@installer.pods_project.path + pod_target.label).exist?
+    end
+  end
+end

data/lib/cocoapods-project-gen/gen/pod/swift_module_helper.rb

@@ -0,0 +1,134 @@
+module ProjectGen
+  module SwiftModule
+    # @return [String] the SWIFT_VERSION within the .swift-version file or nil.
+    #
+    def dot_swift_version(podspec)
+      file = podspec.defined_in_file
+      swift_version_path = file.dirname + '.swift-version'
+      return unless swift_version_path.exist?
+
+      swift_version_path.read.strip
+    end
+
+    # @return [String] The derived Swift version to use for validation. The order of precedence is as follows:
+    #         - The `--swift-version` parameter is always checked first and honored if passed.
+    #         - The `swift_versions` DSL attribute within the podspec, in which case the latest version is always chosen.
+    #         - The Swift version within the `.swift-version` file if present.
+    #         - If none of the above are set then the `#DEFAULT_SWIFT_VERSION` is used.
+    #
+    def derived_swift_version
+      @derived_swift_version ||= if swift_version
+                                   swift_version
+                                 else
+                                   version = podspecs.map do |podspec|
+                                     podspec.swift_versions.max || dot_swift_version(podspec)
+                                   end.compact.max
+                                   if version
+                                     version.to_s
+                                   else
+                                     Constants::DEFAULT_SWIFT_VERSION
+                                   end
+                                 end
+    end
+
+    # Performs validation for the version of Swift used during validation.
+    #
+    # An error will be displayed if the user has provided a `swift_versions` attribute within the podspec but is also
+    # using either `--swift-version` parameter or a `.swift-version` file with a Swift version that is not declared
+    # within the attribute.
+    #
+    # The user will be warned that the default version of Swift was used if the following things are true:
+    #   - The project uses Swift at all
+    #   - The user did not supply a Swift version via a parameter
+    #   - There is no `swift_versions` attribute set within the specification
+    #   - There is no `.swift-version` file present either.
+    #
+    def validate_swift_version
+
+      specs_for_pods.each_pair do |spec, pod_targets|
+        next unless pod_targets.any?(&:uses_swift?)
+
+        spec_swift_versions = spec.swift_versions.map(&:to_s)
+
+        dot_swift = dot_swift_version(spec)
+        unless spec_swift_versions.empty?
+          message = nil
+          if !dot_swift.nil? && !spec_swift_versions.include?(dot_swift)
+            message = "Specification `#{spec.name}` specifies inconsistent `swift_versions` (#{spec_swift_versions.map do |s|
+                                                                                                 "`#{s}`"
+                                                                                               end.to_sentence}) compared to the one present in your `.swift-version` file (`#{dot_swift_version}`). " \
+                      'Please remove the `.swift-version` file which is now deprecated and only use the `swift_versions` attribute within your podspec.'
+          elsif !swift_version.nil? && !spec_swift_versions.include?(swift_version)
+            message = "Specification `#{spec.name}` specifies inconsistent `swift_versions` (#{spec_swift_versions.map do |s|
+                                                                                                 "`#{s}`"
+                                                                                               end.to_sentence}) compared to the one passed during gen (`#{swift_version}`)."
+          end
+          unless message.nil?
+            @results.error('swift', message)
+            break
+          end
+        end
+
+        if swift_version.nil? && spec.swift_versions.empty?
+          if !dot_swift.nil?
+            # The user will be warned to delete the `.swift-version` file in favor of the `swift_versions` DSL attribute.
+            # This is intentionally not a lint warning since we do not want to break existing setups and instead just soft
+            # deprecate this slowly.
+            #
+            Pod::UI.warn 'Usage of the `.swift_version` file has been deprecated! Please delete the file and use the ' \
+              "`swift_versions` attribute within your podspec instead.\n".yellow
+          else
+            results.warning('swift',
+                    'The generator used ' \
+                    "Swift `#{Constants::DEFAULT_SWIFT_VERSION}` by default because no Swift version was specified. " \
+                    'To specify a Swift version during validation, add the `swift_versions` attribute in your podspec. ' \
+                    'Note that usage of a `.swift-version` file is now deprecated.')
+          end
+        end
+      end
+    end
+    # Adds a shell script phase, intended only for library targets that contain swift,
+    # to copy the ObjC compatibility header (the -Swift.h file that the swift compiler generates)
+    # to the built products directory. Additionally, the script phase copies the module map, appending a `.Swift`
+    # submodule that references the (moved) compatibility header. Since the module map has been moved, the umbrella header
+    # is _also_ copied, so that it is sitting next to the module map. This is necessary for a successful archive build.
+    #
+    # @param  [PBXNativeTarget] native_target
+    #         the native target to add the Swift static library script phase into.
+    #
+    # @return [Void]
+    #
+    def add_swift_library_compatibility_header(targets)
+      targets.select(&:build_as_library?).each do |target|
+        relative_module_map_path = target.module_map_path.relative_path_from(target.sandbox.root)
+        relative_umbrella_header_path = target.umbrella_header_path.relative_path_from(target.sandbox.root)
+        shell_script = <<-SH.strip_heredoc
+              COMPATIBILITY_HEADER_ROOT_PATH="${SRCROOT}/${PRODUCT_MODULE_NAME}/#{Constants::COPY_LIBRARY_SWIFT_HEADERS}"
+              COPY_MODULE_MAP_PATH="${COMPATIBILITY_HEADER_ROOT_PATH}/${PRODUCT_MODULE_NAME}.modulemap"
+              ditto "${PODS_ROOT}/#{relative_module_map_path}" "${COPY_MODULE_MAP_PATH}"
+              UMBRELLA_HEADER_PATH="${PODS_ROOT}/#{relative_umbrella_header_path}"
+              if test -f "$UMBRELLA_HEADER_PATH"; then
+                ditto "$UMBRELLA_HEADER_PATH" "${COMPATIBILITY_HEADER_ROOT_PATH}"
+              fi
+        SH
+
+        target.root_spec.script_phases ||= []
+        target.root_spec.script_phases += [{ name: 'Copy Copy generated module header', script: shell_script }]
+        next unless target.uses_swift?
+
+        shell_script = <<-SH.strip_heredoc
+              COMPATIBILITY_HEADER_ROOT_PATH="${SRCROOT}/${PRODUCT_MODULE_NAME}/#{Constants::COPY_LIBRARY_SWIFT_HEADERS}"
+              COPY_COMPATIBILITY_HEADER_PATH="${COMPATIBILITY_HEADER_ROOT_PATH}/${PRODUCT_MODULE_NAME}-Swift.h"#{' '}
+              COPY_MODULE_MAP_PATH="${COMPATIBILITY_HEADER_ROOT_PATH}/${PRODUCT_MODULE_NAME}.modulemap"
+              ditto "${DERIVED_SOURCES_DIR}/${PRODUCT_MODULE_NAME}-Swift.h" "${COPY_COMPATIBILITY_HEADER_PATH}"#{' '}
+              ditto "${BUILT_PRODUCTS_DIR}/${PRODUCT_MODULE_NAME}.swiftmodule" "${COMPATIBILITY_HEADER_ROOT_PATH}/${PRODUCT_MODULE_NAME}.swiftmodule"#{' '}
+              printf "\\n\\nmodule ${PRODUCT_MODULE_NAME}.Swift {\\n  header \\"${PRODUCT_MODULE_NAME}-Swift.h\\"\\n  requires objc\\n}\\n" >> "${COPY_MODULE_MAP_PATH}"
+        SH
+        target.root_spec.script_phases += [{
+          name: 'Copy Copy generated module and compatibility header',
+          script: shell_script
+        }]
+      end
+    end
+  end
+end

data/lib/cocoapods-project-gen/gen/product/product_helper.rb

@@ -0,0 +1,93 @@
+require 'cocoapods/target/pod_target'
+
+module ProjectGen
+
+  require 'delegate'
+
+  class GenTarget < DelegateClass(Pod::PodTarget)
+    def initialize(target)
+      super(target)
+      target.uses_swift?
+    end
+  end
+
+  module ProductHelper
+    
+    def version
+      root_spec.version
+    end
+
+    def label
+      target.label
+    end
+
+    def scope_suffix
+      target.scope_suffix
+    end
+
+    def static_library_name
+      "lib#{Utils.remove_target_scope_suffix(label, scope_suffix)}.a"
+    end
+
+    def pod_dir
+      root_name = module_basename
+      sandbox.sources_root + root_name
+    end
+
+    def build_as_library?
+      target.build_as_library?
+    end
+
+    def uses_swift?
+      target.uses_swift?
+    end
+
+    def build_as_framework?
+      target.build_as_framework?
+    end
+
+    def module_basename 
+      Pod::Specification.root_name(pod_name)
+    end
+
+    def product_name
+      target.product_name
+    end
+
+    def pod_name
+      target.pod_name
+    end
+
+    def product_type
+      target.product_type
+    end
+
+    def file_accessors
+      target.file_accessors
+    end
+
+    def sandbox
+      target.sandbox
+    end
+
+    def xcframework_product_name
+      "#{xcframework_name}.xcframework"
+    end
+
+    def xcframework_name
+      pod_name
+    end
+
+    def root_spec
+      target.root_spec
+    end
+
+    def product_path
+      product_root.join("#{module_basename}-#{product_type}-#{version}")
+    end
+
+    def xcframework_product_path
+      product_path.join(xcframework_product_name)
+    end
+  end
+end