pod-builder 0.1.8.beta → 0.2.0

data/lib/pod_builder/command/install_sources.rb

@@ -46,14 +46,14 @@ module PodBuilder
         end
 
         Dir.chdir(repo_dir)
-        puts "Checking out #{spec.podspec_name}".blue
+        puts "Checking out #{spec.podspec_name}".yellow
         raise "Failed cheking out #{spec.name}" if !system(spec.git_hard_checkout)
 
         Dir.chdir(current_dir)
       end
 
       def self.rewrite_lldinit
-        puts "Writing ~/.lldbinit-Xcode".blue
+        puts "Writing ~/.lldbinit-Xcode".yellow
 
         lldbinit_path = File.expand_path('~/.lldbinit-Xcode')
         FileUtils.touch(lldbinit_path)

data/lib/pod_builder/command/switch.rb

@@ -0,0 +1,165 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class Switch
+      def self.call(options)
+        Configuration.check_inited
+        PodBuilder::prepare_basepath
+        
+        argument_pods = ARGV.dup
+        
+        unless argument_pods.count > 0 
+          return false
+        end
+        unless argument_pods.count == 1
+          raise "\n\nSpecify a single pod to switch\n\n".red 
+          return false
+        end
+        
+        pod_name_to_switch = argument_pods.first
+        
+        check_not_building_subspec(pod_name_to_switch)
+
+        installer, analyzer = Analyze.installer_at(PodBuilder::basepath, false)
+        all_buildable_items = Analyze.podfile_items(installer, analyzer)
+
+        raise "\n\nPod `#{pod_name_to_switch}` wasn't found in Podfile" unless all_buildable_items.map(&:root_name).include?(pod_name_to_switch)
+        
+        unless options.has_key?(:switch_mode)
+          podfile_item = all_buildable_items.detect { |x| x.root_name == pod_name_to_switch }
+          options[:switch_mode] = request_switch_mode(pod_name_to_switch, podfile_item)
+
+          if options[:switch_mode].nil?
+            return true
+          end
+        end
+
+        if options[:switch_mode] == "prebuilt"
+          check_prebuilded(pod_name_to_switch)
+        end
+
+        podfile_path = PodBuilder::project_path("Podfile")
+        podfile_content = File.read(podfile_path)
+
+        pod_lines = []
+        podfile_content.each_line do |line|
+          if pod_name = Podfile.pod_definition_in(line, false)
+            if pod_name.start_with?("PodBuilder/")
+              pod_name = pod_name.split("PodBuilder/").last.gsub("_", "/")
+            end
+
+            unless pod_name.split("/").first == pod_name_to_switch
+              pod_lines.push(line)
+              next
+            end
+
+            if pod_name.include?("/")
+              podfile_items = all_buildable_items.select { |x| x.name == pod_name }
+            else
+              podfile_items = all_buildable_items.select { |x| x.root_name == pod_name }
+            end
+
+            unless podfile_items.count > 0
+              raise "\n\nPod `#{pod_name_to_switch}` wasn't found in Podfile\n".red
+            end
+
+            matches = line.match(/(#\s*pb<)(.*?)(>)/)
+            if matches&.size == 4
+              default_pod_name = matches[2]
+            else
+              puts "⚠️ Did not found pb<> entry, assigning default pod name #{pod_name}"
+              default_pod_name = pod_name
+            end
+
+            unless podfile_item = all_buildable_items.detect { |x| x.name == default_pod_name }
+              raise "\n\nPod `#{default_pod_name}` wasn't found in Podfile\n".red
+            end
+            podfile_item = podfile_item.dup
+
+            indentation = line.detect_indentation
+
+            case options[:switch_mode]
+            when "prebuilt"
+              line = indentation + podfile_item.prebuilt_entry + "\n"
+            when "development"
+              podfile_item.path = find_podspec(podfile_item)
+
+              line = indentation + podfile_item.entry + "\n"
+            when "default"
+              line = indentation + podfile_item.entry + "\n"
+            else
+              break
+            end
+          end
+
+          pod_lines.push(line)
+        end
+        
+        File.write(podfile_path, pod_lines.join)
+        
+        Dir.chdir(PodBuilder::project_path)
+        system("pod install")
+      end
+      
+      private     
+
+      def self.find_podspec(podfile_item)
+        unless Configuration.development_pods_paths.count > 0
+          raise "\n\nPlease add the `development_pods_paths` in #{Configuration.dev_pods_configuration_filename} as per documentation\n".red
+        end
+
+        podspec_path = nil
+        Configuration.development_pods_paths.each do |path|
+          podspec = Dir.glob(File.expand_path("#{path}/**/#{podfile_item.root_name}*.podspec*"))
+          podspec.select! { |x| !x.include?("/Local Podspecs/") }
+          if podspec.count > 0
+            podspec_path = Pathname.new(podspec.first).dirname.to_s
+            break
+          end
+        end
+
+        if podspec_path.nil?
+          raise "\n\nCouln't find `#{pod_name}` sources in the following specified development pod paths: #{Configuration.development_pods_paths.join("\n")}\n".red
+        end
+
+        return podspec_path
+      end
+      
+      def self.request_switch_mode(pod_name, podfile_item)
+        matches = podfile_item.entry.match(/(pod '.*?',)(.*)/)
+        unless matches&.size == 3 
+          raise "\n\nFailed matching pod name\n".red
+        end
+
+        default_entry = matches[2].strip
+
+        modes = ["prebuilt", "development", "default"]
+        mode_indx = ask("\n\nSwitch #{pod_name} to:\n1) Prebuilt\n2) Development pod\n3) Default (#{default_entry})\n\n") { |x| x.limit = 1, x.validate = /[1-3]/ }
+        
+        return modes[mode_indx.to_i - 1]
+      end
+      
+      def self.check_not_building_subspec(pod_to_switch)
+        if pod_to_switch.include?("/")
+          raise "\n\nCan't switch subspec #{pod_to_switch} refer to podspec name.\n\nUse `pod_builder switch #{pod_to_switch.split("/").first}` instead\n\n".red
+        end
+      end
+
+      private
+
+      def self.check_prebuilded(pod_name)
+        podspec_path = PodBuilder::basepath("PodBuilder.podspec")
+        unless File.exist?(podspec_path)
+          raise "Prebuilt podspec not found!".red
+        end
+
+        prebuilt_podspec = File.read(podspec_path)
+
+        if !prebuilt_podspec.include?("s.subspec '#{pod_name}' do |p|")
+          raise "\n\n#{pod_name} is not prebuilt.\n\nRun 'pod_builder build #{pod_name}'\n".red
+        end
+      end
+    end
+  end    
+end

data/lib/pod_builder/command/synch_podfile.rb

@@ -0,0 +1,30 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class SynchPodfile
+      def self.call(options)
+        Configuration.check_inited
+        PodBuilder::prepare_basepath
+        
+        update_repo = options[:update_repos] || false
+        installer, analyzer = Analyze.installer_at(PodBuilder::basepath, update_repo)
+
+        all_buildable_items = Analyze.podfile_items(installer, analyzer)
+
+        Dir.chdir(PodBuilder::project_path)
+
+        previous_podfile_content = File.read("Podfile")
+        Podfile::write_prebuilt(all_buildable_items, analyzer)        
+        updated_podfile_content = File.read("Podfile")
+
+        if previous_podfile_content != updated_podfile_content
+          system("pod install")
+        end
+        
+        return true
+      end
+    end
+  end
+end
+  

data/lib/pod_builder/configuration.rb

@@ -1,96 +1,178 @@
 require 'json'
 
 module PodBuilder  
-  class Configuration
-    class <<self
+  class Configuration  
+    # Remember to update README.md accordingly
+    DEFAULT_BUILD_SETTINGS = {
+      "ENABLE_BITCODE" => "NO",
+      "GCC_OPTIMIZATION_LEVEL" => "s",
+      "SWIFT_OPTIMIZATION_LEVEL" => "-Osize",
+      "SWIFT_COMPILATION_MODE" => "singlefile",
+    }.freeze
+    DEFAULT_SPEC_OVERRIDE = {
+      "Google-Mobile-Ads-SDK" => {
+        "module_name": "GoogleMobileAds"
+      }
+    }.freeze
+    DEFAULT_BUILD_SYSTEM = "Legacy".freeze # either Latest (New build system) or Legacy (Standard build system)
+    MIN_LFS_SIZE_KB = 256.freeze
+    
+    private_constant :DEFAULT_BUILD_SETTINGS
+    private_constant :DEFAULT_BUILD_SYSTEM
+    private_constant :MIN_LFS_SIZE_KB
+    
+    class <<self      
       attr_accessor :build_settings
       attr_accessor :build_settings_overrides
       attr_accessor :build_system
-      attr_accessor :config_file
       attr_accessor :base_path
-      attr_accessor :build_path
       attr_accessor :spec_overrides      
       attr_accessor :skip_licenses
-      attr_accessor :license_file_name
+      attr_accessor :skip_pods
+      attr_accessor :license_filename
+      attr_accessor :subspecs_to_split
+      attr_accessor :development_pods_paths
+      attr_accessor :build_path
+      attr_accessor :configuration_filename
+      attr_accessor :dev_pods_configuration_filename
+      attr_accessor :lfs_min_file_size
+      attr_accessor :update_lfs_gitattributes
     end
-
-    # Remember to update README.md
-    @build_settings = {
-      "ONLY_ACTIVE_ARCH" => "NO", 
-      "ENABLE_BITCODE" => "NO",
-      "CLANG_ENABLE_MODULE_DEBUGGING" => "NO",
-      "GCC_OPTIMIZATION_LEVEL" => "s",
-      "SWIFT_OPTIMIZATION_LEVEL" => "-Osize",
-      "SWIFT_COMPILATION_MODE" => "singlefile",
-    }  
+    
+    @build_settings = DEFAULT_BUILD_SETTINGS
     @build_settings_overrides = {}
-    @build_system = "Legacy" # either Latest (New build system) or Legacy (Standard build system)
-    @config_file = "PodBuilder.json"
+    @build_system = DEFAULT_BUILD_SYSTEM
     @base_path = "Frameworks" # Not nice. This value is used only for initial initization. Once config is loaded it will be an absolute path. FIXME
-    @build_path = "/tmp/pod_builder"
-    @spec_overrides = {}
+    @spec_overrides = DEFAULT_SPEC_OVERRIDE
     @skip_licenses = []
-    @license_file_name = "Pods-acknowledgements"               
-
+    @skip_pods = []
+    @license_filename = "Pods-acknowledgements"
+    @subspecs_to_split = []
+    @development_pods_paths = []
+    @build_path = "/tmp/pod_builder".freeze
+    @configuration_filename = "PodBuilder.json".freeze
+    @dev_pods_configuration_filename = "PodBuilderDevPodsPaths.json".freeze
+    @lfs_min_file_size = MIN_LFS_SIZE_KB
+    @update_lfs_gitattributes = false
+    
     def self.check_inited
-      count = Dir.glob("#{PodBuilder::home}/**/.pod_builder").count
-      raise "\n\nNot inited, run `pod_builder init`\n".red if count == 0
-      raise "\n\nToo many .pod_builder found `#{count}`\n".red if count > 1
+      raise "\n\nNot inited, run `pod_builder init`\n".red if podbuilder_path.nil?
     end
     
     def self.exists
-      return config_path ? File.exist?(config_path) : false
+      return !config_path.nil? && File.exist?(config_path)
     end
     
     def self.load
-      unless config_path
+      unless podbuilder_path
         return
       end
-
-      Configuration.base_path = File.dirname(config_path)
-
+      
+      Configuration.base_path = podbuilder_path
+      
       if exists
-        config = JSON.parse(File.read(config_path))
-        if config.has_key?("spec_overrides")
-          Configuration.spec_overrides = config["spec_overrides"]
+        json = JSON.parse(File.read(config_path))
+        if value = json["spec_overrides"]
+          if value.is_a?(Hash) && value.keys.count > 0
+            Configuration.spec_overrides = value
+          end
+        end
+        if value = json["skip_licenses"]
+          if value.is_a?(Array) && value.count > 0
+            Configuration.skip_licenses = value
+          end
+        end
+        if value = json["skip_pods"]
+          if value.is_a?(Array) && value.count > 0
+            Configuration.skip_pods = value
+          end
+        end
+        if value = json["build_settings"]
+          if value.is_a?(Hash) && value.keys.count > 0
+            Configuration.build_settings = value
+          end
+        end
+        if value = json["build_settings_overrides"]
+          if value.is_a?(Hash) && value.keys.count > 0
+            Configuration.build_settings_overrides = value
+          end
         end
-        if config.has_key?("skip_licenses")
-          Configuration.skip_licenses = config["skip_licenses"]
+        if value = json["build_system"]
+          if value.is_a?(String) && ["Latest", "Legacy"].include?(value)
+            Configuration.build_system = value
+          end
         end
-        if config.has_key?("build_settings")
-          Configuration.build_settings = config["build_settings"]
+        if value = json["license_filename"]
+          if value.is_a?(String) && value.length > 0
+            Configuration.license_filename = value
+          end
         end
-        if config.has_key?("build_settings_overrides")
-          Configuration.build_settings_overrides = config["build_settings_overrides"]
+        if value = json["subspecs_to_split"]
+          if value.is_a?(Array) && value.count > 0
+            Configuration.subspecs_to_split = value
+          end
         end
-        if config.has_key?("build_system")
-          Configuration.build_system = config["build_system"]
+        if value = json["update_lfs_gitattributes"]
+          if [TrueClass, FalseClass].include?(value.class)
+            Configuration.update_lfs_gitattributes = value
+          end
         end
-        if config.has_key?("license_file_name")
-          Configuration.license_file_name = config["license_file_name"]
+        if value = json["lfs_min_file_size_kb"]
+          if value.is_a?(Integer)
+            if value > 50
+              Configuration.lfs_min_file_size = value
+            else
+              puts "\n\n⚠️ Skipping `lfs_min_file_size` value too small".yellow
+            end
+          end
         end
+        
+        Configuration.build_settings.freeze
+      else
+        write
+      end
+      
+      dev_pods_configuration_path = File.join(Configuration.base_path, Configuration.dev_pods_configuration_filename)
+      
+      if File.exist?(dev_pods_configuration_path)
+        json = JSON.parse(File.read(dev_pods_configuration_path))
+        Configuration.development_pods_paths = json || []
+        Configuration.development_pods_paths.freeze
       end
     end
     
     def self.write
-      config = {
-        # nothing here yet
-      }
-      File.write(config_path, config.to_json)
+      config = {}
+      
+      config["spec_overrides"] = Configuration.spec_overrides
+      config["skip_licenses"] = Configuration.skip_licenses
+      config["skip_pods"] = Configuration.skip_pods
+      config["build_settings"] = Configuration.build_settings
+      config["build_settings_overrides"] = Configuration.build_settings_overrides
+      config["build_system"] = Configuration.build_system
+      config["license_filename"] = Configuration.license_filename
+      config["subspecs_to_split"] = Configuration.subspecs_to_split
+      config["update_lfs_gitattributes"] = Configuration.update_lfs_gitattributes
+      config["lfs_min_file_size_kb"] = Configuration.lfs_min_file_size
+      
+      File.write(config_path, JSON.pretty_generate(config))
     end
-
+    
     private 
-
+    
     def self.config_path
-      unless PodBuilder::xcodepath
-        return
+      unless path = podbuilder_path
+        return nil
       end
-
-      project_path = "#{PodBuilder::xcodepath}/#{base_path}/.pod_builder"
-      config_path = Dir.glob("#{PodBuilder::home}/**/.pod_builder").first
       
-      path = File.dirname(config_path || project_path)
-      return File.join(path, config_file)
+      return File.join(path, Configuration.configuration_filename)
+    end
+    
+    def self.podbuilder_path
+      paths = Dir.glob("#{PodBuilder::home}/**/.pod_builder")
+      raise "\n\nToo many .pod_builder found `#{paths.join("\n")}`\n".red if paths.count > 1
+      
+      return paths.count > 0 ? File.dirname(paths.first) : nil
     end
   end  
 end

data/lib/pod_builder/core.rb

@@ -9,6 +9,8 @@ require 'pod_builder/install'
 require 'pod_builder/configuration'
 require 'pod_builder/podspec'
 
+require 'core_ext/string'
+
 module PodBuilder  
   def self.safe_rm_rf(path)
     unless File.exist?(path)
@@ -30,45 +32,62 @@ module PodBuilder
       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
+  def self.project_path(child = "")
+    project = PodBuilder::find_xcodeworkspace
     
     return project ? "#{File.dirname(project)}/#{child}".gsub("//", "/").gsub(/\/$/, '') : nil
   end
 
-  def self.find_xcodeproject
-    return Dir.glob("#{home}/**/*.xcodeproj").detect { |x| !x.include?("/Pods/") && !x.include?(basepath) }
+  def self.find_xcodeproj
+    project_name = File.basename(find_xcodeworkspace, ".*")
+
+    xcodeprojects = Dir.glob("#{home}/**/#{project_name}.xcodeproj").select { |x| !x.include?("/Pods/") && !x.include?("/Sources/") && !x.include?(basepath) }
+    raise "xcodeproj not found!".red if xcodeprojects.count == 0
+    raise "Found multiple xcodeproj:\n#{xcodeprojects.join("\n")}".red if xcodeprojects.count > 1
+
+    return xcodeprojects.first
   end
 
   def self.find_xcodeworkspace
-    return Dir.glob("#{home}/**/*.xcworkspace").detect { |x| !x.include?("/Pods/") && !x.include?(basepath) }
+    xcworkspaces = Dir.glob("#{home}/**/*.xcworkspace").select { |x| !x.include?("/Pods/") && !x.include?("/Sources/") && !x.include?(basepath) && !x.include?(".xcodeproj/") }
+    raise "xcworkspace not found!".red if xcworkspaces.count == 0
+    raise "Found multiple xcworkspaces:\n#{xcworkspaces.join("\n")}".red if xcworkspaces.count > 1
+
+    return xcworkspaces.first
   end
 
   def self.prepare_basepath
-    project = PodBuilder::find_xcodeproject
-    if project
+    workspace_path = PodBuilder::find_xcodeworkspace
+    project_path = PodBuilder::find_xcodeproj
+    if workspace_path && project_path
       FileUtils.mkdir_p(basepath("Pods/Target Support Files"))
-      FileUtils.cp_r(project, basepath)   
+      FileUtils.cp_r(workspace_path, basepath)   
+      FileUtils.cp_r(project_path, 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"))
+    if path = PodBuilder::find_xcodeproj
+      PodBuilder::safe_rm_rf(basepath(File.basename(path)))      
     end
+    if path = PodBuilder::find_xcodeworkspace
+      PodBuilder::safe_rm_rf(basepath(File.basename(path)))      
+    end
+
+    PodBuilder::safe_rm_rf(basepath("Pods"))
+  end
+
+  private 
+  
+  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
 end