pod-builder 1.9.4 → 2.0.0.beta.18

data/lib/pod_builder/podfile_item.rb

@@ -1,5 +1,3 @@
-require 'pod_builder/cocoapods/specification'
-
 module PodBuilder
   class PodfileItem
     # @return [String] The git repo
@@ -10,6 +8,10 @@ module PodBuilder
     #
     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
@@ -49,6 +51,10 @@ module PodBuilder
     # @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 framework
     #
@@ -66,9 +72,13 @@ module PodBuilder
     #
     attr_accessor :build_configuration
 
-    # @return [String] The pod's vendored items (frameworks and libraries)
+    # @return [String] The pod's vendored frameworks
     #
-    attr_accessor :vendored_items
+    attr_accessor :vendored_frameworks
+
+    # @return [String] The pod's vendored libraries
+    #
+    attr_accessor :vendored_libraries
 
     # @return [String] Framweworks the pod needs to link to
     #
@@ -86,25 +96,42 @@ module PodBuilder
     #
     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
+    
     # Initialize a new instance
     #
     # @param [Specification] spec
     #
     # @param [Hash] checkout_options
     #
-    def initialize(spec, all_specs, checkout_options)
-      if overrides = Configuration.spec_overrides[spec.name]
-        overrides.each do |k, v|
-          spec.root.attributes_hash[k] = v
-          if checkout_options.has_key?(spec.name)
-            checkout_options[spec.name][k] = v
-          end
-        end
-      end
-
+    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) }
@@ -120,22 +147,22 @@ module PodBuilder
         @commit = spec.root.source[:commit]
         @is_external = false
       end    
-
-      @vendored_items = recursive_vendored_items(spec, all_specs)
+      
+      @vendored_frameworks = extract_vendored_frameworks(spec, all_specs)
+      @vendored_libraries = extract_vendored_libraries(spec, all_specs)
 
       @frameworks = []
       @weak_frameworks = []
       @libraries = []
-      spec_and_dependencies(spec, all_specs).each do |spec|
-        @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")  
-      end
+      @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")  
 
       @version = spec.root.version.version
       @available_versions = spec.respond_to?(:spec_source) ? spec.spec_source.versions(@root_name)&.map(&:to_s) : [@version]
@@ -143,7 +170,18 @@ module PodBuilder
       @swift_version = spec.root.swift_version&.to_s
       @module_name = spec.root.module_name
 
-      @dependency_names = spec.recursive_dep_names(all_specs)
+      @default_subspecs = extract_array(spec, "default_subspecs")
+      if default_subspec = spec.attributes_hash["default_subspec"]
+        @default_subspecs.push(default_subspec)
+      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"] || {}
@@ -152,6 +190,13 @@ module PodBuilder
       
       @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)
@@ -204,6 +249,43 @@ module PodBuilder
       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 framework
+      # 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) }
+
+      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
@@ -218,14 +300,17 @@ module PodBuilder
 
       # 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
-      vendored_items_paths = vendored_items.map { |x| File.basename(x) }
-      embedded_as_vendored = vendored_items_paths.include?("#{@module_name}.framework")
-      embedded_as_static_lib = vendored_items_paths.any? { |x| x.match(/#{module_name}.*\\.a/) != nil }
+      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_items.count > 0
+      no_sources = (@source_files.count == 0 || only_headers) && (@vendored_frameworks + @vendored_libraries).count > 0
 
-      return embedded_as_static_lib || embedded_as_vendored || only_headers || no_sources
+      if !no_sources && !only_headers
+        return false
+      else
+        return embedded_as_static_lib || embedded_as_vendored
+      end
     end
 
     # @return [Bool] True if it's a subspec
@@ -271,7 +356,7 @@ module PodBuilder
       end
 
       if include_pb_entry && !is_prebuilt
-        plists = Dir.glob(PodBuilder::basepath("Rome/**/#{module_name}.framework/#{Configuration::framework_plist_filename}"))
+        plists = Dir.glob(PodBuilder::prebuiltpath("**/#{module_name}.framework/#{Configuration::framework_plist_filename}"))
         if plists.count > 0
           plist = CFPropertyList::List.new(:file => plists.first)
           data = CFPropertyList.native_types(plist.value)
@@ -302,15 +387,18 @@ module PodBuilder
       end
     end
 
-    def prebuilt_entry(include_pb_entry = true)
-      relative_path = Pathname.new(Configuration.base_path).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
+    def prebuilt_entry(include_pb_entry = true, absolute_path = false)
+      if absolute_path 
+        pod_path = PodBuilder::prebuiltpath
+      else
+        pod_path = Pathname.new(Configuration.base_path).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
+        pod_path += "/Rome"
+      end
 
       if Configuration.subspecs_to_split.include?(name)
-        entry = "pod 'PodBuilder/#{podspec_name}', :path => '#{relative_path}'"
-      elsif override_name = Configuration.spec_overrides.dig(name, "module_name")
-        entry = "pod 'PodBuilder/#{override_name}', :path => '#{relative_path}'"
+        entry = "pod '#{podspec_name}', :path => '#{pod_path}'"
       else
-        entry = "pod 'PodBuilder/#{root_name}', :path => '#{relative_path}'"
+        entry = "pod '#{name}', :path => '#{pod_path}'"
       end
 
       if include_pb_entry && !is_prebuilt
@@ -337,45 +425,48 @@ module PodBuilder
     end
 
     def vendored_framework_path
-      if File.exist?(PodBuilder::basepath(vendored_subspec_framework_path))
-        return vendored_subspec_framework_path
-      elsif File.exist?(PodBuilder::basepath(vendored_spec_framework_path))
-        return vendored_spec_framework_path
+      if File.exist?(PodBuilder::prebuiltpath(vendored_subspec_framework_name))
+        return vendored_subspec_framework_name
+      elsif File.exist?(PodBuilder::prebuiltpath(vendored_spec_framework_name))
+        return vendored_spec_framework_name
       end
       
       return nil
     end
     
-    def vendored_subspec_framework_path
-      return "Rome/#{prebuilt_rel_path}"
+    def vendored_subspec_framework_name
+      return "#{prebuilt_rel_path}"
     end
     
-    def vendored_spec_framework_path
-      return "Rome/#{module_name}.framework"
-    end
-
-    def self.vendored_name_framework_path(name)
-      return "Rome/#{name}"
+    def vendored_spec_framework_name
+      return "#{module_name}.framework"
     end
 
     private
 
-    def recursive_vendored_items(spec, all_specs)
+    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"]]
 
-      spec_and_dependencies(spec, all_specs).each do |spec|
-        items += [spec.attributes_hash["vendored_frameworks"]]
-        items += [spec.attributes_hash["vendored_framework"]]
-        items += [spec.attributes_hash["vendored_libraries"]]
-        items += [spec.attributes_hash["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_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"] }  
-      end
+      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
@@ -429,18 +520,5 @@ module PodBuilder
 
       return source_files + root_source_files + subspec_source_files
     end
-
-    def spec_and_dependencies(spec, all_specs)
-      specs = all_specs.select { |x| spec.dependencies.map(&:name).include?(x.name) }
-      specs += all_specs.select { |x| spec.default_subspecs.any? { |y| x.name == "#{spec.name}/#{y}" } }
-      specs += [spec, spec.root].flatten.uniq
-
-      all_remaining_specs = all_specs.reject { |x| specs.map(&:name).include?(x.name) } 
-      if all_remaining_specs.count < all_specs.count
-        specs += specs.reject { |x| x == spec }.map { |x| spec_and_dependencies(x, all_remaining_specs) }
-      end
-      
-      return specs.flatten.compact.uniq
-    end
   end
 end

data/lib/pod_builder/podspec.rb

@@ -1,38 +1,5 @@
 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 +7,167 @@ 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)
+      generate_podspec_from(all_buildable_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)
+      return File.exist?(PodBuilder::prebuiltpath("#{pod_name}.podspec"))
     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
+        vendored_frameworks = item.vendored_frameworks + ["#{item.module_name}.framework"]
+        existing_vendored_frameworks = vendored_frameworks.select { |t| File.exist?(PodBuilder::prebuiltpath(t) || "") }
+        existing_vendored_frameworks_basename = vendored_frameworks.map { |t| File.basename(t) }.select { |t| File.exist?(PodBuilder::prebuiltpath(t) || "") }
+        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 { |t| File.exist?(PodBuilder::prebuiltpath(t) || "") }
+        existing_vendored_libraries_basename = vendored_libraries.map { |t| File.basename("#{item.module_name}/#{t}") }.select { |t| File.exist?(PodBuilder::prebuiltpath(t) || "") }
+        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.select! { |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
+        exclude_files += frameworks.map { |x| x.vendored_framework_path.nil? ? nil : "#{x.vendored_framework_path}/#{Configuration.framework_plist_filename}" }.compact.flatten.uniq.sort
+          
         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"
-        end
-        non_prebuilt_dependencies.each do |non_prebuilt_dependency|
-          podspec += "    p.dependency '#{non_prebuilt_dependency.name}'\n"
-        end
-
-        podspec += "  end"
-        
-        podspecs.push(podspec)
-      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)
-    end
-
-    def self.podspec_items_from(buildable_items)
-      podspec_items = []
-
-      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
-          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
-        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
-
-        # Merge xcconfigs
-        if !pod.xcconfig.empty?
-          pod.xcconfig.each do |k, v|
+          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 = podspec_item.xcconfig[k]
+  
+            if podspec_values = 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
+            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
+  
+        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_item.dependencies = buildable_items.select { |x| pod.dependency_names.include?(x.name) }
+        valid = valid || vendored_frameworks.count > 0
       end
+      
+      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
 
-      return podspec_items
+        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.generate_podspec_from(all_buildable_items, platform)
+      specs = Dir.glob(PodBuilder::prebuiltpath("*.podspec"))
+      specs.each do |s| 
+        FileUtils.rm(s)
+      end
+
+      all_buildable_items.each do |item|  
+        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
+
+        podspec = "Pod::Spec.new do |p1|\n"
+
+        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"
+
+        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 += main_keys
+        podspec += "end"
+
+        spec_path = PodBuilder::prebuiltpath("#{item.root_name}.podspec")
+        File.write(spec_path, podspec)
+      end
     end
   end
 end