pod-builder 1.9.3 → 2.0.0.beta.22

data/lib/pod_builder/podspec.rb

@@ -1,38 +1,8 @@
+# This file contains the logic that generates the .podspec files that are placed
+# along to the prebuild frameworks under PodBuilder/Prebuilt
+
 module PodBuilder
   class Podspec
-    class PodspecItem
-      attr_accessor :name
-      attr_accessor :module_name
-      attr_accessor :vendored_frameworks
-      attr_accessor :vendored_items
-      attr_accessor :frameworks
-      attr_accessor :weak_frameworks
-      attr_accessor :libraries
-      attr_accessor :resources
-      attr_accessor :exclude_files
-      attr_accessor :xcconfig
-      attr_accessor :dependencies
-      
-      def initialize
-        @name = ""
-        @module_name = ""
-        @vendored_frameworks = []
-        @vendored_items = []
-        @frameworks = []
-        @weak_frameworks = []
-        @libraries = []
-        @resources = []
-        @exclude_files = []
-        @xcconfig = {}
-        @dependencies = []
-      end
-      
-      def to_s
-        @name
-      end
-    end
-    private_constant :PodspecItem
-    
     def self.generate(all_buildable_items, analyzer)  
       unless all_buildable_items.count > 0
         return
@@ -40,142 +10,181 @@ module PodBuilder
       
       puts "Generating PodBuilder's local podspec".yellow
                   
-      podspec_items = podspec_items_from(all_buildable_items)
-
       platform = analyzer.instance_variable_get("@result").targets.first.platform
-      generate_podspec_from(podspec_items, platform)
-    end
-
-    def self.include?(pod_name)
-      podspec_path = PodBuilder::basepath("PodBuilder.podspec")
-      unless File.exist?(podspec_path)
-        return false
-      end
-
-      if Configuration.subspecs_to_split.include?(pod_name)
-        pod_name = pod_name.gsub("/", "_")
-      else
-        pod_name = pod_name.split("/").first
-      end
-
-      podspec_content = File.read(podspec_path)
-
-      # (_.*) will include prebuild podnames like s.subspec 'Podname_Subspec' do |p|
-      subspec_regex = "s.subspec '#{pod_name}(_.*)?' do |p|" 
-      return (podspec_content.match(/#{subspec_regex}/) != nil)
+      generate_podspec_from(all_buildable_items, platform)
     end
     
     private
 
-    def self.generate_podspec_from(podspec_items, platform)
-      podspecs = []
-      podspec_items.each do |item|
-        vendored_frameworks = item.vendored_frameworks.map { |x| x.vendored_framework_path }.compact
-        vendored_frameworks += item.vendored_items.map { |x| File.basename(x) }.select { |x| File.exist?(PodBuilder::basepath(PodfileItem::vendored_name_framework_path(x))) }.map { |x| "Rome/#{x}" }
-        vendored_frameworks.uniq!
-        vendored_libraries = Dir.glob(PodBuilder::basepath("Rome/#{item.module_name}/**/*.a")).map { |x| x.to_s.gsub(PodBuilder::basepath, "")[1..-1] }
+    def self.generate_spec_keys_for(item, name, all_buildable_items)
+      podspec = ""
+      valid = false
 
-        non_prebuilt_dependencies = item.dependencies.select { |x| x.vendored_framework_path.nil? }
-        
-        podspec = "  s.subspec '#{item.name.gsub("/", "_")}' do |p|\n"
+      slash_count = name.count("/") + 1
+      indentation = "    " * slash_count
+      spec_var = "p#{slash_count}"
 
+      if item.name == name
+        if_exists = lambda { |t| File.exist?(PodBuilder::prebuiltpath("#{item.root_name}/#{t}") || "") }
+
+        vendored_frameworks = item.vendored_frameworks + ["#{item.module_name}.framework"]
+        existing_vendored_frameworks = vendored_frameworks.select(&if_exists)
+        existing_vendored_frameworks_basename = vendored_frameworks.map { |t| File.basename(t) }.select(&if_exists)
+        vendored_frameworks = (existing_vendored_frameworks + existing_vendored_frameworks_basename).uniq
+        
+        vendored_libraries = item.vendored_libraries
+        existing_vendored_libraries = vendored_libraries.map { |t| "#{item.module_name}/#{t}" }.select(&if_exists)
+        existing_vendored_libraries_basename = vendored_libraries.map { |t| File.basename(t) }.select(&if_exists)
+        vendored_libraries = (existing_vendored_libraries + existing_vendored_libraries_basename).uniq        
+  
+        # .a are static libraries and should not be included again in the podspec to prevent duplicated symbols (in the app and in the prebuilt framework)
+        vendored_libraries.reject! { |t| t.end_with?(".a") }
+  
+        frameworks = all_buildable_items.select { |t| vendored_frameworks.include?("#{t.module_name}.framework") }.uniq
+        static_frameworks = frameworks.select { |x| x.is_static }
+  
+        resources = static_frameworks.map { |x| x.vendored_framework_path.nil? ? nil : "#{x.vendored_framework_path}/*.{nib,bundle,xcasset,strings,png,jpg,tif,tiff,otf,ttf,ttc,plist,json,caf,wav,p12,momd}" }.compact.flatten.uniq
+        exclude_files = static_frameworks.map { |x| x.vendored_framework_path.nil? ? nil : "#{x.vendored_framework_path}/Info.plist" }.compact.flatten.uniq
+          
         if vendored_frameworks.count > 0
-          podspec += "    p.vendored_frameworks = '#{vendored_frameworks.join("','")}'\n"
-        end
+          podspec += "#{indentation}#{spec_var}.vendored_frameworks = '#{vendored_frameworks.uniq.sort.join("','")}'\n"
+        end      
         if vendored_libraries.count > 0
-          podspec += "    p.vendored_libraries = '#{vendored_libraries.join("','")}'\n"
+          podspec += "#{indentation}#{spec_var}.vendored_libraries = '#{vendored_libraries.uniq.sort.join("','")}'\n"
         end
         if item.frameworks.count > 0
-          podspec += "    p.frameworks = '#{item.frameworks.join("', '")}'\n"
+          podspec += "#{indentation}#{spec_var}.frameworks = '#{item.frameworks.uniq.sort.join("', '")}'\n"
         end
         if item.libraries.count > 0
-          podspec += "    p.libraries = '#{item.libraries.join("', '")}'\n"
+          podspec += "#{indentation}#{spec_var}.libraries = '#{item.libraries.uniq.sort.join("', '")}'\n"
         end
-        if item.resources.count > 0
-          podspec += "    p.resources = '#{item.resources.join("', '")}'\n"
+        if resources.count > 0
+          podspec += "#{indentation}#{spec_var}.resources = '#{resources.uniq.sort.join("', '")}'\n"
         end
-        if item.resources.count > 0
-          podspec += "    p.exclude_files = '#{item.exclude_files.join("', '")}'\n"
+        if exclude_files.count > 0
+          podspec += "#{indentation}#{spec_var}.exclude_files = '#{exclude_files.uniq.sort.join("', '")}'\n"
         end
         if item.xcconfig.keys.count > 0
-          podspec += "    p.xcconfig = #{item.xcconfig.to_s}\n"
+          xcconfig = Hash.new
+          item.xcconfig.each do |k, v|
+            unless v != "$(inherited)"
+              xcconfig[k] = item.xcconfig[k]
+              next
+            end
+            unless k == "OTHER_LDFLAGS"
+              next # For the time being limit to OTHER_LDFLAGS key
+            end
+  
+            if podspec_values = item.xcconfig[k]
+              podspec_values_arr = podspec_values.split(" ")
+              podspec_values_arr.push(v)
+              v = podspec_values_arr.join(" ")          
+            end
+            
+            xcconfig[k] = item.xcconfig[k]
+          end
+  
+          if xcconfig.keys.count > 0 
+            podspec += "#{indentation}#{spec_var}.xcconfig = #{xcconfig.to_s}\n"
+          end
+        end
+  
+        deps = item.dependency_names.sort
+        if name == item.root_name
+          deps.reject! { |t| t.split("/").first == item.root_name }
         end
-        non_prebuilt_dependencies.each do |non_prebuilt_dependency|
-          podspec += "    p.dependency '#{non_prebuilt_dependency.name}'\n"
+  
+        if deps.count > 0
+          if podspec.count("\n") > 1
+            podspec += "\n"
+          end
+          deps.each do |dependency|
+            podspec += "#{indentation}#{spec_var}.dependency '#{dependency}'\n"
+          end
         end
 
-        podspec += "  end"
-        
-        podspecs.push(podspec)
+        valid = valid || vendored_frameworks.count > 0
       end
       
-      cwd = File.dirname(File.expand_path(__FILE__))
-      podspec_file = File.read("#{cwd}/templates/build_podspec.template")
-      podspec_file.gsub!("%%%podspecs%%%", podspecs.join("\n\n"))
-            
-      podspec_file.sub!("%%%platform_name%%%", platform.name.to_s)
-      podspec_file.sub!("%%%deployment_version%%%", platform.deployment_target.version)
-      
-      File.write(PodBuilder::basepath("PodBuilder.podspec"), podspec_file)
+      subspec_names = all_buildable_items.map(&:name).select { |t| t.start_with?("#{name}/") }
+      subspec_names_groups = subspec_names.group_by { |t| name + "/" + t.gsub("#{name}/", '').split("/").first }
+      subspec_names = subspec_names_groups.keys.uniq.sort
+
+      subspec_names.each do |subspec|
+        subspec_item = all_buildable_items.detect { |t| t.name == subspec } || item
+
+        if podspec.length > 0
+          podspec += "\n"
+        end
+          
+        subspec_keys, subspec_valid = generate_spec_keys_for(subspec_item, subspec, all_buildable_items) 
+        valid = valid || subspec_valid
+
+        if subspec_keys.length > 0
+          podspec += "#{indentation}#{spec_var}.subspec '#{subspec.split("/").last}' do |p#{slash_count + 1}|\n"
+          podspec += subspec_keys
+          podspec += "#{indentation}end\n"
+        end
+      end
+    
+      return podspec, valid
     end
 
-    def self.podspec_items_from(buildable_items)
-      podspec_items = []
+    def self.generate_podspec_from(all_buildable_items, platform)
+      prebuilt_podspec_path = all_buildable_items.map(&:prebuilt_podspec_path)
+      prebuilt_podspec_path.each do |path|
+        if File.exist?(path)
+          FileUtils.rm(path)
+        end
+      end
 
-      buildable_items.each do |pod|
-        spec_exists = File.exist?(PodBuilder::basepath(pod.vendored_spec_framework_path))
-        subspec_exists = File.exist?(PodBuilder::basepath(pod.vendored_subspec_framework_path))
-        
-        unless spec_exists || subspec_exists
-          puts "Skipping `#{pod.name}`, not prebuilt".blue
+      all_buildable_items.each do |item|  
+        if item.is_prebuilt
           next
         end
-        
-        pod_name = Configuration.subspecs_to_split.include?(pod.name) ? pod.name : pod.root_name
-        unless podspec_item = podspec_items.detect { |x| x.name == pod_name }
-          podspec_item = PodspecItem.new
-          podspec_items.push(podspec_item)
-          podspec_item.name = pod_name
-          podspec_item.module_name = pod.module_name
-          podspec_item.vendored_items = pod.vendored_items
+        if item.name != item.root_name
+          if all_buildable_items.map(&:name).include?(item.root_name)
+            next # will process root spec, skip subspecs
+          end
+        end
+        if File.exist?(item.prebuilt_podspec_path)
+          next # skip if podspec was already generated
         end
-        
-        podspec_item.vendored_frameworks += [pod] + pod.dependencies(buildable_items)
-        
-        podspec_item.frameworks = podspec_item.vendored_frameworks.map { |x| x.frameworks }.flatten.uniq.sort
-        podspec_item.weak_frameworks = podspec_item.vendored_frameworks.map { |x| x.weak_frameworks }.flatten.uniq.sort
-        podspec_item.libraries = podspec_item.vendored_frameworks.map { |x| x.libraries }.flatten.uniq.sort
-        
-        static_vendored_frameworks = podspec_item.vendored_frameworks.select { |x| x.is_static }
 
-        podspec_item.resources = static_vendored_frameworks.map { |x| x.vendored_framework_path.nil? ? nil : "#{x.vendored_framework_path}/*.{nib,bundle,xcasset,strings,png,jpg,tif,tiff,otf,ttf,ttc,plist,json,caf,wav,p12,momd}" }.compact.flatten.uniq
-        podspec_item.exclude_files = static_vendored_frameworks.map { |x| x.vendored_framework_path.nil? ? nil : "#{x.vendored_framework_path}/Info.plist" }.compact.flatten.uniq
-        podspec_item.exclude_files += podspec_item.vendored_frameworks.map { |x| x.vendored_framework_path.nil? ? nil : "#{x.vendored_framework_path}/#{Configuration.framework_plist_filename}" }.compact.flatten.uniq.sort
+        podspec = "Pod::Spec.new do |p1|\n"
 
-        # Merge xcconfigs
-        if !pod.xcconfig.empty?
-          pod.xcconfig.each do |k, v|
-            unless v != "$(inherited)"
-              next
-            end
-            unless k == "OTHER_LDFLAGS"
-              next # For the time being limit to OTHER_LDFLAGS key
-            end
+        podspec += "    p1.name             = '#{item.root_name}'\n"
+        podspec += "    p1.version          = '#{item.version}'\n"
+        podspec += "    p1.summary          = '#{item.summary.gsub("'", "\\'")}'\n"
+        podspec += "    p1.homepage         = '#{item.homepage}'\n"
+        podspec += "    p1.author           = 'PodBuilder'\n"
+        podspec += "    p1.source           = { 'git' => '#{item.source['git']}'}\n"
+        podspec += "    p1.license          = { :type => '#{item.license}' }\n"
 
-            if podspec_values = podspec_item.xcconfig[k]
-              podspec_values_arr = podspec_values.split(" ")
-              podspec_values_arr.push(v)
-              v = podspec_values_arr.join(" ")          
-            end
-            
-            podspec_item.xcconfig[k] = v
-          end
+        podspec += "\n"
+        podspec += "    p1.#{platform.safe_string_name.downcase}.deployment_target  = '#{platform.deployment_target.version}'\n"
+        podspec += "\n"
+
+        main_keys, valid = generate_spec_keys_for(item, item.root_name, all_buildable_items)
+        if !valid
+          next
         end
 
-        podspec_item.dependencies = buildable_items.select { |x| pod.dependency_names.include?(x.name) }
+        podspec += main_keys
+        podspec += "end"
+
+        spec_path = item.prebuilt_podspec_path
+        if File.directory?(File.dirname(spec_path))
+          File.write(spec_path, podspec)
+        else
+          message = "Prebuilt podspec destination not found for #{File.basename(spec_path)}".red
+          if ENV['DEBUGGING']
+            puts message
+          else
+            raise message
+          end
+        end
       end
-
-      return podspec_items
     end
   end
 end

data/lib/pod_builder/rome/post_install.rb

@@ -0,0 +1,240 @@
+# TODO: Add support when building without use_frameworks!
+
+require 'fourflusher'
+require 'colored'
+
+module PodBuilder
+  def self.build_for_iosish_platform(sandbox, build_dir, target, device, simulator, configuration, deterministic_build, build_for_apple_silicon)
+    raise "\n\nApple silicon hardware still unsupported since it requires to migrate to xcframeworks".red if build_for_apple_silicon
+    
+    dsym_device_folder = File.join(build_dir, "dSYM", device)
+    dsym_simulator_folder = File.join(build_dir, "dSYM", simulator)
+    FileUtils.mkdir_p(dsym_device_folder)
+    FileUtils.mkdir_p(dsym_simulator_folder)
+    
+    deployment_target = target.platform_deployment_target
+    target_label = target.cocoapods_target_label
+    
+    xcodebuild(sandbox, target_label, device, deployment_target, configuration, deterministic_build, [])
+    excluded_archs = build_for_apple_silicon ? [] : ["arm64"]
+    xcodebuild(sandbox, target_label, simulator, deployment_target, configuration, deterministic_build, excluded_archs)
+    
+    spec_names = target.specs.map { |spec| [spec.root.name, spec.root.module_name] }.uniq
+    spec_names.each do |root_name, module_name|
+      device_base = "#{build_dir}/#{configuration}-#{device}/#{root_name}" 
+      device_lib = "#{device_base}/#{module_name}.framework/#{module_name}"
+      device_dsym = "#{device_base}/#{module_name}.framework.dSYM"
+      device_framework_lib = File.dirname(device_lib)
+      device_swift_header_path = "#{device_framework_lib}/Headers/#{module_name}-Swift.h"
+      
+      simulator_base = "#{build_dir}/#{configuration}-#{simulator}/#{root_name}"
+      simulator_lib = "#{simulator_base}/#{module_name}.framework/#{module_name}"
+      simulator_dsym = "#{simulator_base}/#{module_name}.framework.dSYM"
+      simulator_framework_lib = File.dirname(simulator_lib)
+      simulator_swift_header_path = "#{simulator_framework_lib}/Headers/#{module_name}-Swift.h"
+      
+      next unless File.file?(device_lib) && File.file?(simulator_lib)
+      
+      # Starting with Xcode 12b3 the simulator binary contains an arm64 slice as well which conflict with the one in the device_lib
+      # when creating the fat library. A naive workaround is to remove the arm64 from the simulator_lib however this is wrong because 
+      # we might actually need to have 2 separated arm64 slices, one for simulator and one for device each built with different
+      # compile time directives (e.g #if targetEnvironment(simulator))
+      #
+      # For the time being we remove the arm64 slice bacause otherwise the `xcrun lipo -create -output ...` would fail.
+      if `xcrun lipo -info #{simulator_lib}`.include?("arm64")
+        `xcrun lipo -remove arm64 #{simulator_lib} -o #{simulator_lib}`
+      end
+      
+      raise "Lipo failed on #{device_lib}" unless system("xcrun lipo -create -output #{device_lib} #{device_lib} #{simulator_lib}")
+      
+      # Merge swift headers as per Xcode 10.2 release notes
+      if File.exist?(device_swift_header_path) && File.exist?(simulator_swift_header_path)
+        device_content = File.read(device_swift_header_path)
+        simulator_content = File.read(simulator_swift_header_path)
+        merged_content = %{
+          #if TARGET_OS_SIMULATOR
+          #{simulator_content}
+          #else
+          #{device_content}
+          #endif
+        }        
+        File.write(device_swift_header_path, merged_content)
+      end
+      
+      # Merge device framework into simulator framework (so that e.g swift Module folder is merged) 
+      # letting device framework files overwrite simulator ones
+      FileUtils.cp_r(File.join(device_framework_lib, "."), simulator_framework_lib) 
+      source_lib = File.dirname(simulator_framework_lib)
+      
+      FileUtils.cp_r(source_lib, build_dir)
+      
+      FileUtils.cp_r(device_dsym, dsym_device_folder) if File.exist?(device_dsym)
+      FileUtils.cp_r(simulator_dsym, dsym_simulator_folder) if File.exist?(simulator_dsym)
+      
+      # Remove frameworks leaving dSYMs
+      FileUtils.rm_rf(device_framework_lib) 
+      FileUtils.rm_rf(simulator_framework_lib)
+    end
+  end
+  
+  def self.xcodebuild(sandbox, target, sdk='macosx', deployment_target=nil, configuration, deterministic_build, exclude_archs)
+    args = %W(-project #{sandbox.project_path.realdirpath} -scheme #{target} -configuration #{configuration} -sdk #{sdk})
+    supported_platforms = { 'iphonesimulator' => 'iOS', 'appletvsimulator' => 'tvOS', 'watchsimulator' => 'watchOS' }
+    if platform = supported_platforms[sdk]
+      args += Fourflusher::SimControl.new.destination(:oldest, platform, deployment_target) unless platform.nil?
+    end
+    
+    xcodebuild_version = `xcodebuild -version | head -n1 | awk '{print $2}'`.strip().to_f
+    if exclude_archs.count > 0 && xcodebuild_version >= 12.0
+      args += ["EXCLUDED_ARCHS=#{exclude_archs.join(" ")}"]
+    end
+    
+    environmental_variables = {}
+    if deterministic_build
+      environmental_variables["ZERO_AR_DATE"] = "1"
+    end
+    
+    execute_command 'xcodebuild', args, true, environmental_variables
+  end
+  
+  # Copy paste implementation from CocoaPods internals to be able to call poopen3 passing environmental variables
+  def self.execute_command(executable, command, raise_on_failure = true, environmental_variables = {})
+    bin = Pod::Executable.which!(executable)
+    
+    command = command.map(&:to_s)
+    full_command = "#{bin} #{command.join(' ')}"
+    
+    stdout = Pod::Executable::Indenter.new
+    stderr = Pod::Executable::Indenter.new
+    
+    status = popen3(bin, command, stdout, stderr, environmental_variables)
+    stdout = stdout.join
+    stderr = stderr.join
+    output = stdout + stderr
+    unless status.success?
+      if raise_on_failure
+        raise "#{full_command}\n\n#{output}"
+      else
+        UI.message("[!] Failed: #{full_command}".red)
+      end
+    end
+    
+    output
+  end
+  
+  def self.popen3(bin, command, stdout, stderr, environmental_variables)
+    require 'open3'
+    Open3.popen3(environmental_variables, bin, *command) do |i, o, e, t|
+      Pod::Executable::reader(o, stdout)
+      Pod::Executable::reader(e, stderr)
+      i.close
+      
+      status = t.value
+      
+      o.flush
+      e.flush
+      sleep(0.01)
+      
+      status
+    end
+  end
+  
+  def self.enable_debug_information(project_path, configuration)
+    project = Xcodeproj::Project.open(project_path)
+    project.targets.each do |target|
+      config = target.build_configurations.find { |config| config.name.eql? configuration }
+      config.build_settings['DEBUG_INFORMATION_FORMAT'] = 'dwarf-with-dsym'
+      config.build_settings['ONLY_ACTIVE_ARCH'] = 'NO'
+    end
+    project.save
+  end
+
+  
+end
+
+Pod::HooksManager.register('podbuilder-rome', :post_install) do |installer_context, user_options|
+  enable_dsym = user_options.fetch('dsym', true)
+  configuration = user_options.fetch('configuration', 'Debug')
+  if user_options["pre_compile"]
+    user_options["pre_compile"].call(installer_context)
+  end
+  
+  sandbox_root = Pathname(installer_context.sandbox_root)
+  sandbox = Pod::Sandbox.new(sandbox_root)
+  
+  PodBuilder::enable_debug_information(sandbox.project_path, configuration)
+  
+  build_dir = sandbox_root.parent + 'build'
+  base_destination = sandbox_root.parent + 'Prebuilt'
+  
+  build_dir.rmtree if build_dir.directory?
+  targets = installer_context.umbrella_targets.select { |t| t.specs.any? }
+  targets.each do |target|
+    case target.platform_name
+    when :ios then PodBuilder::build_for_iosish_platform(sandbox, build_dir, target, 'iphoneos', 'iphonesimulator', configuration, PodBuilder::Configuration.deterministic_build, PodBuilder::Configuration.build_for_apple_silicon)
+    when :osx then PodBuilder::xcodebuild(sandbox, target.cocoapods_target_label, configuration, PodBuilder::Configuration.deterministic_build, PodBuilder::Configuration.build_for_apple_silicon)
+    when :tvos then PodBuilder::build_for_iosish_platform(sandbox, build_dir, target, 'appletvos', 'appletvsimulator', configuration, PodBuilder::Configuration.deterministic_build, PodBuilder::Configuration.build_for_apple_silicon)
+    when :watchos then PodBuilder::build_for_iosish_platform(sandbox, build_dir, target, 'watchos', 'watchsimulator', configuration, PodBuilder::Configuration.deterministic_build, PodBuilder::Configuration.build_for_apple_silicon)
+    else raise "\n\nUnknown platform '#{target.platform_name}'".red end
+    end
+    
+    raise Pod::Informative, 'The build directory was not found in the expected location.' unless build_dir.directory?
+    
+    built_count = installer_context.umbrella_targets.map { |t| t.specs.map(&:name) }.flatten.map { |t| t.split("/").first }.uniq.count
+    Pod::UI.puts "Built #{built_count} #{'items'.pluralize(built_count)}, copying..."
+    
+    base_destination.rmtree if base_destination.directory?
+    
+    installer_context.umbrella_targets.each do |umbrella|
+      umbrella.specs.each do |spec|
+        root_name = spec.name.split("/").first
+        # Make sure the device target overwrites anything in the simulator build, otherwise iTunesConnect
+        # can get upset about Info.plist containing references to the simulator SDK
+        frameworks = Pathname.glob("build/#{root_name}/*.framework").reject { |f| f.to_s =~ /Pods[^.]+\.framework/ }
+        
+        consumer = spec.consumer(umbrella.platform_name)
+        file_accessor = Pod::Sandbox::FileAccessor.new(sandbox.pod_dir(spec.root.name), consumer)
+        frameworks += file_accessor.vendored_libraries
+        frameworks += file_accessor.vendored_frameworks
+        resources = file_accessor.resources
+        
+        destination = File.join(base_destination, root_name)
+        FileUtils.mkdir_p(destination)
+        
+        files = frameworks + resources
+        files.each do |file|
+          FileUtils.cp_r(file, destination)
+        end    
+      end
+    end
+    
+    # Depending on the resource it may happen that it is present twice, both in the .framework and in the parent folder
+    Dir.glob("#{base_destination}/*") do |path|
+      unless File.directory?(path)
+        return
+      end
+      
+      files = Dir.glob("#{path}/*")
+      framework_files = Dir.glob("#{path}/*.framework/**/*").map { |t| File.basename(t) }
+      
+      files.each do |file|
+        filename = File.basename(file.gsub(/\.xib$/, ".nib"))
+        if framework_files.include?(filename)
+          FileUtils.rm_rf(file)
+        end
+      end
+    end
+    
+    if enable_dsym
+      FileUtils.mv("#{build_dir}/dSYM", sandbox_root.parent)
+    else
+      raise "Not implemented"
+    end
+    
+    build_dir.rmtree if build_dir.directory?
+    
+    if user_options["post_compile"]
+      user_options["post_compile"].call(installer_context)
+    end
+  end
+