cocoapods-project-gen 0.1.0 → 0.2.5

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

@@ -0,0 +1,165 @@
+module ProjectGen
+  require 'cocoapods-project-gen/gen/product/product_helper'
+  require 'cocoapods-project-gen/gen/build/xcode_build'
+  class Products
+    attr_reader :products
+
+    def initialize(spec, products)
+      @products = products
+      @spec = spec
+    end
+
+    def add_pod_targets_file_accessors_paths
+      products.each(&:add_pod_target_file_accessors_paths)
+    end
+
+    def create_bin_products
+      FileUtils.rm_rf(product_path) if product_path.exist?
+      build_xcframework
+      add_pod_targets_file_accessors_paths
+    end
+
+    # Performs platform specific analysis. It requires to download the source
+    # at each iteration
+    #
+    # @note   Xcode warnings are treated as notes because the spec maintainer
+    #         might not be the author of the library
+    # @return [void]
+    def build_xcframework
+      xc_args = @products.flat_map(&:create_bin_product_args!)
+      error = XcodeBuild.create_xcframework?(xc_args, xcframework_product_path)
+      print_pod_xcframework_infos unless error
+    end
+
+    def xcframework_product_path
+      @products[0].xcframework_product_path
+    end
+
+    def product_path
+      @products[0].product_path
+    end
+
+    private
+    # Prints the list of specs & pod cache dirs for a single pod name.
+    #
+    # This output is valid YAML so it can be parsed with 3rd party tools
+    #
+    def print_pod_xcframework_infos
+      product = @products[0]
+      Results.puts("#{product.xcframework_name}:".green)
+      Results.puts("  - Version: #{product.version}".green)
+      Results.puts("    Type:    #{product.product_type}".green)
+      Results.puts("    path:    #{product_path}".green)
+    end
+  end
+
+  class Product
+    include ProductHelper
+
+    attr_reader :target, :product_root
+
+    def initialize(target, product_root, root, archive_paths)
+      @target = GenTarget.new(target)
+      @archive_paths = archive_paths
+      @product_root = product_root
+      @root = root
+    end
+
+    def create_bin_product_args!
+      @archive_paths.flat_map do |path|
+        headers_dir = path.dirname.join(pod_name).join('Headers')
+        args = %W[-archive #{path}]
+        args + if build_as_framework?
+                 %W[-framework #{product_name}]
+               else
+                 h_a = %W[-headers #{headers_dir}] if headers_dir.exist? && headers_dir.children.count.nonzero?
+                 %W[-library #{static_library_name}] + (h_a || [])
+               end
+      end
+    end
+
+    def add_pod_target_file_accessors_paths
+      add_vendored_frameworks
+      add_vendored_libraries
+      add_resources
+      add_other_files
+    end
+
+    private
+
+    # Removes the source files of the Pods to the Pods project.
+    #
+    # @note   The source files are grouped by Pod and in turn by subspec
+    #         (recursively).
+    #
+    # @return [void]
+    #
+    def remove_source_files_references
+      Pod::UI.message '- Removing source files' do
+        extensions = Pod::Sandbox::FileAccessor::SOURCE_FILE_EXTENSIONS
+        source_files = file_accessors.flat_map { |file_accessor| file_accessor.send(:source_files) }
+        source_files.each do |f|
+          next unless extensions.include?(f.extname)
+
+          relative_path = f.relative_path_from(pod_dir)
+          full_source_path = @product_path.join(relative_path)
+          FileUtils.rm_rf(full_source_path)
+        end
+      end
+    end
+
+    # Adds the bundled frameworks to the Pods project
+    #
+    # @return [void]
+    #
+    def add_vendored_frameworks
+      Pod::UI.message '- Adding frameworks' do
+        add_file_accessors_paths_to_products_group(:vendored_frameworks)
+      end
+    end
+
+    # Adds the bundled libraries to the Pods project
+    #
+    # @return [void]
+    #
+    def add_vendored_libraries
+      Pod::UI.message '- Adding libraries' do
+        add_file_accessors_paths_to_products_group(:vendored_libraries)
+      end
+    end
+
+    # Adds the resources of the Pods to the Pods project.
+    #
+    # @note   The source files are grouped by Pod and in turn by subspec
+    #         (recursively) in the resources group.
+    #
+    # @return [void]
+    #
+    def add_resources
+      Pod::UI.message '- Adding resources' do
+        add_file_accessors_paths_to_products_group(:resources)
+        add_file_accessors_paths_to_products_group(:resource_bundle_files)
+      end
+    end
+
+    def add_other_files
+      Pod::UI.message '- Adding other files' do
+        add_file_accessors_paths_to_products_group(:license)
+        add_file_accessors_paths_to_products_group(:readme)
+      end
+    end
+
+    def add_file_accessors_paths_to_products_group(file_accessor_key)
+      fs = file_accessors.flat_map { |file_accessor| file_accessor.send(file_accessor_key) }.compact
+      fs.each do |f|
+        relative_path = f.relative_path_from(pod_dir)
+        full_source_path = product_path.join(relative_path)
+        next if full_source_path.exist?
+
+        full_source_dir = product_path.join(relative_path.parent)
+        FileUtils.mkdir_p(full_source_dir) unless full_source_dir.exist?
+        FileUtils.cp_r(%W[#{f}], full_source_dir)
+      end
+    end
+  end
+end

data/lib/cocoapods-project-gen/gen/project_builder.rb

@@ -0,0 +1,144 @@
+require 'cocoapods'
+
+module ProjectGen
+  class BuildManager
+    require 'cocoapods-project-gen/gen/build/xcode_build'
+    require 'cocoapods-project-gen/gen/product'
+    require 'cocoapods-project-gen/gen/build/headers_store'
+
+    attr_reader :root
+
+    def initialize(app_root, root = nil, no_clean: true, fail_fast: true)
+      @root = root.nil? ? app_root : root
+      @app_root = app_root
+      @no_clean = no_clean
+      @fail_fast = fail_fast
+    end
+
+    def product_dir
+      Pathname.new(root.parent).join('./project_gen_products').expand_path
+    end
+
+    def archives_dir
+      Pathname.new(root.parent).join('./project_gen_archives').expand_path
+    end
+
+    # Integrates the user projects associated with the {TargetDefinitions}
+    # with the Pods project and its products.
+    #
+    # @return [void]
+    #
+    def create_xcframework_products!(platforms, pod_targets, configuration = nil, build_library_for_distribution: false)
+      ts = pod_targets.values.flatten
+      Results.puts '-> Start Archiving...'.green
+      platform_archive_paths = Hash[platforms.map do |platform|
+        archive_paths = compute_archive_paths(platform, ts, configuration, build_library_for_distribution)
+        [platform.name, archive_paths]
+      end]
+      return if platform_archive_paths.values.flatten.empty?
+
+      output = Hash[pod_targets.map do |key, targets|
+        products = targets.map do |target|
+          Product.new(target, product_dir, root.parent, platform_archive_paths[target.platform.name])
+        end
+        ps = Products.new(key, products)
+        ps.create_bin_products
+        ps.add_pod_targets_file_accessors_paths
+        [key, ps.product_path]
+      end]
+      unless @no_clean
+        FileUtils.rm_rf(@app_root)
+        FileUtils.rm_rf(archives_dir)
+      end
+      output
+    end
+
+    private
+
+    def compute_archive_paths(platform, pod_targets, configuration, build_library_for_distribution)
+      sdks = Constants.sdks(platform.name)
+      archive_paths_by_platform(sdks, platform, pod_targets, configuration, build_library_for_distribution)
+    end
+
+    def archive_paths_by_platform(sdks, platform, pod_targets, configuration, build_library_for_distribution)
+      sdks.map do |sdk|
+        args = if build_library_for_distribution
+                 %w[BUILD_LIBRARY_FOR_DISTRIBUTION=YES]
+               else
+                 []
+               end
+        args += %W[-destination generic/platform=#{Constants::SDK_DESTINATION[sdk]}]
+        args += %W[-configuration #{configuration}] unless configuration.nil?
+        args += %W[-sdk #{sdk}]
+        pod_project_path = File.expand_path('./Pods/Pods.xcodeproj', @app_root)
+        archive_root = archives_dir.join(sdk.to_s)
+        archive_path = archive_root.join('Pods-App.xcarchive')
+        error = XcodeBuild.archive?(args, pod_project_path, "Pods-App-#{platform.string_name}", archive_path)
+        break if @fail_fast && error
+        next if error
+
+        print_pod_archive_infos(sdk, archive_path)
+        library_targets = pod_targets.select(&:build_as_library?)
+        library_targets.each do |target|
+          rename_library_product_name(target, archive_path)
+          archive_headers_path = archive_root.join(target.pod_name)
+          link_headers(target, archive_headers_path)
+        end
+        archive_path
+      end.compact
+    end
+
+    def rename_library_product_name(target, archive_path)
+      return unless target.build_as_library?
+
+      full_archive_path = archive_path.join('Products/usr/local/lib')
+      full_product_path = full_archive_path.join(target.static_library_name)
+      scope_suffix = target.scope_suffix
+      return unless full_product_path.exist? && scope_suffix && target.label.end_with?(scope_suffix)
+
+      label = Utils.remove_target_scope_suffix(target.label, scope_suffix)
+      new_full_archive_path = full_archive_path.join("lib#{label}.a")
+      File.rename(full_product_path, new_full_archive_path)
+    end
+
+    # Creates the link to the headers of the Pod in the sandbox.
+    #
+    # @return [void]
+    #
+    def link_headers(target, product_path)
+      Pod::UI.message '- Linking headers' do
+        # When integrating Pod as frameworks, built Pods are built into
+        # frameworks, whose headers are included inside the built
+        # framework. Those headers do not need to be linked from the
+        # sandbox.
+        next if target.build_as_framework? && target.should_build?
+
+        sandbox = Pod::Sandbox.new(product_path)
+        build_headers = ProjectGen::HeadersStore.new(sandbox, '', :public)
+        pod_target_header_mappings = target.header_mappings_by_file_accessor.values
+        public_header_mappings = target.public_header_mappings_by_file_accessor.values
+        headers = pod_target_header_mappings + public_header_mappings
+        headers.uniq.each do |header_mappings|
+          header_mappings.each do |namespaced_path, files|
+            hs = build_headers.add_files('', files)
+            build_headers.add_files(namespaced_path, hs, ln: true)
+          end
+        end
+        root_name = Pod::Specification.root_name(target.pod_name)
+        pod_dir = target.sandbox.sources_root.join(root_name)
+        module_headers = pod_dir.join(Constants::COPY_LIBRARY_SWIFT_HEADERS)
+        module_paths = build_headers.add_files(root_name, module_headers.children) if module_headers.exist?
+        module_paths
+      end
+    end
+
+    # Prints the list of specs & pod cache dirs for a single pod name.
+    #
+    # This output is valid YAML so it can be parsed with 3rd party tools
+    #
+    def print_pod_archive_infos(sdk, archive_path)
+      Results.puts("  - Archive: #{sdk}")
+      Results.puts("    path:    #{archive_path}")
+    end
+  end
+end

data/lib/cocoapods-project-gen/gen/project_gen.rb

@@ -1,10 +1,93 @@
-require 'cocoapods/validator'
-require 'cocoapods-project-gen/gen/swift_module_helper'
 require 'fileutils'
 
 module ProjectGen
-  class ProjectGenerator < Pod::Validator
+  autoload :PodDirCopyCleaner, 'cocoapods-project-gen/gen/pod/pod_copy_cleaner'
+
+  class ProjectGenerator
+    require 'cocoapods-project-gen/gen/pod/swift_module_helper'
+    require 'cocoapods-project-gen/gen/pod/project_gen_helper'
+
     include ProjectGen::SwiftModule
+    include ProjectGen::Helper
+    include Pod::Config::Mixin
+
+    # !@group results
+
+    attr_reader :results
+    #-------------------------------------------------------------------------#
+
+    #  @!group Configuration
+
+    # When multiple dependencies with different sources, use latest.
+    #
+    attr_accessor :use_latest
+
+    # @return [String] The SWIFT_VERSION that should be used to validate the pod. This is set by passing the
+    # `--swift-version` parameter during validation.
+    #
+    attr_accessor :swift_version
+    # @return [Boolean] whether the linter should not clean up temporary files
+    #         for inspection.
+    #
+    attr_accessor :no_clean
+
+    # @return [Boolean] whether the linter should fail as soon as the first build
+    #         variant causes an error. Helpful for i.e. multi-platforms specs,
+    #         specs with subspecs.
+    #
+    attr_accessor :fail_fast
+
+    # @return [Boolean] whether the validation should be performed against the root of
+    #         the podspec instead to its original source.
+    #
+    #
+    attr_accessor :local
+    alias local? local
+
+    # @return [Boolean] Whether the validator should fail on warnings, or only on errors.
+    #
+    attr_accessor :allow_warnings
+
+    # @return [String] name of the subspec to check, if nil all subspecs are checked.
+    #
+    attr_accessor :only_subspecs
+
+    # @return [Boolean] Whether frameworks should be used for the installation.
+    #
+    attr_accessor :use_frameworks
+
+    # @return [Boolean] Whether modular headers should be used for the installation.
+    #
+    attr_accessor :use_modular_headers
+
+    # @return [Boolean] Whether static frameworks should be used for the installation.
+    #
+    attr_accessor :use_static_frameworks
+
+    # @return [String] A glob for podspecs to be used during building of
+    #         the local Podfile via :path.
+    #
+    attr_accessor :include_podspecs
+
+    # @return [String] A glob for podspecs to be used during building of
+    #         the local Podfile via :podspec.
+    #
+    attr_accessor :external_podspecs
+
+    # !@group Helpers
+
+    # @return [Array<String>] an array of source URLs used to create the
+    #         {Podfile} used in the linting process
+    #
+    attr_reader :source_urls
+
+    # @return configuration
+    #
+    attr_accessor :configuration
+
+    #-------------------------------------------------------------------------#
+    # @return [Boolean]
+    #
 
     # Initialize a new instance
     #
@@ -26,168 +109,136 @@ module ProjectGen
     #
     # @param  [Boolean] Whether modular headers should be used for the installation.
     #
-    def self.new_from_local(podspecs, source_urls, platforms = [], product_type = :framework, configuration = :release, swift_version = nil, use_modular_headers: false)
-      generator = new(podspecs[0], source_urls, platforms)
-      generator.local = false
-      generator.no_subspecs    = true
-      generator.only_subspec   = nil
+    def self.new_from_local(podspecs = [], source_urls = [Pod::TrunkSource::TRUNK_REPO_URL], platforms = [], product_type = :framework, configuration = :release, swift_version = nil, use_modular_headers: false)
+      generator = new(source_urls, platforms)
+      generator.local = true
+      generator.no_subspecs = true
+      generator.only_subspecs = nil
       generator.no_clean       = false
       generator.allow_warnings = true
       generator.use_frameworks = product_type == :dynamic_framework
       generator.use_static_frameworks = product_type == :framework
-      generator.skip_import_validation = true
-      generator.external_podspecs = podspecs.drop(1)
+      generator.include_podspecs = podspecs
       generator.configuration = configuration
-      generator.skip_tests = true
       generator.use_modular_headers = use_modular_headers
-      generator.swift_version = swift_version unless swift_version.nil?
+      generator.swift_version = swift_version
       generator
     end
 
+    # Initialize a new instance
+    #
+    # @param  [Array<String>] source_urls
+    #         the Source URLs to use in creating a {Podfile}.
+    #
+    # @param  [Array<String>] platforms
+    #         the platforms to lint.
+    #
+    def initialize(source_urls, platforms = [])
+      @source_urls = source_urls.map { |url| config.sources_manager.source_with_name_or_url(url) }.map(&:url)
+      @platforms = platforms.map do |platform|
+        result =  case platform.to_s.downcase
+                  # Platform doesn't recognize 'macos' as being the same as 'osx' when initializing
+                  when 'macos' then Pod::Platform.macos
+                  else Pod::Platform.new(platform, nil)
+                  end
+        unless Constants.valid_platform?(result)
+          raise Informative, "Unrecognized platform `#{platform}`. Valid platforms: #{VALID_PLATFORMS.join(', ')}"
+        end
+
+        result
+      end
+      @allow_warnings = true
+      @use_frameworks = true
+      @use_latest = true
+    end
+
     # Create app project
-    # 
+    #
     # @param [String, Pathname] dir the temporary directory used by the Gen.
     #
-    # @param  [block<platform, pod_targets, valid>] &block the block to execute inside the lock.
-    #
-    def generate!(dir, &block)
-      dir = Pathname(dir)
-      @results = []
-      # Replace default spec with a subspec if asked for
-      a_spec = spec
-      if spec && @only_subspec
-        subspec_name = @only_subspec.start_with?(spec.root.name) ? @only_subspec : "#{spec.root.name}/#{@only_subspec}"
-        a_spec = spec.subspec_by_name(subspec_name, true, true)
-        @subspec_name = a_spec.name
+    # @param  [block<platforms, pod_targets, valid>] &block the block to execute inside the lock.
+    #
+    def generate!(work_dir, &block)
+      @project_gen_dir = Pathname(work_dir)
+      @results = Results.new
+      unless config.silent?
+        podspecs.each do |spec|
+          subspecs = determine_subspecs[spec]
+          if subspecs && !subspecs.empty?
+            subspecs.each { |s| Results.puts " -> #{s}\r\n" }
+          else
+            Results.puts " -> #{spec.name}\r\n"
+          end
+        end
       end
-      @validation_dir = dir
-      Pod::UI.print " -> #{a_spec ? a_spec.name : file.basename}\r" unless config.silent?
       $stdout.flush
-      send(:perform_linting) if respond_to?(:perform_linting)
-      install(a_spec, dir, &block) if a_spec && !quick
-      Pod::UI.puts ' -> '.send(result_color) << (a_spec ? a_spec.to_s : file.basename.to_s)
-      print_results
+      perform_linting
+      platforms, pod_targets, valid = install
+      @results.print_results
+      block.call(platforms, pod_targets, @clean, @fail_fast) if !block.nil? && valid
     end
 
-    def pod_targets
-      @installer.pod_targets
+    # @return [Pathname] the temporary directory used by the linter.
+    #
+    def project_gen_dir
+      @project_gen_dir ||= Pathname(Dir.mktmpdir(['cocoapods-project-gen-', "-#{spec.name}"]))
     end
 
     private
 
-    # Perform analysis for a given spec (or subspec)
-    #
-    def install(spec, dir, &block)
-      if spec.non_library_specification?
-        error('spec', "Validating a non library spec (`#{spec.name}`) is not supported.")
-        return false
-      end
-      platforms = send(:platforms_to_lint, spec)
-      valid = platforms.send(fail_fast ? :all? : :each) do |platform|
-        Pod::UI.message "\n\n#{spec} - Analyzing on #{platform} platform.".green.reversed
-        @consumer = spec.consumer(platform)
-        c_method = %i[setup_validation_environment create_app_project handle_local_pod
-                      check_file_patterns install_pod validate_swift_version
-                      add_app_project_import validate_vendored_dynamic_frameworks]
+    def install
+      podspec = podspecs.find(&:non_library_specification?)
+      if podspec
+        error('spec', "Validating a non library spec (`#{podspec.name}`) is not supported.")
+        [determine_platforms, specs_for_pods, false]
+      else
         begin
-          c_method.each { |m| send(m) }
+          setup_gen_environment
+          create_app_project
+          download_or_copy_pod
+          install_pod
+          validate_swift_version
+          add_app_project_import
+          validate_vendored_dynamic_frameworks
           valid = validated?
+          results.note('Project gen', 'finish!') if valid
+          [determine_platforms, specs_for_pods, valid]
+        rescue StandardError => e
+          message = e.to_s
+          message << "\n" << e.backtrace.join("\n") << "\n" if config.verbose?
+          error('unknown', "Encountered an unknown error (#{message}) during validation.")
+          [determine_platforms, specs_for_pods, false]
         end
-        block.call(platform, pod_targets, valid) unless block&.nil?
-        return false if fail_fast && !valid
-
-        generate_subspec(spec, dir, &block) unless @no_subspecs
-      rescue StandardError => e
-        message = e.to_s
-        raise Pod::Informative, "Encountered an unknown error\n\n#{message})\n\n#{e.backtrace * "\n"}"
-      end
-    end
-
-    def generate_subspec(spec, dir, &block)
-      spec.subspecs.reject(&:non_library_specification?).send(fail_fast ? :all? : :each) do |subspec|
-        @subspec_name = subspec.name
-        install(subspec, dir, &block)
       end
     end
 
-    def handle_local_pod
-      sandbox = Pod::Sandbox.new(@validation_dir + 'Pods')
-      test_spec_names = consumer.spec.test_specs.select do |ts|
-        ts.supported_on_platform?(consumer.platform_name)
-      end.map(&:name)
-      podfile = podfile_from_spec(consumer.platform_name, deployment_target, use_frameworks, test_spec_names,
-                                  use_modular_headers, use_static_frameworks)
-
+    def download_or_copy_pod
+      sandbox = Pod::Sandbox.new(@project_gen_dir + 'Pods')
+      podfile = podfile_from_spec(use_frameworks, use_modular_headers, use_static_frameworks)
       @installer = Pod::Installer.new(sandbox, podfile)
       @installer.use_default_plugins = false
-      @installer.has_dependencies = !spec.dependencies.empty?
-      %i[prepare resolve_dependencies download_dependencies clean_pod_sources write_lockfiles].each do |m|
+      @installer.has_dependencies = podspecs.any? { |podspec| !podspec.all_dependencies.empty? }
+      %i[prepare resolve_dependencies install_pod_sources run_podfile_pre_install_hooks clean_pod_sources
+         write_lockfiles].each do |m|
         case m
         when :clean_pod_sources
-          copy_and_clean(sandbox)
-          podspecs.each { |s| sandbox.development_pods.delete(s.name) }
+          ProjectGen::PodDirCopyCleaner.new(include_specifications).copy_and_clean(config.sandbox_root, sandbox)
+          include_specifications.each { |s| sandbox.development_pods.delete(s.name) }
           @installer.send(m)
         else
           @installer.send(m)
           next unless m == :resolve_dependencies
 
-          podspecs.each { |s| sandbox.store_local_path(s.name, s.defined_in_file, absolute?(s.defined_in_file)) }
+          # local --> source in local
+          # no-local --> source from cdn
+          # external_podspecs --> source in cdn
+          # include_podspecs  --> source in local
+          include_specifications.each do |spec|
+            sandbox.store_local_path(spec.name, spec.defined_in_file, Utils.absolute?(spec.defined_in_file))
+          end
         end
       end
-      library_targets = pod_targets.select { |target| target.build_as_library? }
-      add_swift_library_compatibility_header(library_targets)
-      @file_accessor = pod_targets.flat_map(&:file_accessors).find do |fa|
-        fa.spec.name == consumer.spec.name
-      end
-    end
-
-    def podspecs
-      ps = [file]
-      ps += external_podspecs.map { |pa| Pathname.new(pa) } if external_podspecs
-      ps += include_podspecs.map { |pa| Pathname.new(pa) } if include_podspecs
-      ps.uniq.map { |path| Pod::Specification.from_file(path) }
-    end
-
-    # @return [Bool]
-    #
-    def absolute?(path)
-      Pathname(path).absolute? || path.to_s.start_with?('~')
-    end
-
-    def group_subspecs_by_platform(spec)
-      specs_by_platform = {}
-      [spec, *spec.recursive_subspecs].each do |ss|
-        ss.available_platforms.each do |platform|
-          specs_by_platform[platform] ||= []
-          specs_by_platform[platform] << ss
-        end
-      end
-      specs_by_platform
-    end
-
-    def copy(source, destination, specs_by_platform)
-      path_list = Pod::Sandbox::PathList.new(source)
-      file_accessors = specs_by_platform.flat_map do |platform, specs|
-        specs.flat_map { |spec| Pod::Sandbox::FileAccessor.new(path_list, spec.consumer(platform)) }
-      end
-      used_files = Pod::Sandbox::FileAccessor.all_files(file_accessors)
-      used_files.each do |path|
-        path = Pathname(path)
-        n_path = destination.join(path.relative_path_from(source))
-        n_path.dirname.mkpath
-        FileUtils.cp_r(path, n_path.dirname)
-      end
-    end
-
-    def copy_and_clean(sandbox)
-      podspecs.each do |spec|
-        destination = config.sandbox_root + spec.name
-        source = sandbox.pod_dir(spec.name)
-        specs_by_platform = group_subspecs_by_platform(spec)
-        destination.parent.mkpath
-        FileUtils.rm_rf(destination)
-        copy(source, destination, specs_by_platform)
-      end
+      add_swift_library_compatibility_header(@installer.pod_targets)
     end
   end
 end