my-cocoapods-packager 1.5.0

data/lib/cocoapods-packager/builder.rb

@@ -0,0 +1,340 @@
+module Pod
+  class Builder
+    def initialize(source_dir, static_sandbox_root, dynamic_sandbox_root, public_headers_root, spec, embedded, mangle, dynamic, config, bundle_identifier, exclude_deps)
+      @source_dir = source_dir
+      @static_sandbox_root = static_sandbox_root
+      @dynamic_sandbox_root = dynamic_sandbox_root
+      @public_headers_root = public_headers_root
+      @spec = spec
+      @embedded = embedded
+      @mangle = mangle
+      @dynamic = dynamic
+      @config = config
+      @bundle_identifier = bundle_identifier
+      @exclude_deps = exclude_deps
+    end
+
+    def build(platform, library)
+      if library
+        build_static_library(platform)
+      else
+        build_framework(platform)
+      end
+    end
+
+    def build_static_library(platform)
+      UI.puts("Building static library #{@spec} with configuration #{@config}")
+
+      defines = compile(platform)
+      build_sim_libraries(platform, defines)
+
+      platform_path = Pathname.new(platform.name.to_s)
+      platform_path.mkdir unless platform_path.exist?
+      build_library(platform, defines, platform_path + Pathname.new("lib#{@spec.name}.a"))
+    end
+
+    def build_framework(platform)
+      UI.puts("Building framework #{@spec} with configuration #{@config}")
+
+      defines = compile(platform)
+      build_sim_libraries(platform, defines)
+
+      if @dynamic
+        build_dynamic_framework(platform, defines, "#{@dynamic_sandbox_root}/build/#{@spec.name}.framework/#{@spec.name}")
+      else
+        create_framework(platform.name.to_s)
+        build_library(platform, defines, @fwk.versions_path + Pathname.new(@spec.name))
+        copy_headers
+        copy_license
+      end
+
+      copy_resources(platform)
+    end
+
+    def link_embedded_resources
+      target_path = @fwk.root_path + Pathname.new('Resources')
+      target_path.mkdir unless target_path.exist?
+
+      Dir.glob(@fwk.resources_path.to_s + '/*').each do |resource|
+        resource = Pathname.new(resource).relative_path_from(target_path)
+        `ln -sf #{resource} #{target_path}`
+      end
+    end
+
+    private
+
+    def build_dynamic_framework(platform, defines, output)
+      UI.puts("Building dynamic Framework #{@spec} with configuration #{@config}")
+
+      if @bundle_identifier
+        defines = "#{defines} PRODUCT_BUNDLE_IDENTIFIER='#{@bundle_identifier}'"
+      end
+
+      clean_directory_for_dynamic_build
+      if platform.name == :ios
+        build_dynamic_framework_for_ios(platform, defines, output)
+      else
+        build_dynamic_framework_for_mac(platform, defines, output)
+      end
+    end
+
+    def build_library(platform, defines, output)
+      static_libs = static_libs_in_sandbox
+
+      if platform.name == :ios
+        build_static_lib_for_ios(static_libs, defines, output)
+      else
+        build_static_lib_for_mac(static_libs, output)
+      end
+    end
+
+    def build_dynamic_framework_for_ios(platform, defines, output)
+      # Specify frameworks to link and search paths
+      lib_linker_flags = static_linker_flags_in_sandbox
+      framework_link_flas = framework_linker_flags_in_sandbox
+
+      linker_flags = lib_linker_flags.push(framework_link_flas)
+
+      puts linker_flags
+
+      defines = "#{defines} OTHER_LDFLAGS='$(inherited) #{linker_flags.join(' ')}'"
+
+      # Build Target Dynamic Framework for both device and Simulator
+      device_defines = "#{defines} LIBRARY_SEARCH_PATHS=\"#{Dir.pwd}/#{@static_sandbox_root}/build\""
+      device_defines = "#{device_defines} FRAMEWORK_SEARCH_PATHS=\"#{Dir.pwd}/#{@static_sandbox_root}/**\""
+
+      device_options = ios_build_options << ' -sdk iphoneos'
+
+      puts device_defines
+      puts linker_flags
+
+      xcodebuild(device_defines, device_options, 'build', @spec.name.to_s, @dynamic_sandbox_root.to_s)
+
+      sim_defines = "#{defines} LIBRARY_SEARCH_PATHS=\"#{Dir.pwd}/#{@static_sandbox_root}/build-sim\" ONLY_ACTIVE_ARCH=NO"
+      sim_defines = "#{sim_defines} FRAMEWORK_SEARCH_PATHS=\"#{Dir.pwd}/#{@static_sandbox_root}/**\""
+
+      xcodebuild(sim_defines, '-sdk iphonesimulator', 'build-sim', @spec.name.to_s, @dynamic_sandbox_root.to_s)
+
+      # Combine architectures
+      `lipo #{@dynamic_sandbox_root}/build/#{@spec.name}.framework/#{@spec.name} #{@dynamic_sandbox_root}/build-sim/#{@spec.name}.framework/#{@spec.name} -create -output #{output}`
+
+      FileUtils.mkdir(platform.name.to_s)
+      `mv #{@dynamic_sandbox_root}/build/#{@spec.name}.framework #{platform.name}`
+      `mv #{@dynamic_sandbox_root}/build/#{@spec.name}.framework.dSYM #{platform.name}`
+    end
+
+    def build_dynamic_framework_for_mac(platform, defines, _output)
+      # Specify frameworks to link and search paths
+      lib_linker_flags = static_linker_flags_in_sandbox
+      framework_link_flas = framework_linker_flags_in_sandbox
+
+      linker_flags = lib_linker_flags.push(framework_link_flas)
+
+
+      defines = "#{defines} OTHER_LDFLAGS=\"#{linker_flags.join(' ')}\""
+
+      # Build Target Dynamic Framework for osx
+      defines = "#{defines} LIBRARY_SEARCH_PATHS=\"#{Dir.pwd}/#{@static_sandbox_root}/build\""
+      device_defines = "#{device_defines} FRAMEWORK_SEARCH_PATHS=\"#{Dir.pwd}/#{@static_sandbox_root}/**\""
+
+      xcodebuild(defines, nil, 'build', @spec.name.to_s, @dynamic_sandbox_root.to_s)
+
+      FileUtils.mkdir(platform.name.to_s)
+      `mv #{@dynamic_sandbox_root}/build/#{@spec.name}.framework #{platform.name}`
+      `mv #{@dynamic_sandbox_root}/build/#{@spec.name}.framework.dSYM #{platform.name}`
+    end
+
+    def build_sim_libraries(platform, defines)
+      if platform.name == :ios
+        xcodebuild(defines, '-sdk iphonesimulator', 'build-sim')
+      end
+    end
+
+    def build_static_lib_for_ios(static_libs, _defines, output)
+      return if static_libs.count == 0
+      `libtool -static -o #{@static_sandbox_root}/build/package.a #{static_libs.join(' ')}`
+
+      sim_libs = static_libs_in_sandbox('build-sim')
+      `libtool -static -o #{@static_sandbox_root}/build-sim/package.a #{sim_libs.join(' ')}`
+
+      `lipo #{@static_sandbox_root}/build/package.a #{@static_sandbox_root}/build-sim/package.a -create -output #{output}`
+    end
+
+    def build_static_lib_for_mac(static_libs, output)
+      return if static_libs.count == 0
+      `libtool -static -o #{output} #{static_libs.join(' ')}`
+    end
+
+    def build_with_mangling(platform, options)
+      UI.puts 'Mangling symbols'
+      defines = Symbols.mangle_for_pod_dependencies(@spec.name, @static_sandbox_root)
+      defines << ' ' << @spec.consumer(platform).compiler_flags.join(' ')
+
+      UI.puts 'Building mangled framework'
+      xcodebuild(defines, options)
+      defines
+    end
+
+    def clean_directory_for_dynamic_build
+      # Remove static headers to avoid duplicate declaration conflicts
+      FileUtils.rm_rf("#{@static_sandbox_root}/Headers/Public/#{@spec.name}")
+      FileUtils.rm_rf("#{@static_sandbox_root}/Headers/Private/#{@spec.name}")
+
+      # Equivalent to removing derrived data
+      FileUtils.rm_rf('Pods/build')
+    end
+
+    def compile(platform)
+      defines = "GCC_PREPROCESSOR_DEFINITIONS='$(inherited) PodsDummy_Pods_#{@spec.name}=PodsDummy_PodPackage_#{@spec.name}'"
+      defines << ' ' << @spec.consumer(platform).compiler_flags.join(' ')
+
+      if platform.name == :ios
+        options = ios_build_options
+      end
+
+      xcodebuild(defines, options)
+
+      if @mangle
+        return build_with_mangling(platform, options)
+      end
+
+      defines
+    end
+
+    def copy_headers
+      headers_source_root = "#{@public_headers_root}/#{@spec.name}"
+
+      Dir.glob("#{headers_source_root}/**/*.h").
+        each { |h| `ditto #{h} #{@fwk.headers_path}/#{h.sub(headers_source_root, '')}` }
+
+      # If custom 'module_map' is specified add it to the framework distribution
+      # otherwise check if a header exists that is equal to 'spec.name', if so
+      # create a default 'module_map' one using it.
+      if !@spec.module_map.nil?
+        module_map_file = "#{@static_sandbox_root}/#{@spec.name}/#{@spec.module_map}"
+        module_map = File.read(module_map_file) if Pathname(module_map_file).exist?
+      elsif File.exist?("#{@public_headers_root}/#{@spec.name}/#{@spec.name}.h")
+        module_map = <<MAP
+framework module #{@spec.name} {
+  umbrella header "#{@spec.name}.h"
+
+  export *
+  module * { export * }
+}
+MAP
+      end
+
+      unless module_map.nil?
+        @fwk.module_map_path.mkpath unless @fwk.module_map_path.exist?
+        File.write("#{@fwk.module_map_path}/module.modulemap", module_map)
+      end
+    end
+
+    def copy_license
+      license_file = @spec.license[:file] || 'LICENSE'
+      `cp "#{license_file}" .` if Pathname(license_file).exist?
+    end
+
+    def copy_resources(platform)
+      bundles = Dir.glob("#{@static_sandbox_root}/build/*.bundle")
+      if @dynamic
+        resources_path = "ios/#{@spec.name}.framework"
+        `cp -rp #{@static_sandbox_root}/build/*.bundle #{resources_path} 2>&1`
+      else
+        `cp -rp #{@static_sandbox_root}/build/*.bundle #{@fwk.resources_path} 2>&1`
+        resources = expand_paths(@spec.consumer(platform).resources)
+        if resources.count == 0 && bundles.count == 0
+          @fwk.delete_resources
+          return
+        end
+        if resources.count > 0
+          `cp -rp #{resources.join(' ')} #{@fwk.resources_path}`
+        end
+      end
+    end
+
+    def create_framework(platform)
+      @fwk = Framework::Tree.new(@spec.name, platform, @embedded)
+      @fwk.make
+    end
+
+    def dependency_count
+      count = @spec.dependencies.count
+
+      @spec.subspecs.each do |subspec|
+        count += subspec.dependencies.count
+      end
+
+      count
+    end
+
+    def expand_paths(path_specs)
+      path_specs.map do |path_spec|
+        Dir.glob(File.join(@source_dir, path_spec))
+      end
+    end
+
+    def static_libs_in_sandbox(build_dir = 'build')
+      if @exclude_deps
+        UI.puts 'Excluding dependencies'
+        Dir.glob("#{@static_sandbox_root}/#{build_dir}/lib#{@spec.name}.a")
+      else
+        Dir.glob("#{@static_sandbox_root}/#{build_dir}/lib*.a")
+      end
+    end
+
+    def framework_in_sandbox(build_dir = 'build')
+      if @exclude_deps
+        UI.puts 'Excluding dependencies'
+        Dir.glob("#{@static_sandbox_root}/**/{@spec.name}.framework")
+      else
+        Dir.glob("#{@static_sandbox_root}/**/*.framework")
+      end
+    end
+
+    def framework_linker_flags_in_sandbox
+      linker_flags = framework_in_sandbox.map do |lib|
+        lib_flag = lib.chomp('.framework').split('/').last
+        "-framework #{lib_flag}"
+      end
+      linker_flags.reject { |e| e == "-framework #{@spec.name}" }
+    end
+
+    def static_linker_flags_in_sandbox
+      puts static_libs_in_sandbox.map
+      linker_flags = static_libs_in_sandbox.map do |lib|
+        lib.slice!('lib')
+        lib_flag = lib.chomp('.a').split('/').last
+        "-l#{lib_flag}"
+      end
+      linker_flags.reject { |e| e == "-l#{@spec.name}" || e == '-lPods-packager' }
+    end
+
+    def ios_build_options
+      "ARCHS=\'x86_64 i386 arm64 armv7 armv7s\' OTHER_CFLAGS=\'-fembed-bitcode -Qunused-arguments\'"
+    end
+
+    def xcodebuild(defines = '', args = '', build_dir = 'build', target = 'Pods-packager', project_root = @static_sandbox_root, config = @config)
+      if defined?(Pod::DONT_CODESIGN)
+        args = "#{args} CODE_SIGN_IDENTITY=\"\" CODE_SIGNING_REQUIRED=NO"
+      end
+
+      UI.puts project_root
+
+      command = "xcodebuild #{defines} #{args} CONFIGURATION_BUILD_DIR=#{build_dir} clean build -configuration #{config} -target #{target} -project #{project_root}/Pods.xcodeproj 2>&1"
+      puts command
+      output = `#{command}`.lines.to_a
+
+      if $?.exitstatus != 0
+        puts UI::BuildFailedReport.report(command, output)
+
+        # Note: We use `Process.exit` here because it fires a `SystemExit`
+        # exception, which gives the caller a chance to clean up before the
+        # process terminates.
+        #
+        # See http://ruby-doc.org/core-1.9.3/Process.html#method-c-exit
+        Process.exit
+      end
+    end
+  end
+end

data/lib/cocoapods-packager/framework.rb

@@ -0,0 +1,66 @@
+module Framework
+  class Tree
+    attr_reader :headers_path
+    attr_reader :module_map_path
+    attr_reader :resources_path
+    attr_reader :root_path
+    attr_reader :versions_path
+
+    def delete_resources
+      Pathname.new(@resources_path).rmtree
+      (Pathname.new(@fwk_path) + Pathname.new('Resources')).delete
+    end
+
+    def initialize(name, platform, embedded)
+      @name = name
+      @platform = platform
+      @embedded = embedded
+    end
+
+    def make
+      make_root
+      make_framework
+      make_headers
+      make_resources
+      make_current_version
+    end
+
+    private
+
+    def make_current_version
+      current_version_path = @versions_path + Pathname.new('../Current')
+      `ln -sf A #{current_version_path}`
+      `ln -sf Versions/Current/Headers #{@fwk_path}/`
+      `ln -sf Versions/Current/Resources #{@fwk_path}/`
+      `ln -sf Versions/Current/#{@name} #{@fwk_path}/`
+    end
+
+    def make_framework
+      @fwk_path = @root_path + Pathname.new(@name + '.framework')
+      @fwk_path.mkdir unless @fwk_path.exist?
+
+      @module_map_path = @fwk_path + Pathname.new('Modules')
+      @versions_path = @fwk_path + Pathname.new('Versions/A')
+    end
+
+    def make_headers
+      @headers_path = @versions_path + Pathname.new('Headers')
+      @headers_path.mkpath unless @headers_path.exist?
+    end
+
+    def make_resources
+      @resources_path = @versions_path + Pathname.new('Resources')
+      @resources_path.mkpath unless @resources_path.exist?
+    end
+
+    def make_root
+      @root_path = Pathname.new(@platform)
+
+      if @embedded
+        @root_path += Pathname.new(@name + '.embeddedframework')
+      end
+
+      @root_path.mkpath unless @root_path.exist?
+    end
+  end
+end

data/lib/cocoapods-packager/mangle.rb

@@ -0,0 +1,32 @@
+module Symbols
+  #
+  # performs symbol aliasing
+  #
+  # for each dependency:
+  # 	- determine symbols for classes and global constants
+  # 	- alias each symbol to Pod#{pod_name}_#{symbol}
+  # 	- put defines into `GCC_PREPROCESSOR_DEFINITIONS` for passing to Xcode
+  #
+  def mangle_for_pod_dependencies(pod_name, sandbox_root)
+    pod_libs = Dir.glob("#{sandbox_root}/build/lib*.a").select do |file|
+      file !~ /lib#{pod_name}.a$/
+    end
+
+    dummy_alias = alias_symbol "PodsDummy_#{pod_name}", pod_name
+    all_syms = [dummy_alias]
+
+    pod_libs.each do |pod_lib|
+      syms = Symbols.symbols_from_library(pod_lib)
+      all_syms += syms.map! { |sym| alias_symbol sym, pod_name }
+    end
+
+    "GCC_PREPROCESSOR_DEFINITIONS='$(inherited) #{all_syms.uniq.join(' ')}'"
+  end
+
+  def alias_symbol(sym, pod_name)
+    pod_name = pod_name.tr('-', '_')
+    sym + "=Pod#{pod_name}_" + sym
+  end
+
+  module_function :mangle_for_pod_dependencies, :alias_symbol
+end

data/lib/cocoapods-packager/pod_utils.rb

@@ -0,0 +1,252 @@
+module Pod
+  class Command
+    class Package < Command
+      private
+
+      def build_static_sandbox(dynamic)
+        static_sandbox_root = if dynamic
+                                Pathname.new(config.sandbox_root + '/Static')
+                              else
+                                Pathname.new(config.sandbox_root)
+                              end
+        Sandbox.new(static_sandbox_root)
+      end
+
+      def install_pod(platform_name, sandbox)
+        podfile = podfile_from_spec(
+          File.basename(@path),
+          @spec.name,
+          platform_name,
+          @spec.deployment_target(platform_name),
+          @subspecs,
+          @spec_sources
+        )
+
+        static_installer = Installer.new(sandbox, podfile)
+        static_installer.install!
+
+        unless static_installer.nil?
+          static_installer.pods_project.targets.each do |target|
+            target.build_configurations.each do |config|
+              config.build_settings['CLANG_MODULES_AUTOLINK'] = 'NO'
+              config.build_settings['GCC_GENERATE_DEBUGGING_SYMBOLS'] = 'NO'
+            end
+          end
+          static_installer.pods_project.save
+        end
+
+        static_installer
+      end
+
+      def podfile_from_spec(path, spec_name, platform_name, deployment_target, subspecs, sources)
+        options = {}
+        if path
+          options[:podspec] = path
+        else
+          options[:path] = '.'
+        end
+        options[:subspecs] = subspecs if subspecs
+        Pod::Podfile.new do
+          sources.each { |s| source s }
+          platform(platform_name, deployment_target)
+          pod(spec_name, options)
+
+          install!('cocoapods',
+                   :integrate_targets => false,
+                   :deterministic_uuids => false)
+
+          target('packager') do
+            if path
+              if subspecs
+                subspecs.each do |subspec|
+                  pod spec_name + '/' + subspec, :podspec => path
+                end
+              else
+                pod spec_name, :podspec => path
+              end
+            elsif subspecs
+              subspecs.each do |subspec|
+                pod spec_name + '/' + subspec, :path => '.'
+              end
+            else
+              pod spec_name, :path => '.'
+            end
+          end
+        end
+      end
+
+      def binary_only?(spec)
+        deps = spec.dependencies.map { |dep| spec_with_name(dep.name) }
+        [spec, *deps].each do |specification|
+          %w(vendored_frameworks vendored_libraries).each do |attrib|
+            if specification.attributes_hash[attrib]
+              return true
+            end
+          end
+        end
+
+        false
+      end
+
+      def spec_with_name(name)
+        return if name.nil?
+
+        set = Pod::Config.instance.sources_manager.search(Dependency.new(name))
+        return nil if set.nil?
+
+        set.specification.root
+      end
+
+      def spec_with_path(path)
+        return if path.nil? || !Pathname.new(path).exist?
+
+        @path = path
+
+        if Pathname.new(path).directory?
+          help! path + ': is a directory.'
+          return
+        end
+
+        unless ['.podspec', '.json'].include? Pathname.new(path).extname
+          help! path + ': is not a podspec.'
+          return
+        end
+
+        Specification.from_file(path)
+      end
+
+      #----------------------
+      # Dynamic Project Setup
+      #----------------------
+
+      def build_dynamic_sandbox(_static_sandbox, _static_installer)
+        dynamic_sandbox_root = Pathname.new(config.sandbox_root + '/Dynamic')
+        dynamic_sandbox = Sandbox.new(dynamic_sandbox_root)
+
+        dynamic_sandbox
+      end
+
+      def install_dynamic_pod(dynamic_sandbox, static_sandbox, static_installer)
+        # 1 Create a dynamic target for only the spec pod.
+        dynamic_target = build_dynamic_target(dynamic_sandbox, static_installer)
+
+        # 2. Build a new xcodeproj in the dynamic_sandbox with only the spec pod as a target.
+        project = prepare_pods_project(dynamic_sandbox, dynamic_target.name, static_installer)
+
+        # 3. Copy the source directory for the dynamic framework from the static sandbox.
+        copy_dynamic_target(static_sandbox, dynamic_target, dynamic_sandbox)
+
+        # 4. Copy the supporting files for the dynamic framework from the static sandbox.
+        copy_dynamic_supporting_files(static_sandbox, dynamic_target, dynamic_sandbox)
+
+        # 5. Update the file accecssors.
+        dynamic_target = update_file_accessors(dynamic_target, dynamic_sandbox)
+
+        # 6. Create the file references.
+        install_file_references(dynamic_sandbox, [dynamic_target], project)
+
+        # 7. Install the target.
+        install_library(dynamic_sandbox, dynamic_target)
+
+        # 9. Write the actual Xcodeproject to the dynamic sandbox.
+        write_pod_project(project, dynamic_sandbox)
+      end
+
+      def build_dynamic_target(dynamic_sandbox, static_installer)
+        spec_targets = static_installer.pod_targets.select do |target|
+          target.name == @spec.name
+        end
+        static_target = spec_targets[0]
+
+        dynamic_target = Pod::PodTarget.new(static_target.specs, static_target.target_definitions, dynamic_sandbox)
+        dynamic_target.host_requires_frameworks = true
+        dynamic_target.user_build_configurations = static_target.user_build_configurations
+        dynamic_target
+      end
+
+      def prepare_pods_project(dynamic_sandbox, spec_name, installer)
+        # Create a new pods project
+        pods_project = Pod::Project.new(dynamic_sandbox.project_path)
+
+        # Update build configurations
+        installer.analysis_result.all_user_build_configurations.each do |name, type|
+          pods_project.add_build_configuration(name, type)
+        end
+
+        # Add the pod group for only the dynamic framework
+        local = dynamic_sandbox.local?(spec_name)
+        path = dynamic_sandbox.pod_dir(spec_name)
+        was_absolute = dynamic_sandbox.local_path_was_absolute?(spec_name)
+        pods_project.add_pod_group(spec_name, path, local, was_absolute)
+
+        dynamic_sandbox.project = pods_project
+        pods_project
+      end
+
+      def copy_dynamic_target(static_sandbox, _dynamic_target, dynamic_sandbox)
+        command = "cp -a #{static_sandbox.root}/#{@spec.name} #{dynamic_sandbox.root}"
+        `#{command}`
+      end
+
+      def copy_dynamic_supporting_files(_static_sandbox, dynamic_target, _dynamic_sandbox)
+        support_dir = Pathname.new(dynamic_target.support_files_dir.to_s.chomp("/#{dynamic_target.name}"))
+        support_dir.mkdir
+      end
+
+      def update_file_accessors(dynamic_target, dynamic_sandbox)
+        pod_root = dynamic_sandbox.pod_dir(dynamic_target.root_spec.name)
+
+        path_list = Sandbox::PathList.new(pod_root)
+        file_accessors = dynamic_target.specs.map do |spec|
+          Sandbox::FileAccessor.new(path_list, spec.consumer(dynamic_target.platform))
+        end
+
+        dynamic_target.file_accessors = file_accessors
+        dynamic_target
+      end
+
+      def install_file_references(dynamic_sandbox, pod_targets, pods_project)
+        installer = Pod::Installer::Xcode::PodsProjectGenerator::FileReferencesInstaller.new(dynamic_sandbox, pod_targets, pods_project)
+        installer.install!
+      end
+
+      def install_library(dynamic_sandbox, dynamic_target)
+        return if dynamic_target.target_definitions.flat_map(&:dependencies).empty?
+        target_installer = Pod::Installer::Xcode::PodsProjectGenerator::PodTargetInstaller.new(dynamic_sandbox, dynamic_target)
+        target_installer.install!
+
+        # Installs System Frameworks
+        dynamic_target.file_accessors.each do |file_accessor|
+          file_accessor.spec_consumer.frameworks.each do |framework|
+            if dynamic_target.should_build?
+              dynamic_target.native_target.add_system_framework(framework)
+            end
+          end
+
+          file_accessor.spec_consumer.libraries.each do |library|
+            if dynamic_target.should_build?
+              dynamic_target.native_target.add_system_library(library)
+            end
+          end
+        end
+      end
+
+      def write_pod_project(dynamic_project, dynamic_sandbox)
+        UI.message "- Writing Xcode project file to #{UI.path dynamic_sandbox.project_path}" do
+          dynamic_project.pods.remove_from_project if dynamic_project.pods.empty?
+          dynamic_project.development_pods.remove_from_project if dynamic_project.development_pods.empty?
+          dynamic_project.sort(:groups_position => :below)
+          dynamic_project.recreate_user_schemes(false)
+
+          # Edit search paths so that we can find our dependency headers
+          dynamic_project.targets.first.build_configuration_list.build_configurations.each do |config|
+            config.build_settings['HEADER_SEARCH_PATHS'] = "$(inherited) #{Dir.pwd}/Pods/Static/Headers/**"
+            config.build_settings['USER_HEADER_SEARCH_PATHS'] = "$(inherited) #{Dir.pwd}/Pods/Static/Headers/**"
+            config.build_settings['OTHER_LDFLAGS'] = '$(inherited) -ObjC'
+          end
+          dynamic_project.save
+        end
+      end
+    end
+  end
+end