pod-builder 0.1.8.beta → 0.2.0

data/lib/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def detect_indentation
+    return self[/\A\s*/]
+  end
+end

data/lib/pod_builder/command.rb

@@ -7,3 +7,6 @@ require 'pod_builder/command/clean'
 require 'pod_builder/command/deintegrate'
 require 'pod_builder/command/generate_podspec'
 require 'pod_builder/command/install_sources'
+require 'pod_builder/command/switch'
+require 'pod_builder/command/generate_lfs'
+require 'pod_builder/command/synch_podfile'

data/lib/pod_builder/command/build.rb

@@ -14,6 +14,8 @@ module PodBuilder
           return false
         end
 
+        check_not_building_subspecs(argument_pods)
+
         update_repo = options[:update_repos] || false
         installer, analyzer = Analyze.installer_at(PodBuilder::basepath, update_repo)
 
@@ -22,10 +24,11 @@ module PodBuilder
         buildable_items = all_buildable_items - prebuilt_items
 
         if argument_pods.first == "*"
-          argument_pods = buildable_items.map(&:name)
+          argument_pods = buildable_items.map(&:root_name)
         end
 
-        argument_pods.select! { |x| buildable_items.map(&:name).include?(x) }
+        argument_pods.select! { |x| buildable_items.map(&:root_name).include?(x) }
+        argument_pods.uniq!
 
         unless argument_pods.count > 0 
           puts "\n\nNo pods to build found, `#{ARGV.join(" ")}` is/are prebuilt\n".yellow
@@ -34,9 +37,10 @@ module PodBuilder
           return true
         end
 
+        check_splitted_subspecs_are_static(all_buildable_items, options)
         check_pods_exists(argument_pods, buildable_items)
 
-        pods_to_build = buildable_items.select { |x| argument_pods.include?(x.name) }
+        pods_to_build = buildable_items.select { |x| argument_pods.include?(x.root_name) }
         pods_to_build += other_subspecs(pods_to_build, buildable_items)
 
         buildable_items -= pods_to_build
@@ -49,11 +53,11 @@ module PodBuilder
         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
+        # 1. subspecs: because the resulting .framework path is treated differently when added to Configuration.subspecs_to_split
         # 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_subspecs = pods_to_build.select { |x| x.is_subspec && Configuration.subspecs_to_split.include?(x.name) }
         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
@@ -80,17 +84,20 @@ module PodBuilder
 
         write_license_files(licenses, all_buildable_items)
 
-        Podspec::generate
+        GenerateLFS::call(nil)
+        Podspec::generate(analyzer)
 
         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)
+          Podfile::write_prebuilt(all_buildable_items, analyzer)
         end
 
         Podfile::deintegrate_install
 
+        sanity_checks(options)
+
         puts "\n\n🎉 done!\n".green
         return true
       end
@@ -112,7 +119,8 @@ module PodBuilder
       end
 
       def self.write_license_files(licenses, all_buildable_items)
-        license_file_path = PodBuilder::xcodepath(Configuration.license_file_name) + ".plist"
+        puts "Writing licenses".yellow
+        license_file_path = PodBuilder::project_path(Configuration.license_filename) + ".plist"
 
         current_licenses = []
         if File.exist?(license_file_path)
@@ -186,8 +194,9 @@ module PodBuilder
                 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
+              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).uniq
+                raise "\n\nCan't build #{pod_to_build.name} because it has common dependencies (#{dependency}) with #{buildable_pod.name}.\n\nUse `pod_builder build #{expected_pod_list.join(" ")} #{buildable_pod.name}` instead\n\n".red
               end
             end
           end
@@ -199,7 +208,15 @@ module PodBuilder
         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
+            raise "\n\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_not_building_subspecs(pods_to_build)
+        pods_to_build.each do |pod_to_build|
+          if pod_to_build.include?("/")
+            raise "\n\nCan't build subspec #{pod_to_build} refer to podspec name.\n\nUse `pod_builder build #{pods_to_build.map { |x| x.split("/").first }.uniq.join(" ")}` instead\n\n".red
           end
         end
       end
@@ -207,9 +224,27 @@ module PodBuilder
       def self.check_pods_exists(pods, buildable_items)
         raise "Empty Podfile?" if buildable_items.nil?
 
-        buildable_items = buildable_items.map(&:name)
+        buildable_items = buildable_items.map(&:root_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)
+          raise "\n\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_splitted_subspecs_are_static(all_buildable_items, options)
+        non_static_subspecs = all_buildable_items.select { |x| x.is_subspec && x.is_static == false }
+        non_static_subspecs_names = non_static_subspecs.map(&:name)
+
+        invalid_subspecs = Configuration.subspecs_to_split & non_static_subspecs_names # intersect
+
+        unless invalid_subspecs.count > 0
+          return
+        end
+
+        warn_message = "The following pods `#{invalid_subspecs.join(" ")}` are non static frameworks which are being splitted over different targets. Beware that this is an unsafe setup as per https://github.com/CocoaPods/CocoaPods/issues/5708 and https://github.com/CocoaPods/CocoaPods/issues/5643\n"
+        if options[:allow_warnings]
+          puts "\n\n⚠️  #{warn_message}".yellow
+        else
+          raise "\n\n🚨️  #{warn_message}".yellow
         end
       end
 
@@ -235,6 +270,22 @@ module PodBuilder
 
         return buildable_subspecs - pods_to_build
       end
+
+      def self.sanity_checks(options)
+        lines = File.read(PodBuilder::project_path("Podfile")).split("\n")
+        stripped_lines = lines.map { |x| Podfile.strip_line(x) }.select { |x| !x.start_with?("#")}
+
+        expected_stripped = Podfile::POST_INSTALL_ACTIONS.map { |x| Podfile.strip_line(x) }
+
+        if !expected_stripped.all? { |x| stripped_lines.include?(x) }
+          warn_message = "PodBuilder's post install actions missing from application Podfile!\n"
+          if options[:allow_warnings]
+            puts "\n\n⚠️  #{warn_message}".yellow
+          else
+            raise "\n\n🚨️  #{warn_message}".red
+          end
+        end
+      end
     end
   end
 end

data/lib/pod_builder/command/clean.rb

@@ -1,4 +1,5 @@
 require 'pod_builder/core'
+require 'highline/import'
 
 module PodBuilder
   module Command
@@ -16,31 +17,34 @@ module PodBuilder
 
         base_path = PodBuilder::basepath("Rome")
         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)
 
+        puts "Looking for unused sources".yellow
         clean_sources(podspec_names)
 
         puts "\n\n🎉 done!\n".green
         return true
       end
 
-      def self.clean_sources(podspec_names)
-        puts "Cleaning sources".blue
-        
+      def self.clean_sources(podspec_names)        
         base_path = PodBuilder::basepath("Sources")
 
         repo_paths = Dir.glob("#{base_path}/*")
 
+        paths_to_delete = []
         repo_paths.each do |path|
           podspec_name = File.basename(path)
 
@@ -48,8 +52,14 @@ module PodBuilder
             next
           end
 
-          puts "Deleting sources #{path}".blue
-          PodBuilder::safe_rm_rf(path)
+          paths_to_delete.push(path)
+        end
+
+        paths_to_delete.flatten.each do |path|
+          confirm = ask("#{path} unused.\nDelete it? [Y/N] ") { |yn| yn.limit = 1, yn.validate = /[yn]/i }
+          if confirm.downcase == 'y'
+            PodBuilder::safe_rm_rf(path)
+          end
         end
       end
 
@@ -58,13 +68,20 @@ module PodBuilder
       def self.clean(files, base_path, rel_paths)
         files = files.map { |x| [Pathname.new(x).relative_path_from(Pathname.new(base_path)).to_s, x] }.to_h
 
+        paths_to_delete = []
         files.each do |rel_path, path|
           unless !rel_paths.include?(rel_path)
             next
           end
 
-          puts "Deleting #{path}".blue
-          PodBuilder::safe_rm_rf(path)
+          paths_to_delete.push(path)
+        end
+
+        paths_to_delete.each do |path|
+          confirm = ask("\n#{path} unused.\nDelete it? [Y/N] ") { |yn| yn.limit = 1, yn.validate = /[yn]/i }
+          if confirm.downcase == 'y'
+            PodBuilder::safe_rm_rf(path)
+          end
         end
 
         current_dir = Dir.pwd

data/lib/pod_builder/command/deintegrate.rb

@@ -7,7 +7,7 @@ module PodBuilder
         raise "\n\nPodBuilder not initialized!\n".red if !Configuration.exists
 
         prebuilt_podfile = File.join(Configuration.base_path, "Podfile")
-        restored_podfile = File.join(PodBuilder::xcodepath, "Podfile")
+        restored_podfile = File.join(PodBuilder::project_path, "Podfile")
 
         FileUtils.cp(prebuilt_podfile, restored_podfile)
 
@@ -15,7 +15,7 @@ module PodBuilder
         podfile_lines = []
         pre_install_indx = -1
         podfile_content.each_line.with_index do |line, index|
-          if Podfile::PRE_INSTALL_ACTIONS.detect { |x| Podfile::strip_line(x) == Podfile::strip_line(line) }
+          if Podfile::PODBUILDER_LOCK_ACTION.detect { |x| Podfile::strip_line(x) == Podfile::strip_line(line) }
             if pre_install_indx == -1
               pre_install_indx = index
             end
@@ -33,19 +33,47 @@ module PodBuilder
 
         FileUtils.rm_f(restored_podfile)
         File.write(restored_podfile, podfile_lines.join)
+        Podfile.update_path_entires(restored_podfile, false)
+        Podfile.update_project_entries(restored_podfile, false)
 
         PodBuilder::safe_rm_rf(Configuration.base_path)
 
-        Dir.chdir(PodBuilder::xcodepath)
-        system("pod deintegrate; pod install;")  
+        Dir.chdir(PodBuilder::project_path)
+        system("pod install;")  
 
-        license_base = PodBuilder::xcodepath(Configuration.license_file_name)
+        license_base = PodBuilder::project_path(Configuration.license_filename)
         FileUtils.rm_f("#{license_base}.plist")
         FileUtils.rm_f("#{license_base}.md")
 
+        update_gemfile
+
         puts "\n\n🎉 done!\n".green
         return true
       end
+
+      private
+
+      def self.update_gemfile
+        gemfile_path = File.join(PodBuilder::home, "Gemfile")
+        unless File.exist?(gemfile_path)
+          FileUtils.touch(gemfile_path)
+        end
+
+        podbuilder_line = "gem 'pod-builder'"
+
+        gemfile = File.read(gemfile_path)
+
+        gemfile_lines = gemfile.split("\n")
+        gemfile_lines.select! { |x| !trim_gemfile_line(x).include?(trim_gemfile_line(podbuilder_line)) }
+        File.write(gemfile_path, gemfile_lines.join("\n"))
+
+        Dir.chdir(PodBuilder::home)
+        system("bundle")
+      end
+
+      def self.trim_gemfile_line(line)
+        return line.gsub("\"", "'").gsub(" ", "")
+      end
     end
   end
 end

data/lib/pod_builder/command/generate_lfs.rb

@@ -0,0 +1,66 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class GenerateLFS
+      def self.call(options)
+        Configuration.check_inited
+
+        unless Configuration.update_lfs_gitattributes
+          return false
+        end
+  
+        base_path = PodBuilder::basepath
+        framework_files = filter_files_by_size(Dir.glob("#{base_path}/Rome/**/*.framework/**/**"), 256)
+        dSYM_files_iphone = filter_files_by_size(Dir.glob("#{base_path}/dSYM/**/*.dSYM/**/**"), 256)
+
+        total_size = (framework_files + dSYM_files_iphone).map { |x| File.size(x) }.inject(0, :+)
+        puts "Total size in LFS: #{total_size / 1024 / 1024}MB"
+
+        home_path = Pathname.new(PodBuilder::home)
+
+        paths = (framework_files + dSYM_files_iphone).map { |x| Pathname.new(x) }
+        rel_paths = paths.map { |x| x.relative_path_from(home_path).to_s }
+
+        stop_marker = "# pb<stop>"
+        start_marker = "# pb<start> (lines up to `#{stop_marker}` are autogenerated, don't modify this section)"
+
+        gitattributes_items = [start_marker]
+        gitattributes_items += rel_paths.map { |x| "#{x} filter=lfs diff=lfs merge=lfs -text" }
+        gitattributes_items += [stop_marker]
+        
+        gitattributes_path = File.join(PodBuilder::home, ".gitattributes")
+        if !File.exist?(gitattributes_path)
+          FileUtils.touch(gitattributes_path)
+        end
+        
+        gitattributes_content = File.read(gitattributes_path)
+
+        podbuilder_start_line_found = false
+        gitattributes_content.each_line do |line|
+          stripped_line = line.strip
+          if stripped_line.start_with?(stop_marker)
+            podbuilder_start_line_found = false
+            next
+          elsif stripped_line.start_with?(start_marker)
+            podbuilder_start_line_found = true
+          end
+
+          unless !podbuilder_start_line_found
+            next
+          end
+
+          gitattributes_items.push(line.strip)
+        end
+        
+        File.write(gitattributes_path, gitattributes_items.join("\n"))
+      end
+
+      private
+
+      def self.filter_files_by_size(files, size_kb)
+        return files.select { |x| File.size(x) / 1024 > Configuration.lfs_min_file_size }
+      end
+    end
+  end
+end       

data/lib/pod_builder/command/generate_podspec.rb

@@ -7,7 +7,9 @@ module PodBuilder
         Configuration.check_inited
         PodBuilder::prepare_basepath
 
-        Podspec::generate
+        installer, analyzer = Analyze.installer_at(PodBuilder::basepath, false)
+
+        Podspec::generate(analyzer)
 
         puts "\n\n🎉 done!\n".green
         return true

data/lib/pod_builder/command/init.rb

@@ -5,75 +5,74 @@ module PodBuilder
     class Init
       def self.call(options)
         raise "\n\nAlready initialized\n".red if Configuration.exists
-        raise "\n\nXcode project missing\n".red if PodBuilder::xcodepath.nil?
+        raise "\n\nXcode workspace not found\n".red if PodBuilder::project_path.nil?
         
         options[:prebuild_path] ||= Configuration.base_path
 
         if File.expand_path(options[:prebuild_path]) != options[:prebuild_path] # if not absolute
-          options[:prebuild_path] = File.expand_path(PodBuilder::xcodepath(options[:prebuild_path]))
+          options[:prebuild_path] = File.expand_path(PodBuilder::project_path(options[:prebuild_path]))
         end
 
         FileUtils.mkdir_p(options[:prebuild_path])
         FileUtils.mkdir_p("#{options[:prebuild_path]}/.pod_builder")
         FileUtils.touch("#{options[:prebuild_path]}/.pod_builder/pod_builder")
+
+        source_path_rel_path = "Sources"
+        development_pods_config_rel_path = Configuration.dev_pods_configuration_filename
+
+        git_ignores = ["Pods/",
+                       "*.xcworkspace",
+                       "*.xcodeproj",
+                       "Podfile.lock",
+                       source_path_rel_path,
+                       development_pods_config_rel_path]
         
-        File.write("#{options[:prebuild_path]}/.gitignore", "Pods/\n*.xcodeproj\nSources\n")
+        File.write("#{options[:prebuild_path]}/.gitignore", git_ignores.join("\n"))
 
-        project_podfile_path = PodBuilder::xcodepath("Podfile")
+        project_podfile_path = PodBuilder::project_path("Podfile")
         prebuilt_podfile_path = File.join(options[:prebuild_path], "Podfile")
         FileUtils.cp(project_podfile_path, prebuilt_podfile_path)
         
-        add_install_block(prebuilt_podfile_path)
-
-        add_pre_install_actions(project_podfile_path)
-        add_post_install_checks(project_podfile_path)
+        Podfile.add_install_block(prebuilt_podfile_path)
+        Podfile.update_path_entires(prebuilt_podfile_path, false, PodBuilder::project_path(""))
+        Podfile.update_project_entries(prebuilt_podfile_path, false, PodBuilder::project_path(""))
 
         Configuration.write
 
+        update_gemfile
+
         puts "\n\n🎉 done!\n".green
         return true
       end
 
-      private
+      private 
 
-      def self.add_install_block(podfile_path)
-        add(Podfile::PRE_INSTALL_ACTIONS, "pre_install", podfile_path)
-      end
+      def self.update_gemfile
+        gemfile_path = File.join(PodBuilder::home, "Gemfile")
+        unless File.exist?(gemfile_path)
+          FileUtils.touch(gemfile_path)
+        end
 
-      def self.add_pre_install_actions(podfile_path)
-        pre_install_actions = ["Pod::Installer::Xcode::TargetValidator.send(:define_method, :verify_no_duplicate_framework_and_library_names) {}"]
-        add(pre_install_actions, "pre_install", podfile_path)
-      end
+        source_line = "source 'https://rubygems.org'"
+        podbuilder_line = "gem 'pod-builder'"
 
-      def self.add_post_install_checks(podfile_path)
-        post_install_actions = ["require 'pod_builder/podfile/post_actions'", "PodBuilder::Podfile::remove_target_support_duplicate_entries", "PodBuilder::Podfile::check_target_support_resource_collisions"]
-        add(post_install_actions, "post_install", podfile_path)
-      end
+        gemfile = File.read(gemfile_path)
 
-      def self.add(entries, marker, podfile_path)
-        podfile_content = File.read(podfile_path)
-
-        entries.map! { |x| "   #{x}\n"}
-
-        marker_found = false
-        podfile_lines = []
-        podfile_content.each_line do |line|
-          stripped_line = Podfile::strip_line(line)
-  
-          podfile_lines.push(line)
-          if stripped_line.start_with?("#{marker}do|")
-            marker_found = true
-            podfile_lines.push(entries)
-          end
-        end
+        gemfile_lines = gemfile.split("\n")
+        gemfile_lines.select! { |x| !trim_gemfile_line(x).include?(trim_gemfile_line(source_line)) }
+        gemfile_lines.select! { |x| !trim_gemfile_line(x).include?(trim_gemfile_line(podbuilder_line)) }
 
-        if !marker_found
-          podfile_lines.push("\n#{marker} do |installer|\n")
-          podfile_lines.push(entries)
-          podfile_lines.push("end\n")
-        end
+        gemfile_lines.insert(0, source_line)
+        gemfile_lines.push(podbuilder_line)
+     
+        File.write(gemfile_path, gemfile_lines.join("\n"))
+
+        Dir.chdir(PodBuilder::home)
+        system("bundle")
+      end
 
-        File.write(podfile_path, podfile_lines.join)
+      def self.trim_gemfile_line(line)
+        return line.gsub("\"", "'").gsub(" ", "")
       end
     end
   end