pod-builder 0.1.4

data/lib/pod_builder/command/build_all.rb

@@ -0,0 +1,15 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class BuildAll
+      def self.call(options)
+        Configuration.check_inited
+        PodBuilder::prepare_basepath
+
+        ARGV << "*"
+        return Command::Build::call(options)
+      end
+    end
+  end
+end

data/lib/pod_builder/command/clean.rb

@@ -0,0 +1,80 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class Clean
+      def self.call(options)
+        Configuration.check_inited
+        PodBuilder::prepare_basepath
+
+        update_repo = options[:update_repos] || false
+        installer, analyzer = Analyze.installer_at(PodBuilder::basepath)
+        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)
+
+        base_path = PodBuilder::basepath("Rome")
+        framework_files = Dir.glob("#{base_path}/**/*.framework")
+        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")
+        clean(dSYM_files_iphone, base_path, rel_paths)
+
+        base_path = PodBuilder::basepath("dSYM/iphonesimulator")
+        dSYM_files_sim = Dir.glob("#{base_path}/**/*.dSYM")
+        clean(dSYM_files_sim, base_path, rel_paths)
+
+        clean_sources(podspec_names)
+
+        puts "\n\n🎉 done!\n".green
+        return true
+      end
+
+      def self.clean_sources(podspec_names)
+        puts "Cleaning sources".blue
+        
+        base_path = PodBuilder::basepath("Sources")
+
+        repo_paths = Dir.glob("#{base_path}/*")
+
+        repo_paths.each do |path|
+          podspec_name = File.basename(path)
+
+          unless !podspec_names.include?(podspec_name)
+            next
+          end
+
+          puts "Deleting sources #{path}".blue
+          FileUtils.rm_rf(path)
+        end
+      end
+
+      private
+
+      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
+
+        files.each do |rel_path, path|
+          unless !rel_paths.include?(rel_path)
+            next
+          end
+
+          puts "Deleting #{path}".blue
+          FileUtils.rm_rf(path)
+        end
+
+        current_dir = Dir.pwd
+        Dir.chdir(base_path)
+        # Before deleting anything be sure we're in a git repo
+        h = `git rev-parse --show-toplevel`.strip()
+        raise "\n\nNo git repository found in current folder `#{Dir.pwd}`!\n".red if h.empty?    
+        system("find . -type d -empty -delete") # delete empty folders
+        Dir.chdir(current_dir)
+      end
+    end
+  end
+end

data/lib/pod_builder/command/deintegrate.rb

@@ -0,0 +1,51 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class Deintegrate
+      def self.call(options)
+        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")
+
+        FileUtils.cp(prebuilt_podfile, restored_podfile)
+
+        podfile_content = File.read(restored_podfile)
+        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 pre_install_indx == -1
+              pre_install_indx = index
+            end
+          else
+            podfile_lines.push(line)
+          end
+        end
+
+        if pre_install_indx > 0 &&
+           Podfile::strip_line(podfile_lines[pre_install_indx - 1]).include?("pre_installdo|") &&
+           Podfile::strip_line(podfile_lines[pre_install_indx]) == "end"
+           podfile_lines.delete_at(pre_install_indx)
+           podfile_lines.delete_at(pre_install_indx - 1)
+        end
+
+        FileUtils.rm_f(restored_podfile)
+        File.write(restored_podfile, podfile_lines.join)
+
+        PodBuilder::safe_rm_rf(Configuration.base_path)
+
+        Dir.chdir(PodBuilder::xcodepath)
+        system("pod deintegrate; pod install;")  
+
+        license_base = PodBuilder::xcodepath(Configuration.license_file_name)
+        FileUtils.rm_f("#{license_base}.plist")
+        FileUtils.rm_f("#{license_base}.md")
+
+        puts "\n\n🎉 done!\n".green
+        return true
+      end
+    end
+  end
+end

data/lib/pod_builder/command/generate_podspec.rb

@@ -0,0 +1,17 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class GeneratePodspec
+      def self.call(options)
+        Configuration.check_inited
+        PodBuilder::prepare_basepath
+
+        Podspec::generate
+
+        puts "\n\n🎉 done!\n".green
+        return true
+      end
+    end
+  end
+end

data/lib/pod_builder/command/init.rb

@@ -0,0 +1,86 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    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?
+        
+        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]))
+        end
+
+        FileUtils.mkdir_p(options[:prebuild_path])
+        FileUtils.mkdir_p("#{options[:prebuild_path]}/.pod_builder")
+        FileUtils.touch("#{options[:prebuild_path]}/.pod_builder/pod_builder")
+        
+        File.write("#{options[:prebuild_path]}/.gitignore", "Pods/\n*.xcodeproj\nSources\n")
+
+        project_podfile_path = PodBuilder::xcodepath("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)
+
+        home_path = Pathname.new(PodBuilder::xcodepath)
+        prebuilt_path = Pathname.new(options[:prebuild_path])
+        relative_path = prebuilt_path.relative_path_from(home_path)
+
+        Configuration.base_path = relative_path
+
+        Configuration.write
+
+        puts "\n\n🎉 done!\n".green
+        return true
+      end
+
+      private
+
+      def self.add_install_block(podfile_path)
+        add(Podfile::PRE_INSTALL_ACTIONS, "pre_install", podfile_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
+
+      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
+
+      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
+
+        if !marker_found
+          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)
+      end
+    end
+  end
+end

data/lib/pod_builder/command/install_sources.rb

@@ -0,0 +1,82 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class InstallSources
+      def self.call(options)
+        Configuration.check_inited
+        PodBuilder::prepare_basepath
+
+        update_repo = options[:update_repos] || false
+        installer, analyzer = Analyze.installer_at(PodBuilder::basepath)
+        framework_items = Analyze.podfile_items(installer, analyzer).select { |x| !x.is_prebuilt }
+        podspec_names = framework_items.map(&:podspec_name)
+
+        base_path = PodBuilder::basepath("Rome")
+        framework_files = Dir.glob("#{base_path}/**/*.framework")
+        
+        framework_files.each do |path|
+          rel_path = Pathname.new(path).relative_path_from(Pathname.new(base_path)).to_s
+
+          if framework_spec = framework_items.detect { |x| x.prebuilt_rel_path == rel_path }
+            update_repo(framework_spec)
+          end
+        end
+
+        Command::Clean::clean_sources()
+
+        rewrite_lldinit
+
+        puts "\n\n🎉 done!\n".green
+        return true
+      end
+
+      private
+
+      def self.update_repo(spec)
+        dest_path = PodBuilder::basepath("Sources")
+        FileUtils.mkdir_p(dest_path)
+
+        current_dir = Dir.pwd
+        Dir.chdir(dest_path)
+
+        repo_dir = File.join(dest_path, spec.podspec_name)
+        if !File.directory?(repo_dir)
+          raise "Failed cloning #{spec.name}" if !system("git clone #{spec.repo} #{spec.podspec_name}")
+        end
+
+        Dir.chdir(repo_dir)
+        puts "Checking out #{spec.podspec_name}".blue
+        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
+
+        lldbinit_path = File.expand_path('~/.lldbinit-Xcode')
+        FileUtils.touch(lldbinit_path)
+
+        lldbinit_lines = []
+        File.read(lldbinit_path).each_line do |line|
+          if lldbinit_lines.include?(line.strip()) ||
+             line.start_with?("settings set target.source-map") ||
+             line.strip() == "" then
+            next
+          end
+            
+          lldbinit_lines.push(line)
+        end
+
+        build_path = "#{PodBuilder::Configuration.build_path}/Pods"
+        source_path = PodBuilder::basepath("Sources")
+
+        lldbinit_lines.push("settings set target.source-map '#{build_path}' '#{source_path}'")
+        lldbinit_lines.push("")
+      
+        File.write(lldbinit_path, lldbinit_lines.join("\n"))
+      end
+    end
+  end
+end

data/lib/pod_builder/command/none.rb

@@ -0,0 +1,16 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class None
+      def self.call(options)
+        unless !options.has_key?(:version)
+          puts VERSION
+          return true
+        end
+
+        return false
+      end
+    end
+  end
+end

data/lib/pod_builder/command/restore_all.rb

@@ -0,0 +1,30 @@
+require 'pod_builder/core'
+
+module PodBuilder
+  module Command
+    class RestoreAll
+      def self.call(options)
+        Configuration.check_inited
+        PodBuilder::prepare_basepath
+
+        ret = false
+        begin
+          File.rename(PodBuilder::basepath("Podfile"), PodBuilder::basepath("Podfile.tmp2"))
+          File.rename(PodBuilder::basepath("Podfile.restore"), PodBuilder::basepath("Podfile"))
+
+          ARGV << "*"
+          options[:skip_prebuild_update] = true
+          ret = Command::Build::call(options)
+        rescue Exception => e
+          raise e
+        ensure
+          FileUtils.rm_f(PodBuilder::basepath("Podfile.restore"))
+          File.rename(PodBuilder::basepath("Podfile"), PodBuilder::basepath("Podfile.restore"))
+          File.rename(PodBuilder::basepath("Podfile.tmp2"), PodBuilder::basepath("Podfile"))
+        end
+
+        return ret
+      end
+    end
+  end
+end

data/lib/pod_builder/configuration.rb

@@ -0,0 +1,91 @@
+require 'json'
+
+module PodBuilder  
+  class Configuration
+    class <<self
+      attr_accessor :build_settings
+      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
+    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" => "Incremental",
+    }  
+    @build_system = "Legacy" # either Latest (New build system) or Legacy (Standard build system)
+    @config_file = "PodBuilder.json"
+    @base_path = "Frameworks"
+    @build_path = "/tmp/pod_builder"
+    @spec_overrides = {}
+    @skip_licenses = []
+    @license_file_name = "Pods-acknowledgements"               
+
+    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
+    end
+    
+    def self.exists
+      return config_path ? File.exist?(config_path) : false
+    end
+    
+    def self.load
+      unless config_path
+        return
+      end
+
+      Configuration.base_path = File.dirname(config_path)
+
+      if exists
+        config = JSON.parse(File.read(config_path))
+        if config.has_key?("spec_overrides")
+          Configuration.spec_overrides = config["spec_overrides"]
+        end
+        if config.has_key?("skip_licenses")
+          Configuration.skip_licenses = config["skip_licenses"]
+        end
+        if config.has_key?("build_settings")
+          Configuration.build_settings = config["build_settings"]
+        end
+        if config.has_key?("build_system")
+          Configuration.build_system = config["build_system"]
+        end
+        if config.has_key?("license_file_name")
+          Configuration.license_file_name = config["license_file_name"]
+        end
+      end
+    end
+    
+    def self.write
+      config = {
+        # nothing here yet
+      }
+      File.write(config_path, config.to_json)
+    end
+
+    private 
+
+    def self.config_path
+      unless PodBuilder::xcodepath
+        return
+      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)
+    end
+  end  
+end