pod-builder 1.9.2 → 2.0.0.beta.19

data/exe/pod_builder

@@ -71,12 +71,15 @@ Options:
         opts.on("-u", "--skip-repo-update", "Skip CocoaPods repo update") do |o|
           OPTIONS[:update_repos] = false
         end
+        opts.on("-f", "--force", "Rebuild frameworks evan if no code change is detected") do |o|
+          OPTIONS[:force_rebuild] = false
+        end
         opts.on("-w", "--allow-warnings", "Allow warnings") do |o|
           OPTIONS[:allow_warnings] = o
         end
-        opts.on("-a", "--auto-resolve-deps", "Resolve pod dependencies automatically") do |o|
-          OPTIONS[:auto_resolve_dependencies] = o
-        end
+        # opts.on("-a", "--auto-resolve-deps", "Resolve pod dependencies automatically") do |o|
+        #   OPTIONS[:auto_resolve_dependencies] = o
+        # end
         opts.on("-d", "--debug", "Don't clean build folder") do |o|
           OPTIONS[:debug] = o
         end
@@ -100,6 +103,9 @@ Options:
         opts.on("-u", "--skip-repo-update", "Skip CocoaPods repo update") do |o|
           OPTIONS[:update_repos] = false
         end
+        opts.on("-f", "--force", "Rebuild frameworks evan if no code change is detected") do |o|
+          OPTIONS[:force_rebuild] = false
+        end
         opts.on("-w", "--allow-warnings", "Allow warnings") do |o|
           OPTIONS[:allow_warnings] = o
         end
@@ -289,9 +295,9 @@ Usage:
         opts.banner = "
 Usage:
         
-    $ pod_builder switch PODNAME [OPTIONS]
+    $ pod_builder switch [OPTIONS] PODNAME[s]
 
-      Switch integration between prebuilt/development/default pod version.
+      Switch integration between prebuilt/development/default pod version. Multiple space separated pods can be passed
         
 Options:
 "        
@@ -357,6 +363,8 @@ Usage:
   else
     PodBuilder::Configuration.load
 
+    PodBuilder::add_lockfile
+
     subcommand[:opts].order!    
     subcommand[:call].each do |k|
       if (ret = k.call(OPTIONS)) && ret == -1
@@ -374,8 +382,6 @@ begin
     raise "\n\nFor safety do not run this as root\n".red
   end
 
-  PodBuilder::add_lock_file
-  valid_lock_file = true
   command_ret = parse_commandline
 rescue Exception => e
   error = e.to_s
@@ -392,14 +398,8 @@ rescue Exception => e
 ensure
   if command_ret == 0
     PodBuilder::clean_basepath
-    
-    if !OPTIONS.has_key?(:debug)
-      PodBuilder::safe_rm_rf(PodBuilder::Configuration.build_path)
-    end    
-  end
-  if valid_lock_file
-    PodBuilder::remove_lock_file
   end
+  PodBuilder::remove_lockfile
 
   exit(command_ret)
 end

data/lib/pod_builder/analyze.rb

@@ -1,4 +1,6 @@
-require 'pod_builder/cocoapods/specification'
+require 'rubygems/specification'
+require 'pod_builder/rome/pre_install.rb'
+require 'pod_builder/rome/post_install.rb'
 
 module PodBuilder
   class Analyze
@@ -6,6 +8,14 @@ module PodBuilder
     #
     def self.installer_at(path, repo_update = false)
       CLAide::Command::PluginManager.load_plugins("cocoapods")
+      
+      # Manually load inline podbuilder-rome plugin
+      pluginspec = Gem::Specification.new("podbuilder-rome", PodBuilder::VERSION)
+      pluginspec.activate
+
+      if !CLAide::Command::PluginManager.loaded_plugins["cocoapods"].map(&:name).include?(pluginspec.name)
+        CLAide::Command::PluginManager.loaded_plugins["cocoapods"].push(pluginspec)
+      end
 
       current_dir = Dir.pwd
       Dir.chdir(path)
@@ -40,15 +50,30 @@ module PodBuilder
       checkout_options.merge!(analyzer.sandbox.checkout_sources)
       
       all_specs = analysis_result.specifications
+      
+      supported_platforms = analyzer.instance_variable_get("@result").targets.map { |t| t.platform.safe_string_name.downcase }
+      all_podfile_items = all_specs.map { |spec| PodfileItem.new(spec, all_specs, checkout_options, supported_platforms) }
 
-      all_podfile_specs = all_specs.select { |x| all_podfile_pods.map(&:name).include?(x.name) }
+      names = analyzer.explicit_pods().map(&:name)
 
-      deps_names = all_podfile_specs.map { |x| x.recursive_dep_names(all_specs) }.flatten.uniq
+      podfile_pods = []
+      last_count = -1 
+      while podfile_pods.count != last_count do
+        last_count = podfile_pods.count
 
-      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) }
+        updated_names = []
+        names.each do |name|
+          if pod = all_podfile_items.detect { |t| t.name == name }
+            podfile_pods.push(pod)
+            updated_names += pod.dependency_names
+          end
+        end
+        
+        names = updated_names.uniq
+        podfile_pods.uniq!
+      end
+
+      return podfile_pods.sort_by(&:name)
     end
   end
 end

data/lib/pod_builder/analyzer.rb

@@ -0,0 +1,16 @@
+require 'cocoapods/installer/analyzer.rb'
+
+module Pod
+  class Installer
+    class Analyzer
+        def explicit_pods
+            pods = []
+            podfile.root_target_definitions[0].children.each do |children|
+                pods += children.dependencies
+            end
+
+            pods.flatten.uniq.sort
+        end
+    end
+  end
+end

data/lib/pod_builder/command/build.rb

@@ -3,7 +3,7 @@ require 'pod_builder/core'
 module PodBuilder
   module Command
     class Build
-      def self.call(options)          
+      def self.call(options) 
         Configuration.check_inited
         PodBuilder::prepare_basepath
 
@@ -18,6 +18,8 @@ module PodBuilder
         Podfile.sanity_check()
         check_not_building_subspecs(argument_pods)
 
+        puts "Loading Podfile".yellow
+
         install_update_repo = options.fetch(:update_repos, true)
         installer, analyzer = Analyze.installer_at(PodBuilder::basepath, install_update_repo)
 
@@ -25,8 +27,11 @@ module PodBuilder
         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(&:root_name)
+        build_all = argument_pods.first == "*"
+        if build_all
+          argument_pods = analyzer.explicit_pods().map(&:root_name).uniq
+        else
+          argument_pods = Podfile::resolve_pod_names(argument_pods, all_buildable_items)
         end
 
         available_argument_pods = argument_pods.select { |x| all_buildable_items.map(&:root_name).include?(x) }     
@@ -73,8 +78,10 @@ module PodBuilder
         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)
+          build_configuration = podfile_items.map(&:build_configuration).uniq.first
+          
+          podfile_items = podfile_items.map { |t| t.recursive_dependencies(all_buildable_items) }.flatten.uniq
+          podfile_content = Podfile.from_podfile_items(podfile_items, analyzer, build_configuration)
           
           Install.podfile(podfile_content, podfile_items, podfile_items.first.build_configuration)
 
@@ -92,7 +99,10 @@ module PodBuilder
         Podspec::generate(all_buildable_items, analyzer)
 
         builded_pods = podfiles_items.flatten
-        builded_pods_and_deps = add_dependencies(builded_pods, all_buildable_items).select { |x| !x.is_prebuilt }
+        
+        builded_pods_and_deps = podfiles_items.flatten.map { |t| t.recursive_dependencies(all_buildable_items) }.flatten.uniq
+        builded_pods_and_deps.select! { |x| !x.is_prebuilt }
+        
         Podfile::write_restorable(builded_pods_and_deps + prebuilt_pods_to_install, all_buildable_items, analyzer)     
         if !options.has_key?(:skip_prebuild_update)   
           Podfile::write_prebuilt(all_buildable_items, analyzer)
@@ -126,73 +136,74 @@ module PodBuilder
         return []
       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.expected_common_dependencies(pods_to_build, buildable_items, options)
-        warned_expected_pod_list = []
-        expected_pod_list = []
-        errors = []
-
-        pods_to_build.each do |pod_to_build|
-          pod_to_build.dependency_names.each do |dependency|
-            unless buildable_items.detect { |x| x.root_name == dependency || x.name == dependency } != nil
-              next
-            end
-
-            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
-                expected_pod_list += pods_to_build.map(&:root_name) + [buildable_pod.root_name]
-                expected_pod_list.uniq!
-
-                expected_list = expected_pod_list.join(" ")
-                if !warned_expected_pod_list.include?(expected_list)
-                  errors.push("Can't build #{pod_to_build.name} because it has common dependencies (#{dependency}) with #{buildable_pod.name}.\n\nUse `pod_builder build #{expected_list}` instead or use `pod_builder build -a #{pod_to_build.name}` to automatically resolve missing dependencies\n\n")
-                  errors.uniq!
-                  warned_expected_pod_list.push(expected_list)
-
-                  if options.has_key?(:auto_resolve_dependencies)
-                    puts "`#{pod_to_build.name}` has the following dependencies:\n`#{pod_to_build.dependency_names.join("`, `")}`\nWhich are in common with `#{buildable_pod.name}` and requires it to be recompiled\n\n".yellow
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        return expected_pod_list, errors
-      end
-
-      def self.expected_parent_dependencies(pods_to_build, buildable_items, options)
-        expected_pod_list = []
-        errors = []
-
-        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) }
-
-            expected_pod_list += (pods_to_build + [parent]).map(&:root_name)
-            expected_pod_list.uniq!
-            errors.push("Can't build #{pod_to_build.name} because it is a dependency of #{parent.name}.\n\nUse `pod_builder build #{expected_pod_list.join(" ")}` instead\n\n")
-          end
-        end
-
-        return expected_pod_list, errors
-      end
+      # def self.buildable_dependencies(pod, buildable_items)
+      #   deps = []
+
+      #   pod.dependency_names.each do |dependency|
+      #     buildable_pods = buildable_items.select { |t| t.root_name == dependency }
+      #     if buildable_pods.any? { |t| t.source_files.count > 0 }
+      #       deps.push(dependency)
+      #     end
+      #   end
+
+      #   return deps
+      # end
+
+      # def self.expected_common_dependencies(pods_to_build, buildable_items, options)
+      #   warned_expected_pod_list = []
+      #   expected_pod_list = []
+      #   errors = []
+
+      #   pods_to_build.each do |pod_to_build|
+      #     buildable_dependencies(pod_to_build, buildable_items).each do |dependency|
+      #       unless buildable_items.detect { |x| x.root_name == dependency || x.name == dependency } != nil
+      #         next
+      #       end
+
+      #       buildable_items.each do |buildable_pod|
+      #         unless !buildable_dependencies(pod_to_build, buildable_items).include?(buildable_pod.name)
+      #           next
+      #         end
+
+      #         if buildable_dependencies(buildable_pod, buildable_items).include?(dependency) && !buildable_pod.has_subspec(dependency) && !buildable_pod.has_common_spec(dependency) then
+      #           expected_pod_list += pods_to_build.map(&:root_name) + [buildable_pod.root_name]
+      #           expected_pod_list.uniq!
+
+      #           expected_list = expected_pod_list.join(" ")
+      #           if !warned_expected_pod_list.include?(expected_list)
+      #             errors.push("Can't build #{pod_to_build.name} because it has common dependencies (#{dependency}) with #{buildable_pod.name}.\n\nUse `pod_builder build #{expected_list}` instead or use `pod_builder build -a #{pod_to_build.name}` to automatically resolve missing dependencies\n\n")
+      #             errors.uniq!
+      #             warned_expected_pod_list.push(expected_list)
+
+      #             if options.has_key?(:auto_resolve_dependencies)
+      #               puts "`#{pod_to_build.name}` has the following dependencies:\n`#{buildable_dependencies(pod_to_build, buildable_items).join("`, `")}`\nWhich are in common with `#{buildable_pod.name}` and requires it to be recompiled\n\n".yellow
+      #             end
+      #           end
+      #         end
+      #       end
+      #     end
+      #   end
+
+      #   return expected_pod_list, errors
+      # end
+
+      # def self.expected_parent_dependencies(pods_to_build, buildable_items, options)
+      #   expected_pod_list = []
+      #   errors = []
+
+      #   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) }
+
+      #       expected_pod_list += (pods_to_build + [parent]).map(&:root_name)
+      #       expected_pod_list.uniq!
+      #       errors.push("Can't build #{pod_to_build.name} because it is a dependency of #{parent.name}.\n\nUse `pod_builder build #{expected_pod_list.join(" ")}` instead\n\n")
+      #     end
+      #   end
+
+      #   return expected_pod_list, errors
+      # end
 
       def self.check_not_building_subspecs(pods_to_build)
         pods_to_build.each do |pod_to_build|
@@ -278,27 +289,30 @@ module PodBuilder
       def self.resolve_pods_to_build(argument_pods, buildable_items, options)
         pods_to_build = []
         
-        fns = [method(:expected_common_dependencies), method(:expected_parent_dependencies)]
-        fns.each do |fn|
-          loop do
-            pods_to_build = buildable_items.select { |x| argument_pods.include?(x.root_name) }
-            pods_to_build += other_subspecs(pods_to_build, buildable_items)
-            tmp_buildable_items = buildable_items - pods_to_build
-
-            expected_pods, errors = fn.call(pods_to_build, tmp_buildable_items, options)
-            if expected_pods.count > 0
-              if !options.has_key?(:auto_resolve_dependencies) && expected_pods.count > 0
-                raise "\n\n#{errors.join("\n")}".red
-              else
-                argument_pods = expected_pods.uniq
-              end  
-            end
+        # fns = [method(:expected_common_dependencies), method(:expected_parent_dependencies)]
+        # fns.each do |fn|
+        #   loop do
+        #     pods_to_build = buildable_items.select { |x| argument_pods.include?(x.root_name) }
+        #     pods_to_build += other_subspecs(pods_to_build, buildable_items)
+        #     tmp_buildable_items = buildable_items - pods_to_build
+
+        #     expected_pods, errors = fn.call(pods_to_build, tmp_buildable_items, options)
+        #     if expected_pods.count > 0
+        #       if !options.has_key?(:auto_resolve_dependencies) && expected_pods.count > 0
+        #         raise "\n\n#{errors.join("\n")}".red
+        #       else
+        #         argument_pods = expected_pods.uniq
+        #       end  
+        #     end
             
-            if !options.has_key?(:auto_resolve_dependencies) || expected_pods.count == 0
-              break
-            end
-          end  
-        end
+        #     if !options.has_key?(:auto_resolve_dependencies) || expected_pods.count == 0
+        #       break
+        #     end
+        #   end  
+        # end
+
+        pods_to_build = buildable_items.select { |x| argument_pods.include?(x.root_name) }
+        pods_to_build += other_subspecs(pods_to_build, buildable_items)
 
         return pods_to_build
       end
@@ -307,10 +321,10 @@ module PodBuilder
         puts "Cleaning framework folder".yellow
 
         expected_frameworks = buildable_items.map { |x| "#{x.module_name}.framework" }
-        expected_frameworks += buildable_items.map { |x| x.vendored_items }.flatten.map { |x| File.basename(x) }
+        expected_frameworks += buildable_items.map { |x| x.vendored_frameworks }.flatten.map { |x| File.basename(x) }
         expected_frameworks.uniq!
 
-        existing_frameworks = Dir.glob("#{PodBuilder::basepath("Rome")}/*.framework")
+        existing_frameworks = Dir.glob(PodBuilder::prebuiltpath("*.framework"))
 
         existing_frameworks.each do |existing_framework|
           existing_framework_name = File.basename(existing_framework)
@@ -320,7 +334,7 @@ module PodBuilder
           end
         end
 
-        existing_dsyms = Dir.glob("#{PodBuilder::basepath("dSYM")}/**/*.dSYM")
+        existing_dsyms = Dir.glob(PodBuilder::dsympath("**/*.dSYM"))
         existing_dsyms.each do |existing_dsym|
           existing_dsym_name = File.basename(existing_dsym)
           if !expected_frameworks.include?(existing_dsym_name.gsub(".dSYM", ""))

data/lib/pod_builder/command/clean.rb

@@ -13,24 +13,22 @@ module PodBuilder
         all_buildable_items = Analyze.podfile_items(installer, analyzer)
 
         podspec_names = all_buildable_items.map(&:podspec_name)
-        rel_paths = all_buildable_items.map(&:prebuilt_rel_path)
+        rel_paths = all_buildable_items.map(&:prebuilt_rel_path) + all_buildable_items.map(&:vendored_frameworks).flatten.map { |t| File.basename(t) }
+        rel_paths.uniq!
 
-        base_path = PodBuilder::basepath("Rome")
+        base_path = PodBuilder::prebuiltpath
         framework_files = Dir.glob("#{base_path}/**/*.framework")
         puts "Looking for unused frameworks".yellow
         clean(framework_files, base_path, rel_paths)
 
         rel_paths.map! { |x| "#{x}.dSYM"}
 
-        base_path = PodBuilder::basepath("dSYM/iphoneos")
-        dSYM_files_iphone = Dir.glob("#{base_path}/**/*.dSYM")
-        puts "Looking for iPhoneOS unused dSYMs".yellow    
-        clean(dSYM_files_iphone, base_path, rel_paths)
-
-        base_path = PodBuilder::basepath("dSYM/iphonesimulator")
-        dSYM_files_sim = Dir.glob("#{base_path}/**/*.dSYM")
-        puts "Looking for iPhone Simulator unused dSYMs".yellow
-        clean(dSYM_files_sim, base_path, rel_paths)
+        Configuration.supported_platforms.each do |platform|
+          base_path = PodBuilder::dsympath(platform)
+          dSYM_files = Dir.glob("#{base_path}/**/*.dSYM")
+          puts "Looking for #{platform} unused dSYMs".yellow    
+          clean(dSYM_files, base_path, rel_paths)  
+        end
 
         puts "Looking for unused sources".yellow
         clean_sources(podspec_names)