pod-builder 0.1.4

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+task :default => :spec

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require 'pod_builder/core'
+require 'pod_builder/version'
+require 'pod_builder/command'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/pod_builder

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+
+if ENV['RUBYLIB']
+  puts "Running in debug, injecting $LOAD_PATH"
+  libdir = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+  $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+end
+
+require 'optparse'
+require 'pod_builder/core'
+require 'pod_builder/version'
+require 'pod_builder/command'
+
+OPTIONS = {}  
+
+def parse_commandline()  
+  subcommands = {  
+    "none" => {
+      :opts => OptionParser.new do |opts|
+        opts.banner = "
+Usage:
+        
+    $ pod_builder COMMAND 
+
+      Prebuild CocoaPods pods
+        
+Command:
+    + init                           Initialize prebuild folders
+    + deintegrate                    Deintegrate prebuild folders
+    + build                          Build a specific pod declared in your Frameworks/Podfile
+    + build_all                      Build all pods declared in your Frameworks/Podfile
+    + restore_all                    Rebuild all pods declared in the Frameworks/Podfile.restore    
+    + install_sources                Install sources of pods to debug into prebuild frameworks
+    + clean                          Remove prebuild frameworks, dSYMs and source files added by install_sources no longer in Frameworks/Podfile
+
+Options:
+"
+        opts.on("-v", "--version", "Show the version of the tool") do |o|
+          OPTIONS[:version] = o
+        end
+      end,
+      :call => [
+        PodBuilder::Command::None
+      ]  
+    },
+
+    "build" => {
+      :opts => OptionParser.new do |opts|
+        opts.banner = "
+Usage:
+        
+    $ pod_builder build <PODNAME...>
+
+      Prebuild the specified CocoaPods pods
+        
+Options:
+"        
+        opts.on("-u", "--update", "Update CocoaPods repos") do |o|
+          OPTIONS[:update_repos] = o
+        end
+        opts.on("-d", "--debug", "Don't clean build folder") do |o|
+          OPTIONS[:debug] = o
+        end
+      end,
+      :call => [
+        PodBuilder::Command::Build
+      ]
+    },
+
+    "build_all" => {
+      :opts => OptionParser.new do |opts|
+        opts.on("-u", "--update", "Update CocoaPods repos") do |o|
+          OPTIONS[:update_repos] = o
+        end
+        opts.on("-d", "--debug", "Don't clean build folder") do |o|
+          OPTIONS[:debug] = o
+        end
+      end,
+      :call => [
+        PodBuilder::Command::BuildAll
+      ]
+    },
+
+    "restore_all" => {
+      :opts => OptionParser.new do |opts|
+        opts.on("-u", "--update", "Update CocoaPods repos") do |o|
+          OPTIONS[:update_repos] = o
+        end
+        opts.on("-d", "--debug", "Don't clean build folder") do |o|
+          OPTIONS[:debug] = o
+        end
+      end,
+      :call => [
+        PodBuilder::Command::RestoreAll
+      ]
+    },
+
+    "init" => {
+      :opts => OptionParser.new do |opts|
+        default_destination = PodBuilder::xcodepath(PodBuilder::Configuration.base_path)
+
+        opts.on("-d", "--destination path", "Prebuilt destination path (defaul: #{default_destination})") do |o|
+          OPTIONS[:prebuild_path] = o
+        end
+      end,
+      :call => [        
+        PodBuilder::Command::Init
+      ]
+    },
+
+    "generate_podspec" => {
+      :opts => OptionParser.new do |opts|
+      end,
+      :call => [        
+        PodBuilder::Command::GeneratePodspec
+      ]
+    },
+
+    "deintegrate" => {
+      :opts => OptionParser.new do |opts|
+      end,
+      :call => [        
+        PodBuilder::Command::Deintegrate
+      ]
+    },
+
+    "clean" => {
+      :opts => OptionParser.new do |opts|
+      end,
+      :call => [        
+        PodBuilder::Command::Clean
+      ]
+    },
+
+    "install_sources" => {
+      :opts => OptionParser.new do |opts|
+      end,
+      :call => [        
+        PodBuilder::Command::InstallSources
+      ]
+    }    
+  }
+   
+  subcommands["none"][:opts].order!
+   
+  subcommand = subcommands[ARGV.shift]
+   
+  if subcommand  
+    subcommand[:opts].order!
+    subcommand[:call].each do |k|
+      if !k.call(OPTIONS)
+        puts subcommand[:opts].help
+      end
+    end
+  else  
+    if !subcommands["none"][:call].first&.call(OPTIONS)
+      puts subcommands["none"][:opts].help
+    end
+  end
+end
+
+begin
+  unless ENV['USER'] != "root"
+    raise "\n\nFor safety do not run this as root\n".red
+  end
+
+  PodBuilder::Configuration.load
+  parse_commandline
+ensure
+  PodBuilder::clean_basepath
+  if !OPTIONS.has_key?(:debug)
+    PodBuilder::safe_rm_rf(PodBuilder::Configuration.build_path)
+  end
+end

data/lib/pod_builder/analyze.rb

@@ -0,0 +1,52 @@
+require 'pod_builder/cocoapods/specification'
+
+module PodBuilder
+  class Analyze
+    # @return [Pod::Installer] The Pod::Installer instance created by processing the Podfile
+    #
+    def self.installer_at(path, repo_update = false)
+      CLAide::Command::PluginManager.load_plugins("cocoapods")
+
+      current_dir = Dir.pwd
+      Dir.chdir(path)
+
+      config = Pod::Config.new()
+      installer = Pod::Installer.new(config.sandbox, config.podfile, config.lockfile)
+      installer.repo_update = repo_update
+      installer.update = false 
+
+      analyzer = installer.resolve_dependencies
+
+      Dir.chdir(current_dir)
+
+      return installer, analyzer
+    end
+    
+    # @return [Array<PodfileItem>] The PodfileItem in the Podfile (including subspecs) and dependencies
+    #
+    def self.podfile_items(installer, analyzer)
+      sandbox = installer.sandbox
+      analysis_result = installer.analysis_result
+      
+      all_podfile_pods = analysis_result.podfile_dependency_cache.podfile_dependencies
+
+      external_source_pods = all_podfile_pods.select(&:external_source)
+      checkout_options = external_source_pods.map { |x| [x.name, x.external_source] }.to_h
+
+      # this adds the :commit which might be missing in checkout_options
+      # will also overwrite :branch with :commit which is desired
+      checkout_options.merge!(analyzer.sandbox.checkout_sources)
+      
+      all_specs = analysis_result.specifications
+
+      all_podfile_specs = all_specs.select { |x| all_podfile_pods.map(&:name).include?(x.name) }
+
+      deps_names = all_podfile_specs.map { |x| x.recursive_dep_names(all_specs) }.flatten.uniq
+
+      all_podfile_specs += all_specs.select { |x| deps_names.include?(x.name) }
+      all_podfile_specs.uniq!
+      
+      return all_podfile_specs.map { |spec| PodfileItem.new(spec, all_specs, checkout_options) }
+    end
+  end
+end

data/lib/pod_builder/cocoapods/analyzer.rb

@@ -0,0 +1,24 @@
+module Pod
+  class Installer
+    class Analyzer
+      def pods_and_deps_in_target(target_name, podfile_items)
+        target_name = "Pods-#{target_name}"
+
+        specs = result.specs_by_target.select { |key, value| key.label == target_name }.values.first
+        specs.select! { |x| podfile_items.map(&:name).include?(x.name) }
+        
+        target_pods = []
+        specs.each do |spec|
+          pod = podfile_items.detect { |x| x.name == spec.name }
+          raise "Pod #{spec.name} not found while trying to build Podfile.restore!" if pod.nil?
+          target_pods.push(pod)
+        end
+
+        target_dependencies = target_pods.map { |x| x.dependencies(podfile_items) }.flatten.uniq
+        target_pods -= target_dependencies
+
+        return target_pods.uniq, target_dependencies.uniq
+      end
+    end
+  end
+end

data/lib/pod_builder/cocoapods/specification.rb

@@ -0,0 +1,27 @@
+module Pod
+  class Specification
+    def recursive_dep_names(all_specs)
+      base_deps = all_dependencies.map(&:name)
+
+      loop do
+        last_deps_count = base_deps.count
+        
+        all_specs.each do |s|
+          unless s != self
+            next
+          end
+
+          specs_deps = s.all_dependencies.map(&:name)
+          if base_deps.include?(s.name)
+            base_deps += specs_deps
+            base_deps.uniq!
+          end
+        end
+        
+        break unless last_deps_count != base_deps.count
+      end 
+
+      return base_deps
+    end    
+  end
+end

data/lib/pod_builder/command.rb

@@ -0,0 +1,9 @@
+require 'pod_builder/command/none'
+require 'pod_builder/command/build'
+require 'pod_builder/command/build_all'
+require 'pod_builder/command/restore_all'
+require 'pod_builder/command/init'
+require 'pod_builder/command/clean'
+require 'pod_builder/command/deintegrate'
+require 'pod_builder/command/generate_podspec'
+require 'pod_builder/command/install_sources'

data/lib/pod_builder/command/build.rb

@@ -0,0 +1,240 @@
+require 'pod_builder/core'
+require 'cfpropertylist'
+
+module PodBuilder
+  module Command
+    class Build
+      def self.call(options)          
+        Configuration.check_inited
+        PodBuilder::prepare_basepath
+
+        argument_pods = ARGV.dup
+
+        unless argument_pods.count > 0 
+          return false
+        end
+
+        update_repo = options[:update_repos] || false
+        installer, analyzer = Analyze.installer_at(PodBuilder::basepath, update_repo)
+
+        all_buildable_items = Analyze.podfile_items(installer, analyzer)
+        prebuilt_items = all_buildable_items.select { |x| x.is_prebuilt }
+        buildable_items = all_buildable_items - prebuilt_items
+
+        if argument_pods.first == "*"
+          argument_pods = buildable_items.map(&:name)
+        end
+
+        argument_pods.select! { |x| buildable_items.map(&:name).include?(x) }
+
+        unless argument_pods.count > 0 
+          puts "\n\nNo pods to build found, `#{ARGV.join(" ")}` is/are prebuilt\n".yellow
+          puts "\n\n🎉 done!\n".green
+
+          return true
+        end
+
+        check_pods_exists(argument_pods, buildable_items)
+
+        pods_to_build = buildable_items.select { |x| argument_pods.include?(x.name) }
+        pods_to_build += other_subspecs(pods_to_build, buildable_items)
+
+        buildable_items -= pods_to_build
+
+        check_no_common_dependencies(pods_to_build, buildable_items)
+        check_not_building_dependency(pods_to_build, buildable_items)
+
+        # Remove dependencies from pods to build
+        all_dependencies_name = pods_to_build.map(&:dependency_names).flatten.uniq
+        pods_to_build.select! { |x| !all_dependencies_name.include?(x.name) }
+
+        # We need to split pods to build in 3 groups
+        # 1. subspecs: because the resulting .framework path is treated differently
+        # 2. pods to build in release
+        # 3. pods to build in debug
+
+        pods_to_build_subspecs = pods_to_build.select { |x| x.is_subspec }
+        pods_to_build -= pods_to_build_subspecs
+        pods_to_build_debug = pods_to_build.select { |x| x.build_configuration == "debug" }
+        pods_to_build_release = pods_to_build - pods_to_build_debug
+
+        check_dependencies_build_configurations(all_buildable_items)
+
+        podfiles_items = pods_to_build_subspecs.map { |x| [x] }
+        podfiles_items.push(pods_to_build_debug)
+        podfiles_items.push(pods_to_build_release)   
+
+        licenses = []
+        
+        podfiles_items.select { |x| x.count > 0 }.each do |podfile_items|
+          podfile_items = add_dependencies(podfile_items, all_buildable_items)
+          podfile_content = Podfile.from_podfile_items(podfile_items, analyzer)
+          
+          Install.podfile(podfile_content, podfile_items, podfile_items.first.build_configuration)
+
+          licenses += license_specifiers
+          
+          # remove lockfile which gets unexplicably created
+          FileUtils.rm_f(PodBuilder::basepath("Podfile.lock"))
+        end
+
+        write_license_files(licenses, all_buildable_items)
+
+        Podspec::generate
+
+        builded_pods = podfiles_items.flatten
+        builded_pods_and_deps = add_dependencies(builded_pods, all_buildable_items).select { |x| !x.is_prebuilt }
+        Podfile::write_restorable(builded_pods, all_buildable_items, analyzer)     
+        if !options.has_key?(:skip_prebuild_update)   
+          Podfile::update_prebuilt(builded_pods_and_deps, all_buildable_items, analyzer)
+        end
+
+        Podfile::deintegrate_install
+
+        puts "\n\n🎉 done!\n".green
+        return true
+      end
+
+      private
+
+      def self.license_specifiers
+        acknowledge_files = Dir.glob("#{PodBuilder::Configuration.build_path}/Pods/**/*acknowledgements.plist")
+        raise "Too many acknoledge file found" if acknowledge_files.count > 1
+
+        if acknowledge_file = acknowledge_files.first
+          plist = CFPropertyList::List.new(:file => acknowledge_file)
+          data = CFPropertyList.native_types(plist.value)
+          
+          return data["PreferenceSpecifiers"]
+        end
+
+        return []
+      end
+
+      def self.write_license_files(licenses, all_buildable_items)
+        license_file_path = PodBuilder::xcodepath(Configuration.license_file_name) + ".plist"
+
+        current_licenses = []
+        if File.exist?(license_file_path)
+          plist = CFPropertyList::List.new(:file => license_file_path)
+          dict = CFPropertyList.native_types(plist.value)  
+          current_licenses = dict["PreferenceSpecifiers"]          
+          current_licenses.shift
+          current_licenses.pop
+        end
+
+        licenses_header = licenses.shift
+        raise "Unexpected license found in header" if licenses_header.has_key?("License")
+        license_footer = licenses.pop
+        raise "Unexpected license found in footer" if license_footer.has_key?("License")
+
+        lincenses_titles = licenses.map { |x| x["Title"] }
+        current_licenses.select! { |x| !lincenses_titles.include?(x["Title"]) }
+
+        licenses += current_licenses # merge with existing license
+        licenses.uniq! { |x| x["Title"] }
+        licenses.sort_by! { |x| x["Title"] }
+        licenses.select! { |x| !Configuration.skip_licenses.include?(x["Title"]) }
+        licenses.select! { |x| all_buildable_items.map(&:root_name).include?(x["Title"]) } # Remove items that are no longer included
+
+        license_dict = {}
+        license_dict["PreferenceSpecifiers"] = [licenses_header, licenses, license_footer].flatten
+        license_dict["StringsTable"] = "Acknowledgements"
+        license_dict["Title"] = license_dict["StringsTable"]
+
+        plist = CFPropertyList::List.new
+        plist.value = CFPropertyList.guess(license_dict)
+        plist.save(license_file_path, CFPropertyList::List::FORMAT_BINARY)
+
+        write_markdown_licenses(license_file_path)
+      end
+
+      def self.write_markdown_licenses(plist_path)
+        plist = CFPropertyList::List.new(:file => plist_path)
+        dict = CFPropertyList.native_types(plist.value)  
+        licenses = dict["PreferenceSpecifiers"]
+        header = licenses.shift
+
+        markdown = []
+        markdown += ["# #{header["Title"]}", header["FooterText"], ""]
+        markdown += licenses.map { |x| ["## #{x["Title"]}", x["FooterText"], ""] }
+
+        markdown.flatten!
+
+        markdown_path = plist_path.chomp(File.extname(plist_path)) + ".md"
+
+        File.write(markdown_path, markdown.join("\n"))
+      end
+
+      def self.add_dependencies(pods, buildable_items)
+        pods.dup.each do |pod|
+          build_configuration = pods.first.build_configuration
+
+          dependencies = pod.dependencies(buildable_items).select { |x| !pods.include?(x) && !pod.has_common_spec(x.name) }
+          dependencies.each { |x| x.build_configuration = build_configuration }
+          pods = dependencies + pods # dependencies should come first
+        end
+        
+        return pods
+      end
+
+      def self.check_no_common_dependencies(pods_to_build, buildable_items)
+        pods_to_build.each do |pod_to_build|
+          pod_to_build.dependency_names.each do |dependency|
+            buildable_items.each do |buildable_pod|
+              unless !pod_to_build.dependency_names.include?(buildable_pod.name)
+                next
+              end
+
+              if buildable_pod.dependency_names.include?(dependency) && !buildable_pod.has_subspec(dependency) && !buildable_pod.has_common_spec(dependency)   then
+                raise "\nCan't build #{pod_to_build.name} because it has common dependencies (#{dependency}) with #{buildable_pod.name}.\n\nUse `pod_builder build #{pods_to_build.map(&:name).join(" ")} #{buildable_pod.name}` instead\n\n".red
+              end
+            end
+          end
+        end
+      end
+
+      def self.check_not_building_dependency(pods_to_build, buildable_items)
+        buildable_items_dependencies = buildable_items.map(&:dependency_names).flatten.uniq
+        pods_to_build.each do |pod_to_build|
+          if buildable_items_dependencies.include?(pod_to_build.name)
+            parent = buildable_items.detect { |x| x.dependency_names.include?(pod_to_build.name) }
+            raise "\nCan't build #{pod_to_build.name} because it is a dependency of #{parent.name}.\n\nUse `pod_builder build #{parent.name}` instead\n\n".red
+          end
+        end
+      end
+
+      def self.check_pods_exists(pods, buildable_items)
+        raise "Empty Podfile?" if buildable_items.nil?
+
+        buildable_items = buildable_items.map(&:name)
+        pods.each do |pod|
+          raise "\nPod `#{pod}` wasn't found in Podfile.\n\nFound:\n#{buildable_items.join("\n")}\n\n".red if !buildable_items.include?(pod)
+        end
+      end
+
+      def self.check_dependencies_build_configurations(pods)
+        pods.each do |pod|
+          pod_dependency_names = pod.dependency_names.select { |x| !pod.has_common_spec(x) }
+
+          remaining_pods = pods - [pod]
+          pods_with_common_deps = remaining_pods.select { |x| x.dependency_names.any? { |y| pod_dependency_names.include?(y) && !x.has_common_spec(y) } }
+          
+          pods_with_unaligned_build_configuration = pods_with_common_deps.select { |x| x.build_configuration != pod.build_configuration }
+          pods_with_unaligned_build_configuration.map!(&:name)
+
+          raise "Dependencies of `#{pod.name}` don't have the same build configuration (#{pod.build_configuration}) of `#{pods_with_unaligned_build_configuration.join(",")}`'s dependencies" if pods_with_unaligned_build_configuration.count > 0
+        end
+      end
+
+      def self.other_subspecs(pods_to_build, buildable_items)
+        buildable_subspecs = buildable_items.select { |x| x.is_subspec }
+        pods_to_build_subspecs = pods_to_build.select { |x| x.is_subspec }.map(&:root_name)
+
+        buildable_subspecs.select! { |x| pods_to_build_subspecs.include?(x.root_name) }
+
+        return buildable_subspecs - pods_to_build
+      end
+    end
+  end
+end