pod-builder 1.9.2 → 2.0.0.beta.21

data/lib/pod_builder/podfile/post_actions.rb

@@ -1,29 +1,23 @@
-require 'colored'
 require 'xcodeproj'
 require 'pod_builder/core'
 
 module PodBuilder
   class Podfile
-    def self.remove_target_support_duplicate_entries
-      puts "[PodBuilder] Removing target support duplicated entries".yellow
-      
+    def self.pod_builder_post_process
       Configuration.load
-      
+
+      targets = find_xcodeproj_targets
+      target_names = targets.map(&:name)
+
+      puts "[PodBuilder] Removing target support duplicated entries".yellow
       # Frameworks and resources
-      find_xcodeproj_targets.map(&:name).each do |target|
+      target_names.each do |target|
         remove_duplicate_entries("Pods/Target Support Files/Pods-#{target}/Pods-#{target}-frameworks.sh")
         remove_duplicate_entries("Pods/Target Support Files/Pods-#{target}/Pods-#{target}-resources.sh")
       end
-    end
 
-    def self.check_target_support_resource_collisions
       puts "[PodBuilder] Checking target support resource collisions".yellow
-
-      Configuration.load
-
-      targets = find_xcodeproj_targets
-
-      targets.map(&:name).each do |target|
+      target_names.each do |target|
         check_for_colliding_resources("Pods/Target Support Files/Pods-#{target}/Pods-#{target}-resources.sh", target, targets)
       end
     end
@@ -75,7 +69,7 @@ module PodBuilder
         resource_files = resource_files.map { |i| File.basename(i) }
         resource_files = resource_files.map { |i| i.gsub(".xib", ".nib") }
       else
-        raise "#{target} not found!".red
+        raise "\n\n#{target} not found!".red
       end
       
       # Check that Pods-TARGET-resources.sh doesn't contain colliding entries (Cocoapods 1.4.0)

data/lib/pod_builder/podfile_cp.rb

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

data/lib/pod_builder/podfile_item.rb

@@ -1,4 +1,5 @@
-require 'pod_builder/cocoapods/specification'
+# This class is the model that PodBuilder uses for every pod spec. The model is instantiated
+# from Pod::Specification
 
 module PodBuilder
   class PodfileItem
@@ -10,6 +11,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
@@ -34,6 +39,10 @@ module PodBuilder
     #
     attr_accessor :path
 
+    # @return [String] Local podspec path, if any
+    #
+    attr_accessor :podspec_path
+
     # @return [String] The pinned commit of the pod, if any
     #
     attr_reader :commit
@@ -49,8 +58,12 @@ 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
+    # @return [Bool] True if the pod is shipped as a static binary
     #
     attr_reader :is_static
     
@@ -66,9 +79,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_frameworks
+
+    # @return [String] The pod's vendored libraries
     #
-    attr_accessor :vendored_items
+    attr_accessor :vendored_libraries
 
     # @return [String] Framweworks the pod needs to link to
     #
@@ -86,25 +103,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) }
@@ -112,6 +146,7 @@ module PodBuilder
         @tag = checkout_options[opts_key][:tag]
         @commit = checkout_options[opts_key][:commit]
         @path = checkout_options[opts_key][:path]
+        @podspec_path = checkout_options[opts_key][:podspec]
         @branch = checkout_options[opts_key][:branch]
         @is_external = true
       else
@@ -120,22 +155,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 +178,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 +198,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 +257,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 item
+      # Ex. 
+      # PodA depends on DepA/subspec1
+      # PodB depends on DepA/subspec2
+      #
+      # When building PodA we need to build both DepA subspecs because they might 
+      # contain different code
+      deps += available_pods.select { |t| root_names.include?(t.root_name) }
+
+      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 +308,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 (no_sources || only_headers || embedded_as_static_lib || embedded_as_vendored)
+      end
     end
 
     # @return [Bool] True if it's a subspec
@@ -252,6 +345,8 @@ module PodBuilder
       if is_external
         if @path
           e += ", :path => '#{@path}'"  
+        elsif @podspec_path
+          e += ", :podspec => '#{@podspec_path}'"  
         else
           if @repo
             e += ", :git => '#{@repo}'"  
@@ -271,10 +366,9 @@ module PodBuilder
       end
 
       if include_pb_entry && !is_prebuilt
-        plists = Dir.glob(PodBuilder::basepath("Rome/**/#{module_name}.framework/#{Configuration::framework_plist_filename}"))
-        if plists.count > 0
-          plist = CFPropertyList::List.new(:file => plists.first)
-          data = CFPropertyList.native_types(plist.value)
+        prebuilt_info_path = PodBuilder::prebuiltpath("#{root_name}/#{Configuration::prebuilt_info_filename}")
+        if File.exist?(prebuilt_info_path)
+          data = JSON.parse(File.read(prebuilt_info_path))
           swift_version = data["swift_version"]
           is_static = data["is_static"] || false
         
@@ -302,15 +396,22 @@ 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_podspec_path(absolute_path = true)
+      podspec_path = PodBuilder::prebuiltpath("#{@root_name}/#{@root_name}.podspec")
+      if absolute_path 
+        return podspec_path
+      else
+        pod_path = Pathname.new(podspec_path).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
+      end
+    end
+
+    def prebuilt_entry(include_pb_entry = true, absolute_path = false)
+      podspec_dirname = File.dirname(prebuilt_podspec_path(absolute_path = absolute_path))
 
       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 => '#{podspec_dirname}'"
       else
-        entry = "pod 'PodBuilder/#{root_name}', :path => '#{relative_path}'"
+        entry = "pod '#{name}', :path => '#{podspec_dirname}'"
       end
 
       if include_pb_entry && !is_prebuilt
@@ -337,45 +438,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("#{root_name}/#{vendored_subspec_framework_name}"))
+        return vendored_subspec_framework_name
+      elsif File.exist?(PodBuilder::prebuiltpath("#{root_name}/#{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
@@ -390,18 +494,26 @@ module PodBuilder
     end
 
     def source_files_from_string(source)
+      # Transform source file entries 
+      # "Networking{Response,Request}*.{h,m}" -> ["NetworkingResponse*.h", "NetworkingResponse*.m", "NetworkingRequest*.h", "NetworkingRequest*.m"]
       files = []
       if source.is_a? String 
-        matches = source.match(/(.*)({(.),?(.)?})/)
-        if matches&.size == 5
-          source = matches[1] + matches[3]
-          if matches[4].length > 0
-            source += "," + matches[1] + matches[4]
+        matches = source.match(/(.*){(.*)}(.*)/)
+        if matches&.size == 4
+          res = matches[2].split(",").map { |t| "#{matches[1]}#{t}#{matches[3]}" }
+          if res.any? { |t| t.include?("{") }
+            return res.map { |t| source_files_from_string(t) }.flatten
           end
+  
+          return res
         end
 
         return source.split(",")
       else
+        if source.any? { |t| t.include?("{") }
+          return source.map { |t| source_files_from_string(t) }.flatten
+        end
+
         return source
       end
     end
@@ -429,18 +541,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