pod-builder 0.1.8.beta → 0.2.0

data/lib/pod_builder/install.rb

@@ -7,7 +7,10 @@ module PodBuilder
       
       init_git(Configuration.build_path) # this is needed to be able to call safe_rm_rf
 
-      File.write("#{Configuration.build_path}/Podfile", podfile_content)
+      podfile_path = "#{Configuration.build_path}/Podfile"
+      File.write(podfile_path, podfile_content)
+      Podfile.update_path_entires(podfile_path, true)
+      Podfile.update_project_entries(podfile_path, true)
 
       begin  
         lock_file = "#{Configuration.build_path}/pod_builder.lock"
@@ -48,7 +51,7 @@ module PodBuilder
     def self.framework_rel_path(framework_path, podfile_items)
       framework_name = File.basename(framework_path)
       framework_name_no_ext = File.basename(framework_name, File.extname(framework_name))
-      if podfile_item = podfile_items.detect { |x| x.module_name == framework_name_no_ext }
+      if podfile_item = podfile_items.detect { |x| x.module_name == framework_name_no_ext && Configuration.subspecs_to_split.include?(x.name) }
         return "#{podfile_item.prebuilt_rel_path}"
       else
         return framework_name

data/lib/pod_builder/podfile.rb

@@ -2,8 +2,11 @@ require 'pod_builder/cocoapods/analyzer'
 
 module PodBuilder
   class Podfile
-
-    PRE_INSTALL_ACTIONS = ["raise \"\\n🚨  Do not launch 'pod install' manually, use `pod_builder` instead!\\n\" if !File.exist?('pod_builder.lock')"]
+    PODBUILDER_LOCK_ACTION = ["raise \"\\n🚨  Do not launch 'pod install' manually, use `pod_builder` instead!\\n\" if !File.exist?('pod_builder.lock')"].freeze    
+    POST_INSTALL_ACTIONS = ["require 'pod_builder/podfile/post_actions'", "PodBuilder::Podfile::remove_target_support_duplicate_entries", "PodBuilder::Podfile::check_target_support_resource_collisions"].freeze
+    
+    PRE_INSTALL_ACTIONS = ["Pod::Installer::Xcode::TargetValidator.send(:define_method, :verify_no_duplicate_framework_and_library_names) {}"].freeze
+    private_constant :PRE_INSTALL_ACTIONS
 
     def self.from_podfile_items(items, analyzer)
       raise "no items" unless items.count > 0
@@ -12,21 +15,36 @@ module PodBuilder
       
       cwd = File.dirname(File.expand_path(__FILE__))
       podfile = File.read("#{cwd}/templates/build_podfile.template")
-      
+
+      platform = analyzer.result.targets.first.platform
+      podfile.sub!("%%%platform_name%%%", platform.name.to_s)
+      podfile.sub!("%%%deployment_version%%%", platform.deployment_target.version)
+
       podfile.sub!("%%%sources%%%", sources.map { |x| "source '#{x.url}'" }.join("\n"))
 
       build_configurations = items.map(&:build_configuration).uniq
       raise "Found different build configurations in #{items}" if build_configurations.count != 1
       podfile.sub!("%%%build_configuration%%%", build_configurations.first.capitalize)
 
-      build_settings = Configuration.build_settings
       podfile_build_settings = ""
       
       pod_dependencies = {}
 
       items.each do |item|
+        build_settings = Configuration.build_settings.dup
+
         item_build_settings = Configuration.build_settings_overrides[item.name] || {}
+        
+        # These settings need to be set as is to properly build frameworks
+        build_settings['SWIFT_COMPILATION_MODE'] = 'singlefile'
+        build_settings['CLANG_ENABLE_MODULE_DEBUGGING'] = 'NO'
+        build_settings['ONLY_ACTIVE_ARCH'] = 'NO'
+
         build_settings['SWIFT_VERSION'] = item_build_settings["SWIFT_VERSION"] || project_swift_version(analyzer)
+        if item.is_static
+          # https://forums.developer.apple.com/thread/17921
+          build_settings['CLANG_ENABLE_MODULE_DEBUGGING'] = "NO"
+        end
 
         item_build_settings.each do |k, v|
           build_settings[k] = v
@@ -38,7 +56,7 @@ module PodBuilder
           if x.split("/").first == item.root_name
             next nil # remove dependency to parent spec
           end
-          if overridded_module_name = Configuration.spec_overrides[x]["module_name"]
+          if overridded_module_name = Configuration.spec_overrides.fetch(x, {})["module_name"]
             next overridded_module_name
           end
         }.compact
@@ -62,105 +80,113 @@ module PodBuilder
     end
 
     def self.write_restorable(updated_pods, podfile_items, analyzer)
+      puts "Writing Restore Podfile".yellow
+
       podfile_items = podfile_items.dup
       podfile_restore_path = PodBuilder::basepath("Podfile.restore")
       podfile_path = PodBuilder::basepath("Podfile")
 
       if File.exist?(podfile_restore_path)
-        podfile_content = File.read(podfile_restore_path)
-
         restore_podfile_items = podfile_items_at(podfile_restore_path)
 
         podfile_items.map! { |podfile_item|
           if updated_pod = updated_pods.detect { |x| x.name == podfile_item.name } then
             updated_pod
-          elsif restored_pod = restore_podfile_items.detect { |x| x.name == podfile_item.name }
+          elsif updated_pods.any? { |x| podfile_item.root_name == x.root_name } == false && # podfile_item shouldn't be among those being updated (including root specification)
+            restored_pod = restore_podfile_items.detect { |x| x.name == podfile_item.name }
             restored_pod
           else
             podfile_item
           end
         }
-      else
-        podfile_content = File.read(podfile_path)
       end
-      
-      current_target = nil
-      destination_lines = []
-      podfile_content.each_line do |line|
-        stripped_line = strip_line(line)
-        if current_target.nil?
-          destination_lines.push(line)
 
-          if current_target = target_definition_in(line, false)
-            target_pods, target_dependencies = analyzer.pods_and_deps_in_target(current_target, podfile_items)
+      result_targets = analyzer.result.targets.map(&:name) 
+      podfile_content = ["# Autogenerated by PodBuilder (https://github.com/Subito-it/PodBuilder)", "# Please don't modify this file", "\n"]
+      podfile_content += analyzer.podfile.sources.map { |x| "source '#{x}'" }
+      podfile_content += ["", "use_frameworks!", ""]
 
-            # dependecies should be listed first
-            current_target_pods = (target_dependencies + target_pods).uniq
+      # multiple platforms not (yet) supported
+      # https://github.com/CocoaPods/Rome/issues/37
+      platform = analyzer.result.targets.first.platform
+      podfile_content += ["platform :#{platform.name}, '#{platform.deployment_target.version}'", ""]
 
-            # There should be at most one subspecs per target
-            # Taking just one subspec is enough to pin to the correct version
-            current_target_pods = current_target_pods.sort_by(&:name).uniq(&:root_name)
+      analyzer.result.specs_by_target.each do |target, specifications|
+        target_name = target.name.to_s
 
-            current_target_pods.each { |x| destination_lines.push("  #{x.entry}\n") }
-          end
-        else          
-          if stripped_line == "end"
-            destination_lines.push(line)
-            current_target = nil
-          end
+        unless result_targets.select { |x| x.end_with?(target_name) }.count > 0
+          next
         end
+
+        podfile_content.push("target '#{target_name}' do")
+
+        specifications.each do |spec|
+          item = podfile_items.detect { |x| x.name == spec.name }
+          podfile_content.push("\t#{item.entry}")
+        end
+
+        podfile_content.push("end\n")
       end
 
-      podfile_content = destination_lines.join
-      File.write(podfile_restore_path, podfile_content)
+      File.write(podfile_restore_path, podfile_content.join("\n"))
     end
 
-    def self.update_prebuilt(updated_pods, podfile_items, analyzer)
-      project_podfile_path = PodBuilder::xcodepath("Podfile")
+    def self.write_prebuilt(all_buildable_items, analyzer)  
+      puts "Updating Application Podfile".yellow
 
-      podfile_content = File.read(project_podfile_path)
+      podbuilder_podfile_path = PodBuilder::basepath("Podfile")
+      rel_path = Pathname.new(podbuilder_podfile_path).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
+    
+      frameworks_base_path = PodBuilder::basepath("Rome")
+    
+      podfile_content = File.read(podbuilder_podfile_path)
 
-      stripped_prebuilt_entries = (updated_pods + podfile_items).map(&:prebuilt_entry).map { |x| strip_line(x) }
-      podfile_items_name = podfile_items.map(&:name)
+      exclude_lines = Podfile::PODBUILDER_LOCK_ACTION.map { |x| Podfile.strip_line(x) }
 
-      destination_lines = []
+      prebuilt_lines = ["# Autogenerated by PodBuilder (https://github.com/Subito-it/PodBuilder)\n", "# Any change to this file should be done on #{rel_path}\n", "\n"]
       podfile_content.each_line do |line|
         stripped_line = strip_line(line)
 
         if pod_name = pod_definition_in(line, true)
-          if updated_pod = updated_pods.detect { |x| x.name == pod_name }
-            destination_lines.push("  #{updated_pod.prebuilt_entry}\n")
-            destination_lines.push("  # #{updated_pod.entry(false)}\n")
-            next
-          elsif !podfile_items_name.include?(pod_name) && !stripped_prebuilt_entries.include?(stripped_line)
-            next
+          if podfile_item = all_buildable_items.detect { |x| x.name == pod_name }
+            if File.exist?("#{frameworks_base_path}/#{podfile_item.prebuilt_rel_path}")
+              line = "#{line.detect_indentation}#{podfile_item.prebuilt_entry}\n"
+            end
           end
         end
 
-        destination_lines.push(line)
+        if !exclude_lines.include?(stripped_line)
+          prebuilt_lines.push(line)
+        end
       end
 
-      # remove adiacent duplicated entries
-      destination_lines = destination_lines.chunk { |x| x }.map(&:first)
+      project_podfile_path = PodBuilder::project_path("Podfile")
+      File.write(project_podfile_path, prebuilt_lines.join)
+      Podfile.update_path_entires(project_podfile_path, false)
+      Podfile.update_project_entries(project_podfile_path, false)
 
-      podfile_content = destination_lines.join
-      File.write(project_podfile_path, podfile_content)
+      add_pre_install_actions(project_podfile_path)
+      add_post_install_checks(project_podfile_path)
     end
 
     def self.deintegrate_install
+      puts "Running pod install".yellow
+
       current_dir = Dir.pwd
 
-      Dir.chdir(PodBuilder::xcodepath)
-      system("pod deintegrate; pod install;")
+      Dir.chdir(PodBuilder::project_path)
+      system("pod install;")
       Dir.chdir(current_dir)
     end
 
     def self.strip_line(line)
-      stripped_line = line.dup
-      return stripped_line.gsub("\"", "'").gsub(" ", "").gsub("\n", "")
+      stripped_line = line.strip
+      return stripped_line.gsub("\"", "'").gsub(" ", "").gsub("\t", "").gsub("\n", "")
     end
 
-    private
+    def self.add_install_block(podfile_path)
+      add(PODBUILDER_LOCK_ACTION, "pre_install", podfile_path)
+    end
 
     def self.pod_definition_in(line, include_commented)
       stripped_line = strip_line(line)
@@ -173,19 +199,30 @@ module PodBuilder
       end
     end
 
-    def self.target_definition_in(line, include_commented)
-      stripped_line = strip_line(line)
-      matches = stripped_line.match(/(^target')(.*?)(')/)
-      
-      if matches&.size == 4 && (include_commented || !stripped_line.start_with?("#"))
-        return matches[2]
-      else
-        return nil
+    private
+    
+    def self.indentation_from_file(path)
+      content = File.read(path)
+
+      lines = content.split("\n").select { |x| !x.empty? }
+
+      if lines.count > 2
+        lines[0..-2].each_with_index do |current_line, index|
+          next_line = lines[index + 1]
+          next_line_first_char = next_line.chars.first
+          current_doesnt_begin_with_whitespace = current_line[/\A\S*/] != nil
+
+          if current_doesnt_begin_with_whitespace && [" ", "\t"].include?(next_line_first_char)
+            return next_line[/\A\s*/]
+          end          
+        end
       end
+
+      return "  "
     end
 
     def self.project_swift_version(analyzer)
-      swift_versions = analyzer.result.target_inspections.values.map { |x| x.target_definition.swift_version }.uniq
+      swift_versions = analyzer.result.target_inspections.values.map { |x| x.target_definition.swift_version }.compact.uniq
 
       raise "Found different Swift versions in targets. Expecting one, got `#{swift_versions}`" if swift_versions.count != 1
 
@@ -208,7 +245,7 @@ module PodBuilder
         installer, analyzer = Analyze.installer_at(PodBuilder::basepath)
       
         podfile_items = Analyze.podfile_items(installer, analyzer)
-        buildable_items = podfile_items.select { |item| item.is_prebuilt == false }   
+        buildable_items = podfile_items.select { |item| !item.is_prebuilt }   
       rescue Exception => e
         raise e
       ensure
@@ -221,5 +258,106 @@ module PodBuilder
 
       return buildable_items
     end
+
+    def self.add_pre_install_actions(podfile_path)
+      add(PRE_INSTALL_ACTIONS + [" "], "pre_install", podfile_path)
+    end
+
+    def self.add_post_install_checks(podfile_path)
+      add(POST_INSTALL_ACTIONS + [" "], "post_install", podfile_path)
+    end
+
+    def self.add(entries, marker, podfile_path)
+      podfile_content = File.read(podfile_path)
+
+      file_indentation = indentation_from_file(podfile_path)
+
+      entries = entries.map { |x| "#{file_indentation}#{x}\n"}
+
+      marker_found = false
+      podfile_lines = []
+      podfile_content.each_line do |line|
+        stripped_line = Podfile::strip_line(line)
+
+        podfile_lines.push(line)
+        if stripped_line.start_with?("#{marker}do|")
+          marker_found = true
+          podfile_lines.push(entries)
+        end
+      end
+
+      if !marker_found
+        podfile_lines.push("\n#{marker} do |installer|\n")
+        podfile_lines.push(entries)
+        podfile_lines.push("end\n")
+      end
+
+      File.write(podfile_path, podfile_lines.join)
+    end
+    
+    def self.update_path_entires(podfile_path, use_absolute_paths = false, path_base = PodBuilder::basepath(""))
+      podfile_content = File.read(podfile_path)
+      
+      base_path = Pathname.new(File.dirname(podfile_path))
+      regex = "(\s*pod\s*['|\"])(.*?)(['|\"])(.*?)(:path\s*=>\s*['|\"])(.*?)(['|\"])"
+
+      podfile_lines = []
+      podfile_content.each_line do |line|
+        stripped_line = strip_line(line)
+        matches = line.match(/#{regex}/)
+
+        if matches&.size == 8 && !stripped_line.start_with?("#")
+          pod_name = matches[2]
+          path = matches[6]
+          unless !pod_name.start_with?("PodBuilder/")
+            podfile_lines.push(line)
+            next
+          end
+
+          original_path = Pathname.new(File.join(path_base, path))
+          replace_path = original_path.relative_path_from(base_path)
+          if use_absolute_paths
+            replace_path = replace_path.expand_path(base_path)
+          end
+                    
+          updated_path_line = line.gsub(/#{regex}/, '\1\2\3\4\5' + replace_path.to_s + '\7\8')
+          podfile_lines.push(updated_path_line)
+        else
+          podfile_lines.push(line)
+        end
+      end
+
+      File.write(podfile_path, podfile_lines.join)
+    end
+
+    def self.update_project_entries(podfile_path, use_absolute_paths = false, path_base = PodBuilder::basepath(""))
+      podfile_content = File.read(podfile_path)
+      
+      base_path = Pathname.new(File.dirname(podfile_path))
+      regex = "(\s*project\s*['|\"])(.*?)(['|\"])"
+
+      podfile_lines = []
+      podfile_content.each_line do |line|
+        stripped_line = strip_line(line)
+        matches = line.match(/#{regex}/)
+
+        if matches&.size == 4 && !stripped_line.start_with?("#")
+          path = matches[2]
+
+          original_path = Pathname.new(File.join(path_base, path))
+          replace_path = original_path.relative_path_from(base_path)
+          if use_absolute_paths
+            replace_path = replace_path.expand_path(base_path)
+          end
+                    
+          updated_path_line = line.gsub(/#{regex}/, '\1' + replace_path.to_s + '\3\4')
+          podfile_lines.push(updated_path_line)
+        else
+          podfile_lines.push(line)
+        end
+      end
+
+      File.write(podfile_path, podfile_lines.join)
+    end
   end
 end

data/lib/pod_builder/podfile/post_actions.rb

@@ -128,12 +128,8 @@ module PodBuilder
       end
     end
 
-    def self.find_xcodeproj_targets
-      xcodeprojects = Dir.glob("#{PodBuilder::home}/**/*.xcodeproj").select { |x| !x.include?("/Pods/") && !x.include?(PodBuilder::basepath) }
-      raise "xcdeoproj not found!".red if xcodeprojects.count == 0
-      raise "Found multiple xcdeoprojs:\n#{xcodeprojects.join("\n")}".red if xcodeprojects.count > 1
-      
-      project = Xcodeproj::Project.open(xcodeprojects.first)
+    def self.find_xcodeproj_targets      
+      project = Xcodeproj::Project.open(PodBuilder::find_xcodeproj)
 
       return project.targets
     end

data/lib/pod_builder/podfile_item.rb

@@ -28,7 +28,7 @@ module PodBuilder
 
     # @return [String] Local path, if any
     #
-    attr_reader :path
+    attr_accessor :path
 
     # @return [String] The pinned commit of the pod, if any
     #
@@ -62,6 +62,26 @@ module PodBuilder
     #
     attr_accessor :build_configuration
 
+    # @return [String] The pod's vendored items (frameworks and libraries)
+    #
+    attr_accessor :vendored_items
+
+    # @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 [Bool] Returns true if the source_files key is present
+    #
+    attr_accessor :has_source_files_key
+
     # Initialize a new instance
     #
     # @param [Specification] spec
@@ -81,12 +101,14 @@ module PodBuilder
       @name = spec.name
       @root_name = spec.name.split("/").first
 
-      if checkout_options.has_key?(name)
-        @repo = checkout_options[name][:git]
-        @tag = checkout_options[name][:tag]
-        @commit = checkout_options[name][:commit]
-        @path = checkout_options[name][:path]
-        @branch = checkout_options[name][:branch]
+      checkout_options_keys = [@name, @root_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]
+        @branch = checkout_options[opts_key][:branch]
         @is_external = true
       else
         @repo = spec.root.source[:git]
@@ -94,7 +116,27 @@ module PodBuilder
         @commit = spec.root.source[:commit]
         @is_external = false
       end    
-      
+
+      @vendored_items = recursive_vendored_items(spec)
+
+      @frameworks = []
+      @frameworks += extract_array(spec, "framework")
+      @frameworks += extract_array(spec, "frameworks")
+      @frameworks += extract_array(spec.root, "framework")
+      @frameworks += extract_array(spec.root, "frameworks")
+
+      @weak_frameworks = []
+      @weak_frameworks += extract_array(spec, "weak_frameworks")
+      @weak_frameworks += extract_array(spec, "weak_frameworks")
+      @weak_frameworks += extract_array(spec.root, "weak_frameworks")
+      @weak_frameworks += extract_array(spec.root, "weak_frameworks")
+
+      @libraries = []
+      @libraries += extract_array(spec, "library")
+      @libraries += extract_array(spec, "libraries")
+      @libraries += extract_array(spec.root, "library")
+      @libraries += extract_array(spec.root, "libraries")
+
       @version = spec.root.version.version
       
       @swift_version = spec.root.swift_version&.to_s
@@ -104,22 +146,78 @@ module PodBuilder
 
       @is_static = spec.root.attributes_hash["static_framework"] || false
       @xcconfig = spec.root.attributes_hash["xcconfig"] || {}
+
+      @has_source_files_key = spec.root.attributes_hash.has_key?("source_files") || spec.attributes_hash.has_key?("source_files")
+      
       @build_configuration = spec.root.attributes_hash.dig("pod_target_xcconfig", "prebuild_configuration") || "release"
       @build_configuration.downcase!
     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) }
+      return available_pods.select { |x| @dependency_names.include?(x.name) }
     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
-      @repo.nil? && @path.nil?
+      # We treat pods to skip like prebuilt ones
+      if Configuration.skip_pods.include?(@root_name) || Configuration.skip_pods.include?(@name)
+        return true
+      end
+
+      # checking if there's a vendored_item matching the module name is a pretty good guess for a prebuilt pod.
+      # Still suboptimal, maybe it should be more appropriate to use FileAccessor and check that no source code is provided (no *.{m,mm,c,cpp,swift, etc})
+      if vendored_items.map { |x| File.basename(x) }.include?("#{@module_name}.framework")
+        return true
+      else
+        return !@has_source_files_key && @vendored_items.count > 0
+      end
     end
 
     # @return [Bool] True if it's a subspec
@@ -130,7 +228,7 @@ module PodBuilder
 
     # @return [String] The podfile entry
     #
-    def entry(include_version = true)
+    def entry(include_version = true, include_pb_entry = true)
       e = "pod '#{@name}'"
 
       unless include_version
@@ -138,25 +236,30 @@ module PodBuilder
       end
 
       if is_external
-        if @repo
-          e += ", :git => '#{@repo}'"  
-        end
-        if @tag
-          e += ", :tag => '#{@tag}'"
-        end
-        if @commit
-          e += ", :commit => '#{@commit}'"  
-        end
         if @path
           e += ", :path => '#{@path}'"  
-        end
-        if @branch
-          e += ", :branch => '#{@branch}'"  
+        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
+        e += " # pb<#{name}>"
+      end
+
       return e
     end
 
@@ -165,16 +268,26 @@ module PodBuilder
     end
 
     def prebuilt_rel_path
-      if is_subspec
+      if is_subspec && Configuration.subspecs_to_split.include?(name)
         return "#{name}/#{module_name}.framework"
       else
         return "#{module_name}.framework"
       end
     end
 
-    def prebuilt_entry
-      relative_path = Pathname.new(Configuration.base_path).relative_path_from(Pathname.new(PodBuilder::xcodepath)).to_s
-      return "pod 'PodBuilder/#{podspec_name}', :path => '#{relative_path}'"
+    def prebuilt_entry(include_pb_entry = true)
+      relative_path = Pathname.new(Configuration.base_path).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
+      if Configuration.subspecs_to_split.include?(name)
+        entry = "pod 'PodBuilder/#{podspec_name}', :path => '#{relative_path}'"
+      else
+        entry = "pod 'PodBuilder/#{root_name}', :path => '#{relative_path}'"
+      end
+
+      if include_pb_entry
+        entry += " # pb<#{name}>"
+      end
+
+      return entry
     end
 
     def has_subspec(named)
@@ -203,5 +316,46 @@ module PodBuilder
 
       return nil
     end
+
+    private
+
+    def recursive_vendored_items(spec)
+      items = []
+
+      items += [spec.root.attributes_hash["vendored_frameworks"]]
+      items += [spec.root.attributes_hash["vendored_framework"]]
+      items += [spec.root.attributes_hash["vendored_libraries"]]
+      items += [spec.root.attributes_hash["vendored_library"]]
+
+      items += [spec.attributes_hash["vendored_frameworks"]]
+      items += [spec.attributes_hash["vendored_framework"]]
+      items += [spec.attributes_hash["vendored_libraries"]]
+      items += [spec.attributes_hash["vendored_library"]]
+
+      supported_platforms = spec.available_platforms.flatten.map(&:name).map(&:to_s)
+
+      items += supported_platforms.map { |x| spec.root.attributes_hash.fetch(x, {})["vendored_frameworks"] }
+      items += supported_platforms.map { |x| spec.root.attributes_hash.fetch(x, {})["vendored_framework"] }
+      items += supported_platforms.map { |x| spec.root.attributes_hash.fetch(x, {})["vendored_libraries"] }
+      items += supported_platforms.map { |x| spec.root.attributes_hash.fetch(x, {})["vendored_library"] }
+
+      items += supported_platforms.map { |x| spec.attributes_hash.fetch(x, {})["vendored_frameworks"] }
+      items += supported_platforms.map { |x| spec.attributes_hash.fetch(x, {})["vendored_framework"] }
+      items += supported_platforms.map { |x| spec.attributes_hash.fetch(x, {})["vendored_libraries"] }
+      items += supported_platforms.map { |x| spec.attributes_hash.fetch(x, {})["vendored_library"] }
+
+      items = items.flatten.compact
+
+      return items.flatten
+    end
+
+    def extract_array(spec, key)
+      element = spec.attributes_hash.fetch(key, [])
+      if element.instance_of? String
+        element = [element]
+      end
+
+      return element
+    end
   end
 end