pod-builder 1.9.4 → 2.0.0.beta.23

data/lib/pod_builder/licenses.rb

@@ -12,19 +12,19 @@
       
         if current_licenses.count > 0 
           licenses_header = current_licenses.shift
-          raise "Unexpected license found in header" if licenses_header.has_key?("License")
+          raise "\n\nUnexpected license found in header".red if licenses_header.has_key?("License")
         end
         if current_licenses.count > 0 
           license_footer = current_licenses.pop
-          raise "Unexpected license found in footer" if license_footer.has_key?("License")
+          raise "\n\nUnexpected license found in footer".red if license_footer.has_key?("License")
         end
       end
 
       if licenses.count > 0
         licenses_header = licenses.shift
-        raise "Unexpected license found in header" if licenses_header.has_key?("License")
+        raise "\n\nUnexpected license found in header".red if licenses_header.has_key?("License")
         license_footer = licenses.pop
-        raise "Unexpected license found in footer" if license_footer.has_key?("License")
+        raise "\n\nUnexpected license found in footer".red if license_footer.has_key?("License")
 
         lincenses_titles = licenses.map { |x| x["Title"] }
         current_licenses.select! { |x| !lincenses_titles.include?(x["Title"]) }

data/lib/pod_builder/podfile.rb

@@ -1,13 +1,14 @@
+require 'json'
 module PodBuilder
   class Podfile
     PODBUILDER_LOCK_ACTION = ["raise \"\\n🚨  Do not launch 'pod install' manually, use `pod_builder` instead!\\n\" if !File.exist?('pod_builder.lock')"].freeze    
-    POST_INSTALL_ACTIONS = ["require 'pod_builder/podfile/post_actions'", "PodBuilder::Podfile::remove_target_support_duplicate_entries", "PodBuilder::Podfile::check_target_support_resource_collisions"].freeze
+    POST_INSTALL_ACTIONS = ["require 'pod_builder/podfile/post_actions'", "PodBuilder::Podfile::pod_builder_post_process"].freeze
     
     PRE_INSTALL_ACTIONS = ["Pod::Installer::Xcode::TargetValidator.send(:define_method, :verify_no_duplicate_framework_and_library_names) {}"].freeze
     private_constant :PRE_INSTALL_ACTIONS
 
-    def self.from_podfile_items(items, analyzer)
-      raise "no items" unless items.count > 0
+    def self.from_podfile_items(items, analyzer, build_configuration)
+      raise "\n\nno items".red unless items.count > 0
 
       sources = analyzer.sources
       
@@ -15,14 +16,17 @@ module PodBuilder
       podfile = File.read("#{cwd}/templates/build_podfile.template")
 
       platform = analyzer.instance_variable_get("@result").targets.first.platform
+
+      install_using_frameworks = install_using_frameworks(analyzer)      
+
+      podfile.sub!("%%%use_frameworks%%%", install_using_frameworks ? "use_frameworks!" : "") 
+
       podfile.sub!("%%%platform_name%%%", platform.name.to_s)
       podfile.sub!("%%%deployment_version%%%", platform.deployment_target.version)
 
       podfile.sub!("%%%sources%%%", sources.map { |x| "source '#{x.url}'" }.join("\n"))
 
-      build_configurations = items.map(&:build_configuration).uniq
-      raise "Found different build configurations in #{items}" if build_configurations.count != 1
-      podfile.sub!("%%%build_configuration%%%", build_configurations.first.capitalize)
+      podfile.sub!("%%%build_configuration%%%", build_configuration.capitalize)
 
       podfile_build_settings = ""
       
@@ -35,12 +39,25 @@ module PodBuilder
         
         # These settings need to be set as is to properly build frameworks
         build_settings['SWIFT_COMPILATION_MODE'] = 'wholemodule'
-        build_settings['CLANG_ENABLE_MODULE_DEBUGGING'] = 'NO'
         build_settings['ONLY_ACTIVE_ARCH'] = 'NO'
         build_settings['DEBUG_INFORMATION_FORMAT'] = "dwarf-with-dsym"
 
+        build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = platform.deployment_target.version # Fix compilation warnings on Xcode 12
+
+        # Don't store .pcm info in binary, see https://forums.swift.org/t/swift-behavior-of-gmodules-and-dsyms/23211/3
+        build_settings['CLANG_ENABLE_MODULE_DEBUGGING'] = 'NO'
+        build_settings['OTHER_SWIFT_FLAGS'] = "-Xfrontend -no-clang-module-breadcrumbs"
+
+        # Improve compile speed
+        build_settings['COMPILER_INDEX_STORE_ENABLE'] = 'NO'
+        build_settings['SWIFT_INDEX_STORE_ENABLE'] = 'NO'
+        build_settings['MTL_ENABLE_INDEX_STORE'] = 'NO'
+
         if Configuration.build_system == "Legacy"
           build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = "NO"
+          raise "\n\nCan't enable library evolution support with legacy build system!".red if Configuration.library_evolution_support
+        elsif Configuration.library_evolution_support
+          build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = "YES"
         end
 
         build_settings['SWIFT_VERSION'] = item_build_settings["SWIFT_VERSION"] || item.swift_version || project_swift_version(analyzer)
@@ -55,7 +72,7 @@ module PodBuilder
           if x.split("/").first == item.root_name
             next nil # remove dependency to parent spec
           end
-          if overridded_module_name = Configuration.spec_overrides.fetch(x, {})["module_name"]
+          if overridded_module_name = Configuration.spec_overrides.fetch(x, {})["module_name"] # this might no longer be needed after
             next overridded_module_name
           end
         }.compact
@@ -104,9 +121,6 @@ module PodBuilder
         }
       end
       
-      multiple_buildable_items = podfile_items.uniq { |t| t.root_name }
-      buildable_items = podfile_items.reject { |t| multiple_buildable_items.map(&:root_name).include?(t.root_name) && t.is_external == false }
-
       result_targets = analyzer.instance_variable_get("@result").targets.map(&:name) 
       podfile_content = ["# Autogenerated by PodBuilder (https://github.com/Subito-it/PodBuilder)", "# Please don't modify this file", "\n"]
       podfile_content += analyzer.podfile.sources.map { |x| "source '#{x}'" }
@@ -132,7 +146,7 @@ module PodBuilder
 
         specifications.each do |spec|
           item = podfile_items.detect { |x| x.name == spec.name }
-          if buildable_items.map(&:name).include?(spec.name)
+          if podfile_items.map(&:name).include?(spec.name)
             podfile_content.push("\t#{item.entry}")
           end
         end
@@ -143,9 +157,16 @@ module PodBuilder
       File.write(podfile_restore_path, podfile_content.join("\n"))
     end
 
-    def self.write_prebuilt(all_buildable_items, analyzer)  
+    def self.write_prebuilt(all_buildable_items, analyzer)
+      if Configuration.react_native_project
+        return write_prebuilt_react_native(all_buildable_items, analyzer)
+      end
+  
       puts "Updating Application Podfile".yellow
 
+      explicit_deps = analyzer.explicit_pods()
+      explicit_deps.map! { |t| all_buildable_items.detect { |x| x.name == t.name } }
+      explicit_deps.uniq!
       podbuilder_podfile_path = PodBuilder::basepath("Podfile")
       rel_path = Pathname.new(podbuilder_podfile_path).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
         
@@ -160,22 +181,33 @@ module PodBuilder
           next
         end
 
-        if pod_name = pod_definition_in(line, true)
+        if pod_name = pod_definition_in(line, true)      
           if podfile_item = all_buildable_items.detect { |x| x.name == pod_name }
-            if Podspec.include?(podfile_item.name)
-              if podfile_item.vendored_framework_path.nil?
-                marker = podfile_item.prebuilt_marker()
-
-                podfile_item_dependency_items = all_buildable_items.select { |x| podfile_item.dependency_names.include?(x.name) && x.vendored_framework_path.nil? == false }
-                if podfile_item_dependency_items.count > 0
-                  prebuilt_lines += podfile_item_dependency_items.map { |x| "#{line.detect_indentation}#{x.prebuilt_entry(include_pb_entry = false)}#{marker}\n" }.uniq
-                else
-                  prebuilt_lines.push(line)
-                end
-              else 
-                prebuilt_lines.push("#{line.detect_indentation}#{podfile_item.prebuilt_entry}\n")
+            marker = podfile_item.prebuilt_marker()
+
+            non_explicit_dependencies = podfile_item.recursive_dependencies(all_buildable_items) - explicit_deps
+            non_explicit_dependencies_root_names = non_explicit_dependencies.map(&:root_name).uniq.filter { |t| t != podfile_item.root_name }
+            non_explicit_dependencies = non_explicit_dependencies_root_names.map { |x| 
+              if item = all_buildable_items.detect { |t| x == t.name }
+                item                    
+              else
+                item = all_buildable_items.detect { |t| x == t.root_name }
+              end
+            }.compact
+            
+            non_explicit_dependencies.each do |dep|
+              dep_item = all_buildable_items.detect { |x| x.name == dep.name }
+
+              if File.exist?(dep_item.prebuilt_podspec_path) && !dep_item.is_prebuilt 
+                pod_name = dep_item.prebuilt_entry(false, false)
+                prebuilt_lines.push("#{line.detect_indentation}#{pod_name}#{marker}\n")
               end
 
+              explicit_deps.push(dep)
+            end       
+
+            if File.exist?(podfile_item.prebuilt_podspec_path) && !podfile_item.is_prebuilt 
+              prebuilt_lines.push("#{line.detect_indentation}#{podfile_item.prebuilt_entry}\n")
               next
             end
           end
@@ -184,20 +216,45 @@ module PodBuilder
         prebuilt_lines.push(line)
       end
 
+      podfile_content = prebuilt_lines.join
+
+      podfile_content = Podfile.update_path_entries(podfile_content, Podfile.method(:podfile_path_transform))
+      podfile_content = Podfile.update_project_entries(podfile_content, Podfile.method(:podfile_path_transform))
+      podfile_content = Podfile.update_require_entries(podfile_content, Podfile.method(:podfile_path_transform))
+
+      podfile_content = add_pre_install_actions(podfile_content)
+      podfile_content = add_post_install_checks(podfile_content)
+
       project_podfile_path = PodBuilder::project_path("Podfile")
-      File.write(project_podfile_path, prebuilt_lines.join)
-      Podfile.update_path_entires(project_podfile_path, false)
-      Podfile.update_project_entries(project_podfile_path, false)
+      File.write(project_podfile_path, podfile_content)
+    end
+
+    def self.write_prebuilt_react_native(all_buildable_items, analyzer)  
+      puts "Updating Application Podfile".yellow
+
+      podbuilder_podfile_path = PodBuilder::basepath("Podfile")
+      rel_path = Pathname.new(podbuilder_podfile_path).relative_path_from(Pathname.new(PodBuilder::project_path)).to_s
+
+      podfile_content = ["# Autogenerated by PodBuilder (https://github.com/Subito-it/PodBuilder)\n", "# Any change to this file should be done on #{rel_path}\n", "\n"].join
+      podfile_content += analyzer.podfile.pb_to_s(all_buildable_items)
 
-      add_pre_install_actions(project_podfile_path)
-      add_post_install_checks(project_podfile_path)
+      podfile_content = Podfile.update_path_entries(podfile_content, PodfileCP.method(:podfile_path_transform))
+      podfile_content = Podfile.update_project_entries(podfile_content, Podfile.method(:podfile_path_transform))
+      podfile_content = Podfile.update_require_entries(podfile_content, Podfile.method(:podfile_path_transform))
+
+      podfile_content = add_pre_install_actions(podfile_content)
+      podfile_content = add_post_install_checks(podfile_content)
+
+      project_podfile_path = PodBuilder::project_path("Podfile")
+      File.write(project_podfile_path, podfile_content)
     end
 
     def self.install
       puts "Running pod install".yellow
 
       Dir.chdir(PodBuilder::project_path) do
-        system("pod install;")
+        bundler_prefix = Configuration.use_bundler ? "bundle exec " : ""
+        system("#{bundler_prefix}pod install;")
       end
     end
 
@@ -206,10 +263,6 @@ module PodBuilder
       return stripped_line.gsub("\"", "'").gsub(" ", "").gsub("\t", "").gsub("\n", "")
     end
 
-    def self.add_install_block(podfile_path)
-      add(PODBUILDER_LOCK_ACTION, "pre_install", podfile_path)
-    end
-
     def self.pod_definition_in(line, include_commented)
       stripped_line = strip_line(line)
       matches = stripped_line.match(/(^pod')(.*?)(')/)
@@ -253,6 +306,8 @@ module PodBuilder
         return nil
       end
 
+      puts "Checking Podfile.restore".yellow
+
       podfile_restore_path = PodBuilder::basepath("Podfile.restore")
       unless File.exist?(podfile_restore_path)
         return
@@ -293,16 +348,62 @@ module PodBuilder
 
         if stripped_line.match(/(pod')(.*?)(')/) != nil
           starting_def_found = stripped_line.start_with?("def") && (line.match("\s*def\s") != nil)
-          raise "Unsupported single line def/pod. `def` and `pod` shouldn't be on the same line, please modify the following line:\n#{line}" if starting_def_found
+          raise "\n\nUnsupported single line def/pod. `def` and `pod` shouldn't be on the same line, please modify the following line:\n#{line}".red if starting_def_found
+        end
+      end
+    end
+
+    def self.resolve_pod_names(names, all_buildable_items)
+      resolved_names = []
+
+      names.each do |name|
+        if item = all_buildable_items.detect { |t| t.root_name.downcase == name.downcase }
+          resolved_names.push(item.root_name)
         end
       end
+
+      return resolved_names.uniq
+    end
+
+    def self.resolve_pod_names_from_podfile(names)
+      resolved_names = []
+
+      # resolve potentially wrong pod name case
+      podfile_path = PodBuilder::basepath("Podfile")
+      content = File.read(podfile_path)
+        
+      current_section = ""
+      content.each_line do |line|
+        matches = line.gsub("\"", "'").match(/pod '(.*?)'/)
+        if matches&.size == 2
+          if resolved_name = names.detect { |t| matches[1].split("/").first.downcase == t.downcase }
+            resolved_names.push(matches[1].split("/").first)
+          end
+        end
+      end
+
+      resolved_names.uniq
     end
 
     private
 
-    def self.indentation_from_file(path)
-      content = File.read(path)
+    def self.podfile_path_transform(path)
+      use_absolute_paths = false
+      podfile_path = PodBuilder::project_path("Podfile")
+      original_basepath = PodBuilder::basepath
+
+      podfile_base_path = Pathname.new(File.dirname(podfile_path))
 
+      original_path = Pathname.new(File.join(original_basepath, path))
+      replace_path = original_path.relative_path_from(podfile_base_path)
+      if use_absolute_paths
+        replace_path = replace_path.expand_path(podfile_base_path)
+      end
+
+      return replace_path
+    end  
+
+    def self.indentation_from_string(content)
       lines = content.split("\n").select { |x| !x.empty? }
 
       if lines.count > 2
@@ -323,13 +424,13 @@ module PodBuilder
     def self.project_swift_version(analyzer)
       swift_versions = analyzer.instance_variable_get("@result").targets.map { |x| x.target_definition.swift_version }.compact.uniq
 
-      raise "Found different Swift versions in targets. Expecting one, got `#{swift_versions}`" if swift_versions.count > 1
+      raise "\n\nFound different Swift versions in targets. Expecting one, got `#{swift_versions}`".red if swift_versions.count > 1
 
       return swift_versions.first || PodBuilder::system_swift_version
     end
 
     def self.podfile_items_at(podfile_path, include_prebuilt = false)
-      raise "Expecting basepath folder!" if !File.exist?(PodBuilder::basepath("Podfile"))
+      raise "\n\nExpecting basepath folder!".red if !File.exist?(PodBuilder::basepath("Podfile"))
 
       if File.basename(podfile_path) != "Podfile"
         File.rename(PodBuilder::basepath("Podfile"), PodBuilder::basepath("Podfile.tmp"))
@@ -358,18 +459,20 @@ module PodBuilder
       return buildable_items
     end
 
-    def self.add_pre_install_actions(podfile_path)
-      add(PRE_INSTALL_ACTIONS + [" "], "pre_install", podfile_path)
+    def self.add_install_block(podfile_content)
+      return add(PODBUILDER_LOCK_ACTION, "pre_install", podfile_content)
     end
 
-    def self.add_post_install_checks(podfile_path)
-      add(POST_INSTALL_ACTIONS + [" "], "post_install", podfile_path)
+    def self.add_pre_install_actions(podfile_content)
+      return add(PRE_INSTALL_ACTIONS + [" "], "pre_install", podfile_content)
     end
 
-    def self.add(entries, marker, podfile_path)
-      podfile_content = File.read(podfile_path)
+    def self.add_post_install_checks(podfile_content)
+      return add(POST_INSTALL_ACTIONS + [" "], "post_install", podfile_content)
+    end
 
-      file_indentation = indentation_from_file(podfile_path)
+    def self.add(entries, marker, podfile_content)
+      file_indentation = indentation_from_string(podfile_content)
 
       entries = entries.map { |x| "#{file_indentation}#{x}\n"}
 
@@ -386,55 +489,48 @@ module PodBuilder
       end
 
       if !marker_found
+        if podfile_lines.last.strip.length > 0
+          podfile_lines.push("\n")
+        end
         podfile_lines.push("\n#{marker} do |installer|\n")
         podfile_lines.push(entries)
         podfile_lines.push("end\n")
       end
 
-      File.write(podfile_path, podfile_lines.join)
+      return podfile_lines.join
     end
     
-    def self.update_path_entires(podfile_path, use_absolute_paths = false, path_base = PodBuilder::basepath(""))
-      podfile_content = File.read(podfile_path)
-      
-      base_path = Pathname.new(File.dirname(podfile_path))
-      regex = "(\s*pod\s*['|\"])(.*?)(['|\"])(.*?)(:path\s*=>\s*['|\"])(.*?)(['|\"])"
+    def self.update_path_entries(podfile_content, path_transform)
+      regex = "(\s*pod\s*['|\"])(.*?)(['|\"])(.*?):(path|podspec)(\s*=>\s*['|\"])(.*?)(['|\"])"
 
       podfile_lines = []
       podfile_content.each_line do |line|
         stripped_line = strip_line(line)
         matches = line.match(/#{regex}/)
 
-        if matches&.size == 8 && !stripped_line.start_with?("#")
+        if matches&.size == 9 && !stripped_line.start_with?("#")
           pod_name = matches[2]
-          path = matches[6]
+          path = matches[7]
 
           is_absolute = ["~", "/"].include?(path[0])
-          unless !pod_name.start_with?("PodBuilder/") && !is_absolute
+          unless !PodBuilder::prebuiltpath.end_with?(path) && !is_absolute
             podfile_lines.push(line)
             next
           end
 
-          original_path = Pathname.new(File.join(path_base, path))
-          replace_path = original_path.relative_path_from(base_path)
-          if use_absolute_paths
-            replace_path = replace_path.expand_path(base_path)
-          end
+          replace_path = path_transform.call(path)
                     
-          updated_path_line = line.gsub(/#{regex}/, '\1\2\3\4\5' + replace_path.to_s + '\7\8')
+          updated_path_line = line.gsub(/#{regex}/, '\1\2\3\4:\5\6' + replace_path.to_s + '\8\9')
           podfile_lines.push(updated_path_line)
         else
           podfile_lines.push(line)
         end
       end
 
-      File.write(podfile_path, podfile_lines.join)
+      return podfile_lines.join
     end
 
-    def self.update_project_entries(podfile_path, use_absolute_paths = false, path_base = PodBuilder::basepath(""))
-      podfile_content = File.read(podfile_path)
-      
-      base_path = Pathname.new(File.dirname(podfile_path))
+    def self.update_project_entries(podfile_content, path_transform)      
       regex = "(\s*project\s*['|\"])(.*?)(['|\"])"
 
       podfile_lines = []
@@ -451,11 +547,36 @@ module PodBuilder
             next
           end
 
-          original_path = Pathname.new(File.join(path_base, path))
-          replace_path = original_path.relative_path_from(base_path)
-          if use_absolute_paths
-            replace_path = replace_path.expand_path(base_path)
+          replace_path = path_transform.call(path)
+                    
+          updated_path_line = line.gsub(/#{regex}/, '\1' + replace_path.to_s + '\3\4')
+          podfile_lines.push(updated_path_line)
+        else
+          podfile_lines.push(line)
+        end
+      end
+
+      return podfile_lines.join
+    end
+
+    def self.update_require_entries(podfile_content, path_transform)
+      regex = "(\s*require_relative\s*['|\"])(.*?)(['|\"])"
+
+      podfile_lines = []
+      podfile_content.each_line do |line|
+        stripped_line = strip_line(line)
+        matches = line.match(/#{regex}/)
+
+        if matches&.size == 4 && !stripped_line.start_with?("#")
+          path = matches[2]
+
+          is_absolute = ["~", "/"].include?(path[0])
+          unless !is_absolute
+            podfile_lines.push(line)
+            next
           end
+
+          replace_path = path_transform.call(path)
                     
           updated_path_line = line.gsub(/#{regex}/, '\1' + replace_path.to_s + '\3\4')
           podfile_lines.push(updated_path_line)
@@ -464,7 +585,113 @@ module PodBuilder
         end
       end
 
-      File.write(podfile_path, podfile_lines.join)
+      return podfile_lines.join
+    end
+
+    def self.prepare_for_react_native_write_pb_configuration(podfile_content)
+      base = File.expand_path(File.join(PodBuilder::project_path, ".."))
+      bin_js = Dir.glob("#{base}/node_modules/@react-native-community/cli/build/bin.js")
+
+      raise "\n\nReact native cli bin_js not found!".red unless bin_js.count == 1
+      bin_js = bin_js.first
+
+      config_dest_path = PodBuilder::basepath("rn_config.json")
+
+      raise "\n\nFailed generating react native configuration file".red unless system("node '#{bin_js}' config > #{config_dest_path}")
+      
+      content = File.read(config_dest_path)
+
+      content.gsub!(PodBuilder::project_path, "..")
+      content.gsub!(File.expand_path(PodBuilder::project_path("..")), "../..")
+
+      json = JSON.parse(content)
+      begin
+        json["project"]["ios"]["sourceDir"] = "./"
+        json["project"]["ios"]["podfile"] = "./"  
+      rescue => exception
+        raise "\n\nFailed updating react native configuration json".red
+      end
+      
+      File.write(config_dest_path, JSON.pretty_generate(json))
+
+      return "rn_config = JSON.load(File.read(\"rn_config.json\")) # pb added\n\n" + podfile_content
+    end
+
+    def self.prepare_for_react_native_rn_pods_file(podfile_content)
+      lines = []
+      podfile_content.each_line do |line|
+        if line.include?("use_react_native!")
+          matches = line.match(/(\s*)/)
+          unless matches&.size == 2
+            return podfile_content
+          end
+    
+          indentation = matches[1]
+          lines.push("#{indentation}use_react_native!(:path => rn_config[\"reactNativePath\"]) # pb added\n")
+          lines.push("#{indentation}# #{line.strip} # pb removed\n")
+        else
+          lines.push(line)
+        end
+      end
+
+      return lines.join
+    end
+
+    def self.prepare_for_react_native_native_modules_file(podfile_content)
+      lines = []
+      podfile_content.each_line do |line|
+        if line.include?("use_native_modules!")
+          matches = line.match(/(\s*)/)
+          unless matches&.size == 2
+            return podfile_content
+          end
+    
+          indentation = matches[1]
+          lines.push("#{indentation}use_native_modules!(rn_config) # pb added\n")
+          lines.push("#{indentation}# #{line.strip} # pb removed\n")
+        else
+          lines.push(line)
+        end
+      end
+
+      return lines.join
+    end
+
+    def self.prepare_for_react_native(podfile_content)
+      original_podfile_content = podfile_content.dup
+
+      podfile_content = prepare_for_react_native_write_pb_configuration(podfile_content)
+      content = prepare_for_react_native_rn_pods_file(podfile_content)
+      if content == podfile_content
+        return original_podfile_content
+      end
+      podfile_content = content
+      content = prepare_for_react_native_native_modules_file(podfile_content)
+      if content == podfile_content
+        return original_podfile_content
+      end
+      podfile_content = content
+
+      Configuration.build_using_repo_paths = true
+      Configuration.react_native_project = true
+
+      return podfile_content
+    end
+
+    def self.install_using_frameworks(analyzer)
+      target_settings = analyzer.podfile.target_definition_list.map(&:uses_frameworks?).uniq
+      if target_settings.count == 1
+        if target_settings.first == false
+          raise "\n\nOnly framework packaging currently supported. Please add 'use_frameworks!' at Podfile root level (not nested in targets)".red
+        end
+        return target_settings.first
+      elsif target_settings.count > 1
+        raise "\n\n'use_frameworks!' should be declared only once at Podfile root level (not nested in targets)".red
+      else
+        raise "\n\nFailed detecting use_frameworks!"
+      end
+
+      return true
     end
   end
 end