pod-builder 0.1.4

data/lib/pod_builder/core.rb

@@ -0,0 +1,74 @@
+require 'cocoapods'
+require 'fileutils'
+require 'colored'
+
+require 'pod_builder/podfile'
+require 'pod_builder/podfile_item'
+require 'pod_builder/analyze'
+require 'pod_builder/install'
+require 'pod_builder/configuration'
+require 'pod_builder/podspec'
+
+module PodBuilder  
+  def self.safe_rm_rf(path)
+    unless File.exist?(path)
+      return
+    end
+
+    current_dir = Dir.pwd
+
+    Dir.chdir(path)
+
+    h = `git rev-parse --show-toplevel`.strip()
+    raise "\n\nNo git repository found, can't delete files!\n".red if h.empty?
+
+    FileUtils.rm_rf(path)
+
+    if File.exist?(current_dir)
+      Dir.chdir(current_dir)
+    else
+      Dir.chdir(basepath)
+    end
+  end
+
+  def self.home
+    h = `git rev-parse --show-toplevel`.strip()
+    raise "\n\nNo git repository found in current folder `#{Dir.pwd}`!\n".red if h.empty?
+    return h
+  end
+  
+  def self.basepath(child = "")
+    return "#{Configuration.base_path}/#{child}".gsub("//", "/").gsub(/\/$/, '')
+  end
+  
+  def self.xcodepath(child = "")
+    project = PodBuilder::find_xcodeproject
+    
+    return project ? "#{File.dirname(project)}/#{child}".gsub("//", "/").gsub(/\/$/, '') : nil
+  end
+
+  def self.find_xcodeproject
+    return Dir.glob("#{home}/**/*.xcodeproj").detect { |x| !x.include?("Pods.xcodeproj") && !x.include?(basepath) }
+  end
+
+  def self.find_xcodeworkspace
+    return Dir.glob("#{home}/**/*.xcworkspace").detect { |x| !x.include?("Pods.xcworkspace") && !x.include?(basepath) }
+  end
+
+  def self.prepare_basepath
+    project = PodBuilder::find_xcodeproject
+    if project
+      FileUtils.mkdir_p(basepath("Pods/Target Support Files"))
+      FileUtils.cp_r(project, basepath)   
+      FileUtils.rm_f(basepath("Podfile.lock"))
+    end
+  end
+
+  def self.clean_basepath
+    project = PodBuilder::find_xcodeproject
+    if project
+      PodBuilder::safe_rm_rf(basepath(File.basename(project)))
+      PodBuilder::safe_rm_rf(basepath("Pods"))
+    end
+  end
+end

data/lib/pod_builder/install.rb

@@ -0,0 +1,105 @@
+
+module PodBuilder
+  class Install
+    def self.podfile(podfile_content, podfile_items, build_configuration)
+      PodBuilder::safe_rm_rf(Configuration.build_path)
+      FileUtils.mkdir_p(Configuration.build_path)
+      
+      init_git(Configuration.build_path) # this is needed to be able to call safe_rm_rf
+
+      File.write("#{Configuration.build_path}/Podfile", podfile_content)
+
+      begin  
+        lock_file = "#{Configuration.build_path}/pod_builder.lock"
+        FileUtils.touch(lock_file)
+  
+        install
+        
+        cleanup_frameworks(podfile_items)
+        copy_frameworks(podfile_items)
+        if build_configuration != "debug"
+          copy_dsyms(podfile_items)
+        end
+      rescue Exception => e
+        raise e
+      ensure
+        FileUtils.rm(lock_file)
+      end
+    end
+
+    private 
+
+    def self.install
+      CLAide::Command::PluginManager.load_plugins("cocoapods")
+
+      current_dir = Dir.pwd
+      
+      Dir.chdir(Configuration.build_path)
+
+      config = Pod::Config.new()
+      installer = Pod::Installer.new(config.sandbox, config.podfile, config.lockfile)
+      installer.repo_update = false
+      installer.update = false
+      installer.install!  
+
+      Dir.chdir(current_dir)
+    end
+
+    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 }
+        return "#{podfile_item.prebuilt_rel_path}"
+      else
+        return framework_name
+      end
+    end
+
+    def self.cleanup_frameworks(podfile_items)
+      Dir.glob("#{Configuration.build_path}/Rome/*.framework") do |framework_path|
+        framework_rel_path = framework_rel_path(framework_path, podfile_items)
+        dsym_path = framework_rel_path + ".dSYM"
+
+        PodBuilder::safe_rm_rf(PodBuilder::basepath("Rome/#{framework_rel_path}"))
+        PodBuilder::safe_rm_rf(PodBuilder::basepath("dSYM/iphoneos/#{dsym_path}"))
+        PodBuilder::safe_rm_rf(PodBuilder::basepath("dSYM/iphonesimulator/#{dsym_path}"))
+      end
+    end
+
+    def self.copy_frameworks(podfile_items)
+      Dir.glob("#{Configuration.build_path}/Rome/*.framework") do |framework_path|
+        framework_rel_path = framework_rel_path(framework_path, podfile_items)
+
+        destination_path = PodBuilder::basepath("Rome/#{framework_rel_path}")
+        FileUtils.mkdir_p(File.dirname(destination_path))
+        FileUtils.cp_r(framework_path, destination_path)
+      end
+    end
+
+    def self.copy_dsyms(podfile_items)
+      Dir.glob("#{Configuration.build_path}/build/*iphoneos/**/*.dSYM") do |dsym_path|
+        framework_rel_path = framework_rel_path(dsym_path.gsub(File.extname(dsym_path), ""), podfile_items)
+        
+        destination_path = PodBuilder::basepath("dSYM/iphoneos/#{File.dirname(framework_rel_path)}") 
+        FileUtils.mkdir_p(destination_path)
+        FileUtils.cp_r(dsym_path, destination_path)
+      end
+
+      Dir.glob("#{Configuration.build_path}/build/*iphonesimulator/**/*.dSYM") do |dsym_path|
+        framework_rel_path = framework_rel_path(dsym_path.gsub(File.extname(dsym_path), ""), podfile_items)
+
+        destination_path = PodBuilder::basepath("dSYM/iphonesimulator/#{File.dirname(framework_rel_path)}") 
+        FileUtils.mkdir_p(destination_path)
+        FileUtils.cp_r(dsym_path, destination_path)
+      end
+    end
+
+    def self.init_git(path)
+      current_dir = Dir.pwd
+
+      Dir.chdir(path)
+      system("git init")
+      Dir.chdir(current_dir)
+    end
+  end
+end

data/lib/pod_builder/podfile.rb

@@ -0,0 +1,207 @@
+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')"]
+
+    def self.from_podfile_items(items, analyzer)
+      raise "no items" unless items.count > 0
+
+      sources = analyzer.sources
+      
+      cwd = File.dirname(File.expand_path(__FILE__))
+      podfile = File.read("#{cwd}/templates/build_podfile.template")
+      
+      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 = ""
+      items.each do |item|
+        build_settings['SWIFT_VERSION'] = item.swift_version || project_swift_version(analyzer)
+        if swift_optimization_level = item.swift_optimization_level
+          build_settings['SWIFT_OPTIMIZATION_LEVEL'] = swift_optimization_level
+        end
+
+        podfile_build_settings += "set_build_settings(\"#{item.root_name}\", #{build_settings.to_s}, installer)\n  "
+      end
+
+      podfile.sub!("%%%build_settings%%%", podfile_build_settings)
+
+      podfile.sub!("%%%build_system%%%", Configuration.build_system)
+
+      podfile.sub!("%%%pods%%%", "\"#{items.map(&:name).join('", "')}\"")
+      
+      podfile.sub!("%%%dependencies%%%", "\"#{items.map(&:dependency_names).flatten.uniq.join("\",\"")}\"")
+      
+      podfile.sub!("%%%targets%%%", items.map(&:entry).join("\n  "))
+
+      return podfile
+    end
+
+    def self.write_restorable(updated_pods, podfile_items, analyzer)
+      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 }
+            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)
+
+            # dependecies should be listed first
+            current_target_pods = (target_dependencies + target_pods).uniq
+
+            # 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)
+
+            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
+        end
+      end
+
+      podfile_content = destination_lines.join
+      File.write(podfile_restore_path, podfile_content)
+    end
+
+    def self.update_prebuilt(updated_pods, podfile_items, analyzer)
+      project_podfile_path = PodBuilder::xcodepath("Podfile")
+
+      podfile_content = File.read(project_podfile_path)
+
+      stripped_prebuilt_entries = (updated_pods + podfile_items).map(&:prebuilt_entry).map { |x| strip_line(x) }
+      podfile_items_name = podfile_items.map(&:name)
+
+      destination_lines = []
+      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
+          end
+        end
+
+        destination_lines.push(line)
+      end
+
+      # remove adiacent duplicated entries
+      destination_lines = destination_lines.chunk { |x| x }.map(&:first)
+
+      podfile_content = destination_lines.join
+      File.write(project_podfile_path, podfile_content)
+    end
+
+    def self.deintegrate_install
+      current_dir = Dir.pwd
+
+      Dir.chdir(PodBuilder::xcodepath)
+      system("pod deintegrate; pod install;")
+      Dir.chdir(current_dir)
+    end
+
+    def self.strip_line(line)
+      stripped_line = line.dup
+      return stripped_line.gsub("\"", "'").gsub(" ", "").gsub("\n", "")
+    end
+
+    private
+
+    def self.pod_definition_in(line, include_commented)
+      stripped_line = strip_line(line)
+      matches = stripped_line.match(/(pod')(.*?)(')/)
+      
+      if matches&.size == 4 && (include_commented || !stripped_line.start_with?("#"))
+        return matches[2]
+      else
+        return nil
+      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
+      end
+    end
+
+    def self.project_swift_version(analyzer)
+      swift_versions = analyzer.result.target_inspections.values.map { |x| x.target_definition.swift_version }.uniq
+
+      raise "Found different Swift versions in targets. Expecting one, got `#{swift_versions}`" if swift_versions.count != 1
+
+      return swift_versions.first
+    end
+
+    def self.podfile_items_at(podfile_path)
+      raise "Expecting basepath folder!" if !File.exist?(PodBuilder::basepath("Podfile"))
+
+      if File.basename(podfile_path) != "Podfile"
+        File.rename(PodBuilder::basepath("Podfile"), PodBuilder::basepath("Podfile.tmp"))
+        FileUtils.cp(podfile_path, PodBuilder::basepath("Podfile"))
+      end
+
+      current_dir = Dir.pwd
+      Dir.chdir(File.dirname(podfile_path))
+
+      buildable_items = []
+      begin
+        installer, analyzer = Analyze.installer_at(PodBuilder::basepath)
+      
+        podfile_items = Analyze.podfile_items(installer, analyzer)
+        buildable_items = podfile_items.select { |item| item.is_prebuilt == false }   
+      rescue Exception => e
+        raise e
+      ensure
+        Dir.chdir(current_dir)
+      
+        if File.basename(podfile_path) != "Podfile"
+          File.rename(PodBuilder::basepath("Podfile.tmp"), PodBuilder::basepath("Podfile"))
+        end  
+      end
+
+      return buildable_items
+    end
+  end
+end

data/lib/pod_builder/podfile/post_actions.rb

@@ -0,0 +1,141 @@
+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
+      # Frameworks and resources
+      find_xcodeproj_targets.map(&:name).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
+
+      targets = find_xcodeproj_targets
+
+      targets.map(&:name).each do |target|
+        check_for_colliding_resources("Pods/Target Support Files/Pods-#{target}/Pods-#{target}-resources.sh", target, targets)
+      end
+    end
+
+    private
+
+    def self.remove_duplicate_entries(path)
+      if !File.file?(path)
+        return
+      end
+      
+      # Adding the same pod to multiple targets results in duplicate entries in Pods-TARGET-frameworks.sh and Pods-TARGET-resources.sh (Cocoapods 1.4.0)
+      # To avoid conflicts during parallel codesign we manually remove duplicates
+      in_section_to_update = false
+      processed_entries = []
+      lines = []
+      File.read(path).each_line do |line|
+        stripped_line = line.strip()
+        next if stripped_line.empty?
+
+        if stripped_line.include?("if [[ \"$CONFIGURATION\" == ")
+          in_section_to_update = true
+        elsif stripped_line == "fi"
+          in_section_to_update = false
+          processed_entries = []
+        end
+        if in_section_to_update
+          if processed_entries.include?(stripped_line)
+            if !line.include?("#")
+              line = "# #{line}"
+            end
+          end
+          processed_entries.push(stripped_line)
+        end
+        
+        lines.push(line)
+      end
+      
+      File.write(path, lines.join)
+    end
+
+    def self.check_for_colliding_resources(path, target_name, targets)
+      if !File.file?(path)
+        return
+      end
+
+      if target = targets.detect { |x| x.name == target_name }
+        resource_files = target.resources_build_phase.files.map { |i| i.file_ref.real_path.to_s }.to_set
+        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
+      end
+      
+      # Check that Pods-TARGET-resources.sh doesn't contain colliding entries (Cocoapods 1.4.0)
+      in_section_to_update = false
+      processed_entries = []
+      File.read(path).each_line do |line|
+        stripped_line = line.strip()
+        next if stripped_line.empty?
+        
+        if stripped_line.include?("if [[ \"$CONFIGURATION\" == ")
+          in_section_to_update = true
+          next
+        elsif stripped_line == "fi"
+          in_section_to_update = false
+          
+          processed_entries.each do |entry|
+            matches_other_framework = processed_entries.select { |t| t[0] == entry[0] }
+            
+            # Check for static framework cross-collisions
+            if matches_other_framework.count > 1
+              error = "\n\nCross-framework resource collision detected:\n"
+              error += "#{entry[0]} found in\n"
+              error += matches_other_framework.map { |x| "- #{x[1]}" }.join("\n")
+              error += "\n\n"
+              
+              raise error.red
+            end
+            
+            # Check for collisions with app's resources
+            matches_app_resources = resource_files.select { |t| t == entry[0] }
+            if matches_app_resources.count > 0
+              error = "\n\nResource collision with app file detected:\n"
+              error += "#{entry[0]} found in app but also in\n"
+              error += matches_app_resources.map { |x| "- #{x[1]}" }.join("\n")
+              error += "\n\n"
+              
+              raise error.red
+            end
+          end
+          
+          processed_entries = []
+        end
+        
+        next if stripped_line.start_with?("#") # skip commented lines
+        next if stripped_line.count("/..") > 2 # skip development pods
+        
+        line.gsub!("\"", "")
+        line.gsub!("install_resource", "")
+        line.strip!()
+        
+        if in_section_to_update
+          filename = File.basename(line)
+          processed_entries.push([filename, line])
+        end
+      end
+    end
+
+    def self.find_xcodeproj_targets
+      xcodeprojects = Dir.glob("#{PodBuilder::home}/**/*.xcodeproj").select { |x| !x.include?("Pods.xcodeproj") && !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)
+
+      return project.targets
+    end
+  end
+end