pod-builder-y 2.3.1

data/lib/pod_builder/podfile/pre_actions_swizzles.rb

@@ -0,0 +1,84 @@
+require 'xcodeproj'
+require 'pod_builder/core'
+require 'digest'
+
+class Pod::Generator::FileList
+  alias_method :swz_initialize, :initialize
+  
+  def initialize(paths)
+    paths.uniq!
+    swz_initialize(paths)
+  end
+end 
+
+class Pod::Generator::CopyXCFrameworksScript
+  alias_method :swz_initialize, :initialize
+  
+  def initialize(xcframeworks, sandbox_root, platform)
+    xcframeworks.uniq! { |t| t.path }
+    swz_initialize(xcframeworks, sandbox_root, platform)
+  end
+end 
+
+class Pod::Generator::EmbedFrameworksScript
+  alias_method :swz_initialize, :initialize
+  
+  def initialize(*args)
+    raise "Unsupported CocoaPods version" if (args.count == 0 || args.count > 2)
+    
+    frameworks_by_config = args[0]
+    frameworks_by_config.keys.each do |key|
+      items = frameworks_by_config[key]
+      items.uniq! { |t| t.source_path }
+      frameworks_by_config[key] = items
+    end
+
+    if args.count == 2
+      # CocoaPods 1.10.0 and newer
+      xcframeworks_by_config = args[1]
+      xcframeworks_by_config.keys.each do |key|
+        items = xcframeworks_by_config[key]
+        items.uniq! { |t| t.path }
+        xcframeworks_by_config[key] = items
+      end
+    end
+
+    swz_initialize(*args)
+  end
+end 
+
+class Pod::Generator::CopyResourcesScript
+  alias_method :swz_initialize, :initialize
+  
+  def initialize(resources_by_config, platform)
+    resources_by_config.keys.each do |key|
+      items = resources_by_config[key]
+      items.uniq!
+
+      colliding_resources = items.group_by { |t| File.basename(t) }.values.select { |t| t.count > 1 }
+
+      unless colliding_resources.empty?
+        message = ""
+        colliding_resources.each do |resources|
+          resources.map! { |t| File.expand_path(t.gsub("${PODS_ROOT}", "#{Dir.pwd}/Pods")) }
+          # check that files are identical. 
+          # For files with paths that are resolved (e.g containing ${PODS_ROOT}) we use the file hash
+          # we fallback to the filename for the others
+          hashes = resources.map { |t| File.exists?(t) ? Digest::MD5.hexdigest(File.read(t)) : File.basename(t) }
+          if hashes.uniq.count > 1
+            message += resources.join("\n") + "\n"
+          end
+        end
+
+        unless message.empty?
+          message = "\n\nThe following resources have the same name and will collide once copied into application bundle:\n" + message
+          raise message
+        end
+      end
+
+      resources_by_config[key] = items
+    end
+    
+    swz_initialize(resources_by_config, platform)
+  end
+end 

data/lib/pod_builder/podfile_cp.rb

@@ -0,0 +1,99 @@
+require 'cocoapods/podfile.rb'
+
+module Pod
+  class Podfile
+    class TargetDefinition
+      def pb_to_s(all_buildable_items, indent_level = 0, parent_pods = [])
+        indentation = "  " * indent_level
+        target_s = "#{indentation}target '#{self.name}' do\n"
+        
+        child_indentation = "  " * (indent_level + 1)
+
+        explicit_deps = self.dependencies.map { |t| all_buildable_items.detect { |u| u.name == t.name } }.compact
+        
+        pod_entries = []
+        prebuild_entries = []
+        self.dependencies.each do |dep|
+          if podfile_item = all_buildable_items.detect { |t| t.name == dep.name } 
+            is_prebuilt = all_buildable_items.select { |t| t.root_name == dep.root_name}.all?(&:is_prebuilt)
+            if File.exist?(podfile_item.prebuilt_podspec_path) && !is_prebuilt
+              prebuild_entries.push(podfile_item)
+            else
+              pod_entries.push(podfile_item)
+            end
+
+            non_explicit_dependencies = podfile_item.recursive_dependencies(all_buildable_items) - explicit_deps
+            non_explicit_dependencies_root_names = non_explicit_dependencies.map(&:root_name).uniq.filter { |t| t != podfile_item.root_name }
+            non_explicit_dependencies = non_explicit_dependencies_root_names.map { |x| 
+              if item = all_buildable_items.detect { |t| x == t.name }
+                item                    
+              else
+                item = all_buildable_items.detect { |t| x == t.root_name }
+              end
+            }.compact
+            
+            non_explicit_dependencies.each do |dep|
+              dep_item = all_buildable_items.detect { |x| x.name == dep.name }
+
+              is_prebuilt = all_buildable_items.select { |t| t.root_name == dep.root_name}.all?(&:is_prebuilt)
+              if File.exist?(dep_item.prebuilt_podspec_path) && !is_prebuilt
+                prebuild_entries.push(dep_item)
+              else
+                pod_entries.push(dep_item)
+              end
+
+              explicit_deps.push(dep)
+            end       
+          end
+        end
+
+        prebuild_entries = prebuild_entries.uniq.sort_by { |t| t.name }
+        pod_entries = pod_entries.uniq.sort_by { |t| t.name }
+        
+        # Don't include inherited pods
+        prebuild_entries.reject! { |t| parent_pods.include?(t) }
+        pod_entries.reject! { |t| parent_pods.include?(t) }
+
+        prebuild_entries.each do |pod|
+          target_s += "#{child_indentation}#{pod.prebuilt_entry(false, false)}\n"
+        end
+        pod_entries.each do |pod|
+          target_s += "#{child_indentation}#{pod.entry(true, false)}\n"
+        end
+
+        if self.children.count > 0
+          target_s += "\n"
+          target_s += @children.map { |t| t.pb_to_s(all_buildable_items, indent_level + 1, parent_pods + pod_entries + prebuild_entries) }.join("\n\n")
+        end
+
+        target_s += "#{indentation}end\n"
+      end
+    end
+  end
+end
+
+module Pod
+  class Podfile
+    def pb_to_s(all_buildable_items)
+      initial_targets = root_target_definitions.first.children
+      
+      platform = @current_target_definition.platform
+      
+      podfile_s = "platform :#{platform.to_sym}, '#{platform.deployment_target.to_s}'\n\n"
+      podfile_s += initial_targets.map { |t| t.pb_to_s(all_buildable_items) }.join("\n\n")
+
+      return podfile_s
+    end
+  end
+end
+
+class PodfileCP
+  def self.podfile_path_transform(path)
+    prebuilt_prefix = PodBuilder::prebuiltpath.gsub(PodBuilder::project_path, "")[1..] + "/"
+    if path.start_with?(prebuilt_prefix)
+      return path
+    else
+      return PodBuilder::Podfile.podfile_path_transform(path)
+    end
+  end
+end

data/lib/pod_builder/podfile_item.rb

@@ -0,0 +1,530 @@
+# This class is the model that PodBuilder uses for every pod spec. The model is instantiated
+# from Pod::Specification
+
+module PodBuilder
+  class PodfileItem
+    # @return [String] The git repo
+    #
+    attr_reader :repo
+
+    # @return [String] The git branch
+    #
+    attr_reader :branch
+
+    # @return [String] A checksum for the spec
+    #
+    attr_reader :checksum
+
+    # @return [String] Matches @name unless for subspecs were it stores the name of the root pod
+    #
+    attr_reader :root_name
+
+    # @return [String] The name of the pod, which might be the subspec name if appicable
+    #
+    attr_reader :name
+    
+    # @return [String] The pinned tag of the pod, if any
+    #
+    attr_reader :tag
+
+    # @return [String] The pinned version of the pod, if any
+    #
+    attr_reader :version
+
+    # @return Array<[String]> The available versions of the pod
+    #
+    attr_reader :available_versions
+
+    # @return [String] Local path, if any
+    #
+    attr_accessor :path
+
+    # @return [String] Local podspec path, if any
+    #
+    attr_accessor :podspec_path
+
+    # @return [String] The pinned commit of the pod, if any
+    #
+    attr_reader :commit
+    
+    # @return [String] The module name
+    #
+    attr_reader :module_name
+    
+    # @return [String] The swift version if applicable
+    #
+    attr_reader :swift_version
+    
+    # @return [Array<String>] The pod's dependency names, if any. Use dependencies() to get the [Array<PodfileItem>]
+    #
+    attr_reader :dependency_names
+
+    # @return [Array<String>] The pod's external dependency names (excluding subspecs), if any
+    #
+    attr_reader :external_dependency_names
+    
+    # @return [Bool] True if the pod is shipped as a static binary
+    #
+    attr_reader :is_static
+    
+    # @return [Array<Hash>] The pod's xcconfig configuration
+    #
+    attr_reader :xcconfig
+
+    # @return [Bool] Is external pod
+    #
+    attr_accessor :is_external
+
+    # @return [String] Header directory name
+    #
+    attr_accessor :header_dir
+
+    # @return [String] The pod's build configuration
+    #
+    attr_accessor :build_configuration
+
+    # @return [String] The pod's vendored frameworks
+    #
+    attr_accessor :vendored_frameworks
+
+    # @return [String] The pod's vendored libraries
+    #
+    attr_accessor :vendored_libraries
+
+    # @return [String] Framweworks the pod needs to link to
+    #
+    attr_accessor :frameworks
+
+    # @return [String] Weak framweworks the pod needs to link to
+    #
+    attr_accessor :weak_frameworks
+
+    # @return [String] Libraries the pod needs to link to
+    #
+    attr_accessor :libraries
+
+    # @return [String] source_files
+    #
+    attr_accessor :source_files
+
+    # @return [String] license
+    #
+    attr_accessor :license
+
+    # @return [String] summary
+    #
+    attr_accessor :summary
+
+    # @return [Hash] source
+    #
+    attr_accessor :source
+
+    # @return [Hash] authors
+    #
+    attr_accessor :authors
+
+    # @return [String] homepage
+    #
+    attr_accessor :homepage
+
+    # @return [Array<String>] Default subspecs
+    #
+    attr_accessor :default_subspecs
+
+    # @return [Bool] Defines module
+    #
+    attr_accessor :defines_module
+    
+    # Initialize a new instance
+    #
+    # @param [Specification] spec
+    #
+    # @param [Hash] checkout_options
+    #
+    def initialize(spec, all_specs, checkout_options, supported_platforms)
+      @name = spec.name
+      @root_name = spec.name.split("/").first
+
+      @checksum = spec.checksum
+
+      checkout_options_keys = [@root_name, @name]
+
+      if opts_key = checkout_options_keys.detect { |x| checkout_options.has_key?(x) }
+        @repo = checkout_options[opts_key][:git]
+        @tag = checkout_options[opts_key][:tag]
+        @commit = checkout_options[opts_key][:commit]
+        @path = checkout_options[opts_key][:path]
+        @podspec_path = checkout_options[opts_key][:podspec]        
+        @branch = checkout_options[opts_key][:branch]
+        @is_external = true
+      else
+        @repo = spec.root.source[:git]
+        @tag = spec.root.source[:tag]
+        @commit = spec.root.source[:commit]
+        @is_external = false
+      end    
+
+      @defines_module = nil # nil is not specified
+      if override = spec.attributes_hash.dig("pod_target_xcconfig", "DEFINES_MODULE")
+        @defines_module = (override == "YES")
+      end
+      
+      @vendored_frameworks = extract_vendored_frameworks(spec, all_specs)
+      @vendored_libraries = extract_vendored_libraries(spec, all_specs)
+
+      @frameworks = []
+      @weak_frameworks = []
+      @libraries = []
+
+      @frameworks += extract_array(spec, "framework")
+      @frameworks += extract_array(spec, "frameworks")
+      
+      @weak_frameworks += extract_array(spec, "weak_framework")
+      @weak_frameworks += extract_array(spec, "weak_frameworks")  
+
+      @libraries += extract_array(spec, "library")
+      @libraries += extract_array(spec, "libraries")  
+
+      @header_dir = spec.attributes_hash["header_dir"]
+
+      @version = spec.root.version.version
+      @available_versions = spec.respond_to?(:spec_source) ? spec.spec_source.versions(@root_name)&.map(&:to_s) : [@version]
+      
+      @swift_version = spec.root.swift_version&.to_s
+      @module_name = spec.root.module_name
+
+      @default_subspecs = extract_array(spec, "default_subspecs")
+      if default_subspec = spec.attributes_hash["default_subspec"]
+        @default_subspecs.push(default_subspec)        
+      end
+
+      if @name == @root_name && @default_subspecs.empty?
+        @default_subspecs += all_specs.select { |t| t.name.include?("/") && t.name.split("/").first == @root_name }.map { |t| t.name.split("/").last }
+      end
+
+      @dependency_names = spec.attributes_hash.fetch("dependencies", {}).keys + default_subspecs.map { |t| "#{@root_name}/#{t}" } 
+      supported_platforms.each do |platform|        
+        @dependency_names += (spec.attributes_hash.dig(platform, "dependencies") || {}).keys
+      end
+      @dependency_names.uniq!
+
+      @external_dependency_names = @dependency_names.select { |t| !t.start_with?(root_name)  }
+
+      @is_static = spec.root.attributes_hash["static_framework"] || false
+      @xcconfig = spec.root.attributes_hash["xcconfig"] || {}
+
+      if spec.attributes_hash.has_key?("script_phases")
+        Configuration.skip_pods += [name, root_name]
+        Configuration.skip_pods.uniq!
+        puts "Will skip '#{root_name}' which defines script_phase in podspec".blue
+      end
+
+      default_subspecs_specs ||= begin
+        subspecs = all_specs.select { |t| t.name.split("/").first == @root_name }
+        subspecs.select { |t| @default_subspecs.include?(t.name.split("/").last) }
+      end
+      root_spec = all_specs.detect { |t| t.name == @root_name } || spec
+      @source_files = source_files_from([spec, root_spec] + default_subspecs_specs)
+      
+      @build_configuration = spec.root.attributes_hash.dig("pod_target_xcconfig", "prebuild_configuration") || "release"
+      @build_configuration.downcase!
+
+      default_license = "MIT"
+      @license = spec.root.attributes_hash.fetch("license", {"type"=>"#{default_license}"})["type"] || default_license
+      @summary = spec.root.attributes_hash.fetch("summary", "A summary for #{@name}")
+      @source = spec.root.attributes_hash.fetch("source", { "git"=>"https://github.com/Subito-it/PodBuilder.git" })
+      @authors = spec.root.attributes_hash.fetch("authors", {"PodBuilder"=>"pod@podbuilder.com"})
+      @homepage = spec.root.attributes_hash.fetch("homepage", "https://github.com/Subito-it/PodBuilder")
+    end
+
+    def pod_specification(all_poditems, parent_spec = nil)
+      spec_raw = {}
+
+      spec_raw["name"] = @name
+      spec_raw["module_name"] = @module_name
+
+      spec_raw["source"] = {}
+      if repo = @repo
+        spec_raw["source"]["git"] = repo
+      end
+      if tag = @tag
+        spec_raw["source"]["tag"] = tag
+      end
+      if commit = @commit
+        spec_raw["source"]["commit"] = commit
+      end
+
+      spec_raw["version"] = @version
+      if swift_version = @swift_version
+        spec_raw["swift_version"] = swift_version
+      end
+
+      spec_raw["static_framework"] = is_static
+
+      spec_raw["frameworks"] = @frameworks
+      spec_raw["libraries"] = @libraries
+
+      spec_raw["xcconfig"] = @xcconfig
+
+      spec_raw["dependencies"] = @dependency_names.map { |x| [x, []] }.to_h
+
+      spec = Pod::Specification.from_hash(spec_raw, parent_spec)   
+      all_subspec_items = all_poditems.select { |x| x.is_subspec && x.root_name == @name }
+      spec.subspecs = all_subspec_items.map { |x| x.pod_specification(all_poditems, spec) }
+
+      return spec
+    end
+    
+    def inspect
+      return "#{@name} repo=#{@repo} pinned=#{@tag || @commit} is_static=#{@is_static} deps=#{@dependencies || "[]"}"
+    end
+
+    def to_s
+      return @name
+    end
+
+    def dependencies(available_pods)
+      return available_pods.select { |x| @dependency_names.include?(x.name) }
+    end
+
+    def recursive_dependencies(available_pods)
+      names = [name]
+
+      deps = []
+      last_count = -1 
+      while deps.count != last_count do
+        last_count = deps.count
+
+        updated_names = []
+        names.each do |name|
+          if pod = available_pods.detect { |t| t.name == name }
+            deps.push(pod)
+            updated_names += pod.dependency_names
+          end
+        end
+        
+        names = updated_names.uniq
+
+        deps.uniq!  
+      end
+
+      root_names = deps.map(&:root_name).uniq
+
+      # We need to build all other common subspecs to properly build the item
+      # Ex. 
+      # PodA depends on DepA/subspec1
+      # PodB depends on DepA/subspec2
+      #
+      # When building PodA we need to build both DepA subspecs because they might 
+      # contain different code
+      deps += available_pods.select { |t| root_names.include?(t.root_name) && t.root_name != t.name }
+
+      deps.uniq!
+
+      return deps
+    end
+
+    # @return [Bool] True if it's a pod that doesn't provide source code (is already shipped as a prebuilt pod)
+    #    
+    def is_prebuilt
+      if Configuration.force_prebuild_pods.include?(@root_name) || Configuration.force_prebuild_pods.include?(@name)
+        return false
+      end
+
+      # We treat pods to skip like prebuilt ones
+      if Configuration.skip_pods.include?(@root_name) || Configuration.skip_pods.include?(@name)
+        return true
+      end
+
+      # Podspecs aren't always properly written (source_file key is often used instead of header_files)
+      # Therefore it can become tricky to understand which pods are already precompiled by boxing a .framework or .a
+      embedded_as_vendored = vendored_frameworks.map { |x| File.basename(x) }.include?("#{module_name}.framework")
+      embedded_as_static_lib = vendored_libraries.map { |x| File.basename(x) }.include?("lib#{module_name}.a")
+      
+      only_headers = (source_files.count > 0 && @source_files.all? { |x| x.end_with?(".h") })
+      no_sources = (@source_files.count == 0 || only_headers) && (@vendored_frameworks + @vendored_libraries).count > 0
+
+      if !no_sources && !only_headers
+        return false
+      else
+        return (no_sources || only_headers || embedded_as_static_lib || embedded_as_vendored)
+      end
+    end
+
+    # @return [Bool] True if it's a subspec
+    #
+    def is_subspec
+      @root_name != @name
+    end
+
+    # @return [Bool] True if it's a development pod
+    #
+    def is_development_pod
+      @path != nil
+    end
+
+    # @return [String] The podfile entry
+    #
+    def entry(include_version = true, include_pb_entry = true)
+      e = "pod '#{@name}'"
+
+      unless include_version
+        return e
+      end
+
+      if is_external
+        if @path
+          e += ", :path => '#{@path}'"  
+        elsif @podspec_path
+          e += ", :podspec => '#{@podspec_path}'"  
+        else
+          if @repo
+            e += ", :git => '#{@repo}'"  
+          end
+          if @tag
+            e += ", :tag => '#{@tag}'"
+          end
+          if @commit
+            e += ", :commit => '#{@commit}'"  
+          end
+          if @branch
+            e += ", :branch => '#{@branch}'"  
+          end
+        end
+      else
+        e += ", '=#{@version}'"  
+      end
+
+      if include_pb_entry && !is_prebuilt
+        prebuilt_info_path = PodBuilder::prebuiltpath("#{root_name}/#{Configuration::prebuilt_info_filename}")
+        if File.exist?(prebuilt_info_path)
+          data = JSON.parse(File.read(prebuilt_info_path))
+          swift_version = data["swift_version"]
+          is_static = data["is_static"] || false
+        
+          e += "#{prebuilt_marker()} is<#{is_static}>"
+          if swift_version
+            e += " sv<#{swift_version}>"
+          end
+        else
+          e += prebuilt_marker()
+        end
+      end
+
+      return e
+    end
+
+    def podspec_name
+      return name.gsub("/", "_")
+    end
+
+    def prebuilt_rel_path
+      return "#{module_name}.framework"
+    end
+
+    def prebuilt_podspec_path(absolute_path = true)
+      podspec_path = PodBuilder::prebuiltpath("#{@root_name}/#{@root_name}.podspec")
+      if absolute_path 
+        return podspec_path
+      else
+        pod_path = Pathname.new(podspec_path).relative_path_from(Pathname.new(PodBuilder::basepath)).to_s
+      end
+    end
+
+    def prebuilt_entry(include_pb_entry = true, absolute_path = false)
+      podspec_dirname = File.dirname(prebuilt_podspec_path(absolute_path = absolute_path))
+
+      entry = "pod '#{name}', :path => '#{podspec_dirname}'"
+
+      if include_pb_entry && !is_prebuilt
+        entry += prebuilt_marker()
+      end
+
+      return entry
+    end
+
+    def prebuilt_marker
+      return " # pb<#{name}>"
+    end
+
+    def has_subspec(named)
+      unless !is_subspec
+        return false
+      end
+
+      return named.split("/").first == name
+    end
+
+    def has_common_spec(named)
+      return root_name == named.split("/").first
+    end
+
+    private
+
+    def extract_vendored_frameworks(spec, all_specs)
+      items = []
+
+      supported_platforms = spec.available_platforms.flatten.map(&:name).map(&:to_s)
+      items += [spec.attributes_hash["vendored_frameworks"]]
+      items += [spec.attributes_hash["vendored_framework"]]
+
+      items += supported_platforms.map { |x| spec.attributes_hash.fetch(x, {})["vendored_frameworks"] }
+      items += supported_platforms.map { |x| spec.attributes_hash.fetch(x, {})["vendored_framework"] }
+
+      return items.flatten.uniq.compact
+    end
+
+    def extract_vendored_libraries(spec, all_specs)
+      items = []
+
+      supported_platforms = spec.available_platforms.flatten.map(&:name).map(&:to_s)
+
+      items += [spec.attributes_hash["vendored_libraries"]]
+      items += [spec.attributes_hash["vendored_library"]]  
+
+      items += supported_platforms.map { |x| spec.attributes_hash.fetch(x, {})["vendored_libraries"] }
+      items += supported_platforms.map { |x| spec.attributes_hash.fetch(x, {})["vendored_library"] }  
+
+      return items.flatten.uniq.compact
+    end
+
+    def extract_array(spec, key)
+      element = spec.attributes_hash.fetch(key, [])
+      if element.instance_of? String
+        element = [element]
+      end
+
+      return element
+    end
+
+    def source_files_from_string(source)
+      # Transform source file entries 
+      # "Networking{Response,Request}*.{h,m}" -> ["NetworkingResponse*.h", "NetworkingResponse*.m", "NetworkingRequest*.h", "NetworkingRequest*.m"]
+      files = []
+      if source.is_a? String 
+        matches = source.match(/(.*){(.*)}(.*)/)
+        if matches&.size == 4
+          res = matches[2].split(",").map { |t| "#{matches[1]}#{t}#{matches[3]}" }
+          if res.any? { |t| t.include?("{") }
+            return res.map { |t| source_files_from_string(t) }.flatten
+          end
+  
+          return res
+        end
+
+        return source.split(",")
+      else
+        if source.any? { |t| t.include?("{") }
+          return source.map { |t| source_files_from_string(t) }.flatten
+        end
+
+        return source
+      end
+    end
+
+    def source_files_from(specs)
+      files = specs.map { |t| t.attributes_hash.fetch("source_files", []) }.flatten
+      return source_files_from_string(files).uniq
+    end
+  end
+end