pod-builder 1.9.4 → 2.0.0.beta.18

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,86 +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.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.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|
@@ -291,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
@@ -320,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)
@@ -333,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)

data/lib/pod_builder/command/clear_lldbinit.rb

@@ -16,7 +16,7 @@ module PodBuilder
         end
             
         lldbinit_path = File.expand_path(argument_pods[0])
-        lldbinit_content = File.exists?(lldbinit_path) ? File.read(lldbinit_path) : ""
+        lldbinit_content = File.exist?(lldbinit_path) ? File.read(lldbinit_path) : ""
 
         lldbinit_lines = []
         skipNext = false

data/lib/pod_builder/command/deintegrate.rb

@@ -39,7 +39,8 @@ module PodBuilder
         PodBuilder::safe_rm_rf(Configuration.base_path)
 
         Dir.chdir(PodBuilder::project_path)
-        system("pod install;")  
+        bundler_prefix = Configuration.use_bundler ? "bundle exec " : ""
+        system("#{bundler_prefix}pod install;")
 
         license_base = PodBuilder::project_path(Configuration.license_filename)
         FileUtils.rm_f("#{license_base}.plist")

data/lib/pod_builder/command/generate_lfs.rb

@@ -13,8 +13,8 @@ module PodBuilder
         gitattributes_excludes = ["*.h", "*.hh", "*.m", "*.mm", "*.i", "*.c", "*.cc", "*.cxx", "*.cpp", "*.def", "*.inc", "*.inl", "*.swift", "*.modulemap", "*.strings", "*.png", "*.jpg", "*.gif", "*.html", "*.htm", "*.js", "*.json", "*.xml", "*.txt", "*.md", "*.rb", "*.sh", "*.py", "*.plist", "*.resolved", ".*", "README*", "LICENSE*"]
 
         gitattributes_includes_frameworks = ["**/* filter=lfs diff=lfs merge=lfs !text"]
-        write_attributes(PodBuilder::basepath("Rome"), gitattributes_includes_frameworks, gitattributes_excludes)
-        write_attributes(PodBuilder::basepath("dSYM"), gitattributes_includes_frameworks, gitattributes_excludes)
+        write_attributes(PodBuilder::prebuiltpath, gitattributes_includes_frameworks, gitattributes_excludes)
+        write_attributes(PodBuilder::dsympath, gitattributes_includes_frameworks, gitattributes_excludes)
 
         if Configuration.lfs_include_pods_folder
           gitattributes_includes_pods = ["**/*.framework/**/* filter=lfs diff=lfs merge=lfs !text"]

data/lib/pod_builder/command/install_sources.rb

@@ -12,7 +12,7 @@ module PodBuilder
         framework_items = Analyze.podfile_items(installer, analyzer).select { |x| !x.is_prebuilt }
         podspec_names = framework_items.map(&:podspec_name)
 
-        base_path = PodBuilder::basepath("Rome")
+        base_path = PodBuilder::prebuiltpath
         framework_files = Dir.glob("#{base_path}/**/*.framework")
         
         framework_files.each do |path|

data/lib/pod_builder/command/switch.rb

@@ -12,108 +12,130 @@ module PodBuilder
         unless argument_pods.count > 0 
           return -1
         end
-        unless argument_pods.count == 1
-          raise "\n\nSpecify a single pod to switch\n\n".red 
-        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)
+        pod_names_to_switch = []
+        argument_pods.each do |pod|
+          pod_name_to_switch = pod
+          pod_name_to_switch = Podfile::resolve_pod_names_from_podfile([pod_name_to_switch]).first
+          raise "\n\nDid not find pod '#{pod}'" if pod_name_to_switch.nil?
+          
+          check_not_building_subspec(pod_name_to_switch)  
 
-          if options[:switch_mode].nil?
-            return 0
-          end
-        end
-
-        if options[:switch_mode] == "prebuilt"
-          check_prebuilded(pod_name_to_switch)
+          pod_names_to_switch.push(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 }
+        
+        pod_names_to_switch.each do |pod_name_to_switch|
+          development_path = ""
+          default_entries = Hash.new
+
+          case options[:switch_mode]
+          when "development"
+            development_path = find_podspec(pod_name_to_switch)          
+          when "prebuilt"
+            podfile_path = PodBuilder::basepath("Podfile.restore")
+            content = File.read(podfile_path)
+            if !content.include?("pod '#{pod_name_to_switch}")
+              raise "\n\n'#{pod_name_to_switch}' does not seem to be prebuit!"
             end
-
-            unless podfile_items.count > 0
-              raise "\n\nPod `#{pod_name_to_switch}` wasn't found in Podfile\n".red
+          when "default"
+            podfile_path = PodBuilder::basepath("Podfile")
+            content = File.read(podfile_path)
+              
+            current_section = ""
+            content.each_line do |line|
+              stripped_line = line.strip
+              if stripped_line.start_with?("def ") || stripped_line.start_with?("target ")
+                current_section = line.split(" ")[1]
+                next
+              end
+    
+              matches = line.gsub("\"", "'").match(/pod '(.*?)',(.*)/)
+              if matches&.size == 3
+                if matches[1].split("/").first == pod_name_to_switch
+                  default_entries[current_section] = line
+                end  
+              end
             end
+    
+            raise "\n\n'#{pod_name_to_switch}' not found in #{podfile_path}" if default_entries.keys.count == 0
+          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
+          podfile_path = PodBuilder::project_path("Podfile")
+          content = File.read(podfile_path)
+          
+          lines = []
+          current_section = ""
+          content.each_line do |line|
+            stripped_line = line.strip
+            if stripped_line.start_with?("def ") || stripped_line.start_with?("target ")
+              current_section = line.split(" ")[1]
             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
+            matches = line.gsub("\"", "'").match(/pod '(.*?)',(.*)/)
+            if matches&.size == 3
+              if matches[1].split("/").first == pod_name_to_switch
+                case options[:switch_mode]
+                when "prebuilt"
+                  indentation = line.split("pod '").first
+                  rel_path = Pathname.new(PodBuilder::prebuiltpath).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
+                  prebuilt_line = "#{indentation}pod '#{matches[1]}', :path => '#{rel_path}'\n"
+                  if line.include?("# pb<") && marker = line.split("# pb<").last
+                    prebuilt_line = prebuilt_line.chomp("\n") + " # pb<#{marker}"
+                  end
+                  lines.append(prebuilt_line)
+                  next
+                when "development"
+                  indentation = line.split("pod '").first
+                  rel_path = Pathname.new(development_path).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
+                  development_line = "#{indentation}pod '#{matches[1]}', :path => '#{rel_path}'\n"
+                  if line.include?("# pb<") && marker = line.split("# pb<").last
+                    development_line = development_line.chomp("\n") + " # pb<#{marker}"
+                  end
+
+                  lines.append(development_line)
+                  next
+                when "default"
+                  if default_line = default_entries[current_section]
+                    if line.include?("# pb<") && marker = line.split("# pb<").last
+                      default_line = default_line.chomp("\n") + " # pb<#{marker}"
+                    end
+                    lines.append(default_line)
+                    next
+                  elsif
+                    raise "Line for pod '#{matches[1]}' in section '#{current_section}' not found in PodBuilder's Podfile"
+                  end
+                else
+                  raise "Unsupported mode '#{options[:switch_mode]}'"
+                end
+              end  
             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)
-              podfile_item.is_external = true
-
-              line = indentation + podfile_item.entry + "\n"
-            when "default"
-              line = indentation + podfile_item.entry + "\n"
-            else
-              break
-            end
+            lines.append(line)
           end
 
-          pod_lines.push(line)
+          File.write(podfile_path, lines.join)
         end
         
-        File.write(podfile_path, pod_lines.join)
-        
         Dir.chdir(PodBuilder::project_path)
-        system("pod install")
+        bundler_prefix = Configuration.use_bundler ? "bundle exec " : ""
+        system("#{bundler_prefix}pod install;")
 
         return 0
       end
       
       private     
 
-      def self.find_podspec(podfile_item)
+      def self.find_podspec(podname)
         unless Configuration.development_pods_paths.count > 0
           raise "\n\nPlease add the development pods path(s) 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*"))
+          if Pathname.new(path).relative?
+            path = PodBuilder::basepath(path)
+          end
+          podspec = Dir.glob(File.expand_path("#{path}/**/#{podname}*.podspec*"))
           podspec.select! { |x| !x.include?("/Local Podspecs/") }
           podspec.select! { |x| Dir.glob(File.join(File.dirname(x), "*")).count > 1 } # exclude podspec folder (which has one file per folder)
           if podspec.count > 0
@@ -123,39 +145,17 @@ module PodBuilder
         end
 
         if podspec_path.nil?
-          raise "\n\nCouln't find `#{podfile_item.root_name}` sources in the following specified development pod paths: #{Configuration.development_pods_paths.join("\n")}\n".red
+          raise "\n\nCouln't find `#{podname}` sources in the following specified development pod paths:\n#{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 == 4
-          raise "\n\nFailed matching pod name\n".red
-        end
-
-        default_entry = matches[3].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)
-        if !Podspec.include?(pod_name)
-          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/sync_podfile.rb

@@ -21,7 +21,8 @@ module PodBuilder
         Licenses::write([], all_buildable_items)
 
         if previous_podfile_content != updated_podfile_content
-          system("pod install")
+          bundler_prefix = Configuration.use_bundler ? "bundle exec " : ""
+          system("#{bundler_prefix}pod install;")
         end
         
         return 0

data/lib/pod_builder/command/update.rb

@@ -36,7 +36,7 @@ module PodBuilder
         ARGV.clear
         pods_to_update.each { |x| ARGV << x }
 
-        options[:auto_resolve_dependencies] = true
+        # options[:auto_resolve_dependencies] = true
         return PodBuilder::Command::Build.call(options)
       end              
     end

data/lib/pod_builder/command/update_lldbinit.rb

@@ -22,7 +22,7 @@ module PodBuilder
         app_podfile_content = File.read(PodBuilder::project_path("Podfile"))
 
         lldbinit_path = File.expand_path(argument_pods[0])
-        lldbinit_content = File.exists?(lldbinit_path) ? File.read(lldbinit_path) : ""
+        lldbinit_content = File.exist?(lldbinit_path) ? File.read(lldbinit_path) : ""
         status_hash = podfiles_status_hash(app_podfile_content, podfile_restore_content)
         if lldbinit_content.include?("# <pb_md5:#{base_path}:#{status_hash}")
           puts "\n\n🎉 already in sync!\n".green
@@ -125,7 +125,7 @@ module PodBuilder
         puts "Writing #{lldbinit_path}".yellow
 
         FileUtils.touch(lldbinit_path)
-        raise "\n\nDestination file should be a file" unless File.exists?(lldbinit_path)
+        raise "\n\nDestination file should be a file" unless File.exist?(lldbinit_path)
 
         lldbinit_lines = []
         skipNext = false