carthage_cache_res 0.9.1

data/lib/carthage_cache_res.rb

@@ -0,0 +1,22 @@
+require "carthage_cache_res/version"
+require "carthage_cache_res/description"
+require "carthage_cache_res/archive_builder"
+require "carthage_cache_res/archive_installer"
+require "carthage_cache_res/archiver"
+require "carthage_cache_res/carthage_resolved_file"
+require "carthage_cache_res/project"
+require "carthage_cache_res/repository"
+require "carthage_cache_res/terminal"
+require "carthage_cache_res/configuration_validator"
+require "carthage_cache_res/configuration"
+require "carthage_cache_res/configurator"
+require "carthage_cache_res/configurator_wizard"
+require "carthage_cache_res/shell_command_executor"
+require "carthage_cache_res/application"
+require "carthage_cache_res/swift_version_resolver"
+require "carthage_cache_res/build_collector"
+require "carthage_cache_res/carthage_cache_res_lock"
+
+module CarthageCacheRes
+
+end

data/lib/carthage_cache_res/application.rb

@@ -0,0 +1,93 @@
+require 'yaml'
+
+module CarthageCacheRes
+
+  class Application
+
+    CACHE_DIR_NAME = "carthage_cache_res"
+
+    attr_reader :terminal
+    attr_reader :archiver
+    attr_reader :repository
+    attr_reader :project
+    attr_reader :config
+
+    def initialize(project_path, verbose, config, repository: AWSRepository, terminal: Terminal, swift_version_resolver: SwiftVersionResolver)
+      @terminal = terminal.new(verbose)
+      @archiver = Archiver.new
+      @config = Configurator.new(@terminal, project_path, config).config
+      clazz = @config.read_only? ? HTTPRepository : repository
+      @repository = clazz.new(@config.bucket_name, @config.hash_object[:aws_s3_client_options])
+      @project = Project.new(project_path, CACHE_DIR_NAME, @config.archive_base_path, @terminal, @config.tmpdir, swift_version_resolver.new)
+    end
+
+    def archive_exist?
+      repository.archive_exist?(project.archive_path)
+    end
+
+    def install_archive
+      if archive_exist?
+        archive_installer.install
+        true
+      else
+        terminal.puts "There is no cached archive for the current Cartfile.resolved file."
+        false
+      end
+    end
+
+    def create_archive(force = false, prune = nil, prune_white_list = nil, platforms = nil)
+      prune ||= config.prune_on_publish
+      platforms ||= config.platforms
+      prune_white_list ||= config.prune_white_list
+
+      if force || !archive_exist?
+        carthage_cache_res_lock.write_lock_digest(project.archive_key)
+        prune_build_directory(prune_white_list) if prune
+        archive_builder.build(platforms)
+      end
+    end
+
+    def prune_build_directory(white_list)
+      white_list ||= config.prune_white_list
+
+      if white_list && File.exist?(white_list)
+        terminal.vputs "Pruning build directory with white list '#{white_list}' ..."
+        white_list = YAML.load(File.read(white_list))
+      else
+        white_list = {}
+        terminal.vputs "Pruning build directory ..."
+      end
+      build_collector.delete_unused_frameworks(white_list)
+    end
+
+    def validate_installation
+      if carthage_cache_res_lock.valid_digest?(project.archive_key)
+        terminal.puts "Your installation is valid."
+        true
+      else
+        terminal.puts "Your current Carthage digest '#{project.archive_key}' does not match digest '#{carthage_cache_res_lock.lock_digest}' in '#{carthage_cache_res_lock.lock_file_path}'"
+        false
+      end
+    end
+
+    private
+
+      def archive_installer
+        @archive_installer ||= ArchiveInstaller.new(terminal, repository, archiver, project)
+      end
+
+      def archive_builder
+        @archive_builder ||= ArchiveBuilder.new(terminal, repository, archiver, project)
+      end
+
+      def build_collector
+        @build_collector ||= BuildCollector.new(terminal, project.carthage_build_directory, project.all_frameworks)
+      end
+
+      def carthage_cache_res_lock
+        @carthage_cache_res_lock ||= CarthageCacheResLock.new(project.carthage_build_directory)
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/archive_builder.rb

@@ -0,0 +1,57 @@
+module CarthageCacheRes
+
+  class ArchiveBuilder
+
+    attr_reader :terminal
+    attr_reader :repository
+    attr_reader :archiver
+    attr_reader :project
+
+    def initialize(terminal, repository, archiver, project)
+      @terminal = terminal
+      @repository = repository
+      @archiver = archiver
+      @project = project
+    end
+
+    def build(platforms = nil)
+      archive_path = archive(platforms)
+      upload_archive(archive_path)
+      # TODO check if some old archives can be deleted
+      # I would store the last N archives and then delete
+      # the rest
+    end
+
+    private
+
+      def archive(platforms = nil)
+        archive_path = File.join(project.tmpdir, project.archive_filename)
+        if platforms
+          terminal.puts "Archiving Carthage build directory for #{platforms.join(',')} platforms."
+        else
+          terminal.puts "Archiving Carthage build directory for all platforms."
+        end
+
+        filter_block = nil
+        if platforms
+          filter_block = ->(file) do
+            lock_file?(file) || platforms.map(&:downcase).include?(file.downcase)
+          end
+        end
+
+        archiver.archive(project.carthage_build_directory, archive_path, &filter_block)
+        archive_path
+      end
+
+      def upload_archive(archive_path)
+        terminal.puts "Uploading archive with key '#{project.archive_key}'."
+        repository.upload(project.archive_path, archive_path)
+      end
+
+      def lock_file?(file)
+        file == CarthageCacheResLock::LOCK_FILE_NAME
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/archive_installer.rb

@@ -0,0 +1,53 @@
+module CarthageCacheRes
+
+  class ArchiveInstaller
+
+    attr_reader :terminal
+    attr_reader :repository
+    attr_reader :archiver
+    attr_reader :project
+
+    def initialize(terminal, repository, archiver, project)
+      @terminal = terminal
+      @repository = repository
+      @archiver = archiver
+      @project = project
+    end
+
+    def install
+      archive_path = download_archive
+      unarchive(archive_path)
+    end
+
+    private
+
+      def create_carthage_build_directory
+        unless File.exist?(project.carthage_build_directory)
+          terminal.vputs "Creating Carthage build directory '#{project.carthage_build_directory}'."
+          FileUtils.mkdir_p(project.carthage_build_directory)
+        end
+        project.carthage_build_directory
+      end
+
+      def download_archive
+        archive_path = File.join(project.tmpdir, project.archive_filename)
+
+        if File.exist?(archive_path)
+          terminal.puts "Archive with key '#{archive_path}' already downloaded in local cache."
+        else
+          terminal.puts "Downloading archive with key '#{archive_path}'."
+          repository.download(project.archive_path, archive_path)
+        end
+
+        archive_path
+      end
+
+      def unarchive(archive_path)
+        build_directory = create_carthage_build_directory
+        terminal.puts "Unarchiving '#{archive_path}' into '#{build_directory}'."
+        archiver.unarchive(archive_path, build_directory)
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/archiver.rb

@@ -0,0 +1,24 @@
+module CarthageCacheRes
+
+  class Archiver
+
+    attr_reader :executor
+
+    def initialize(executor = ShellCommandExecutor.new)
+      @executor = executor
+    end
+
+    def archive(archive_path, destination_path, &filter_block)
+      files = Dir.entries(archive_path).select { |x| !x.start_with?(".") }
+      files = files.select(&filter_block) if filter_block
+      files = files.sort_by(&:downcase)
+      executor.execute("cd #{archive_path} && zip -r -X #{File.expand_path(destination_path)} #{files.join(' ')} > /dev/null")
+    end
+
+    def unarchive(archive_path, destination_path)
+      executor.execute("unzip -o #{archive_path} -d #{destination_path} > /dev/null")
+    end
+
+  end
+
+end

data/lib/carthage_cache_res/build_collector.rb

@@ -0,0 +1,86 @@
+require 'fileutils'
+
+module CarthageCacheRes
+
+  class BuildCollector
+
+    attr_reader :terminal
+    attr_reader :build_directory
+    attr_reader :required_frameworks
+    attr_reader :command_executor
+
+    def initialize(terminal, build_directory, required_frameworks, command_executor = ShellCommandExecutor.new)
+      @terminal = terminal
+      @build_directory = build_directory
+      @required_frameworks = Set.new(required_frameworks)
+      @command_executor = command_executor
+    end
+
+    def delete_unused_frameworks(white_list = {})
+      terminal.vputs "Deleting unused frameworks from '#{build_directory}' ..."
+      list_built_frameworks.each do |framework_path|
+        if delete_framework?(framework_path, white_list)
+          delete_framework_files(framework_path)
+        end
+      end
+    end
+
+    private
+
+      def delete_framework?(framework_path, white_list)
+        framework = framework_name(framework_path)
+        if required_frameworks.include?(white_list[framework])
+          false
+        else
+          ! required_frameworks.include?(framework)
+        end
+      end
+
+      def list_built_frameworks
+        Dir[File.join(build_directory, "/**/*.framework")]
+      end
+
+      def framework_name(framework_path)
+        Pathname.new(framework_path).basename(".framework").to_s
+      end
+
+      def delete_framework_files(framework_path)
+        framework_dsym_path = "#{framework_path}.dSYM"
+        terminal.vputs "Deleting #{framework_name(framework_path)} files because they are no longer needed ..."
+
+        # Deletes .framework file
+        terminal.vputs "Deleting '#{framework_path}' ..."
+        FileUtils.rm_r(framework_path) if File.exist?(framework_path)
+
+        # Deletes .bcsymbolmap files (needs .dSYM file)
+        if File.exist?(framework_dsym_path)
+          symbol_map_files(framework_dsym_path).each do |symbol_table_file|
+            terminal.vputs "Deleting '#{symbol_table_file}' ..."
+            FileUtils.rm(symbol_table_file)  if File.exist?(symbol_table_file)
+          end
+        end
+
+        # Deletes .dSYM files
+        # .dSYM file MUST be deleted after .bcsymbolmap files because
+        # in order to match .bcsymbolmap files with framework file
+        # we need to use .dSYM file with dwarfdump command.
+        terminal.vputs "Deleting '#{framework_dsym_path}' ..."
+        FileUtils.rm_r(framework_dsym_path) if File.exist?(framework_dsym_path)
+
+        terminal.vputs ""
+      end
+
+      def symbol_map_files(framework_dsym_path)
+        uuid_dwarfdump(framework_dsym_path)
+          .split("\n")
+          .map { |line| line.match(/UUID: (.*) \(/)[1] }
+          .map { |uuid| File.expand_path(File.join(framework_dsym_path, "../#{uuid}.bcsymbolmap")) }
+      end
+
+      def uuid_dwarfdump(framework_dsym_path)
+        command_executor.execute("/usr/bin/xcrun dwarfdump --uuid #{framework_dsym_path}")
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/carthage_cache_lock.rb

@@ -0,0 +1,28 @@
+
+module CarthageCacheRes
+
+  class CarthageCacheResLock
+
+    LOCK_FILE_NAME = "CarthageCacheRes.lock"
+
+    attr_reader :lock_file_path
+
+    def initialize(build_directory)
+      @lock_file_path = File.join(build_directory, LOCK_FILE_NAME)
+    end
+
+    def lock_digest
+      File.read(lock_file_path).strip if File.exist?(lock_file_path)
+    end
+
+    def write_lock_digest(digest)
+      File.open(lock_file_path, "w") { |f| f.write(digest) }
+    end
+
+    def valid_digest?(digest)
+      lock_digest == digest
+    end
+
+  end
+
+end

data/lib/carthage_cache_res/carthage_resolved_file.rb

@@ -0,0 +1,49 @@
+require "digest"
+
+module CarthageCacheRes
+
+  class CartfileResolvedFile
+
+    attr_reader :file_path
+    attr_reader :terminal
+    attr_reader :swift_version_resolver
+
+    def initialize(file_path, terminal, swift_version_resolver = SwiftVersionResolver.new)
+      @file_path = file_path
+      @swift_version_resolver = swift_version_resolver
+      @terminal = terminal
+    end
+
+    def digest
+      @digest ||= generate_digest
+    end
+
+    def content
+      @content ||= File.read(file_path)
+    end
+
+    def swift_version
+      @swift_version ||= swift_version_resolver.swift_version
+    end
+
+    def frameworks
+      @frameworks ||= content.each_line.map { |line| extract_framework_name(line) }
+    end
+
+    private
+
+      def generate_digest
+        terminal.vputs "Generating carthage_cache_res archive digest using swift version '#{swift_version}' and " \
+                      "the content of '#{file_path}'"
+        generated_digest = Digest::SHA256.hexdigest(content + "#{swift_version}")
+        terminal.vputs "Generated digest: #{generated_digest}"
+        generated_digest
+      end
+
+      def extract_framework_name(cartfile_line)
+        cartfile_line.split(" ")[1].split("/").last.gsub('"', "")
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/configuration.rb

@@ -0,0 +1,122 @@
+require "yaml"
+
+module CarthageCacheRes
+
+  class Configuration
+
+    def self.supported_keys
+      @supported_keys ||= []
+    end
+
+    def self.config_key(name)
+      supported_keys << name
+    end
+
+    def self.valid?(config)
+      ConfigurationValidator.new(config).valid?
+    end
+
+    def self.read_only?(config)
+      ConfigurationValidator.new(config).read_only?
+    end
+
+    def self.parse(str)
+      new(YAML.load(str))
+    end
+
+    def self.default
+      @default ||= Configuration.new({
+        prune_on_publish: false,
+        platforms: nil,
+        prune_white_list: nil,
+        aws_s3_client_options: {
+          region: ENV['AWS_REGION'],
+          access_key_id: ENV['AWS_ACCESS_KEY_ID'],
+          secret_access_key: ENV['AWS_SECRET_ACCESS_KEY'],
+          profile: ENV['AWS_PROFILE'],
+          session_token: ENV['AWS_SESSION_TOKEN']
+          
+        },
+        tmpdir: File.join(Dir.home, 'Library', 'Caches'),
+        archive_base_path: nil
+      })
+    end
+
+    config_key :bucket_name
+    config_key :prune_on_publish
+    config_key :prune_white_list
+    config_key :platforms
+    config_key :aws_region
+    config_key :aws_access_key_id
+    config_key :aws_secret_access_key
+    config_key :aws_profile
+    config_key :tmpdir
+    config_key :aws_session_token
+    config_key :archive_base_path
+
+    attr_reader :hash_object
+
+    def initialize(hash_object = {})
+      @hash_object = hash_object
+    end
+
+    def to_yaml
+      hash_object.to_yaml
+    end
+
+    def valid?
+      self.class.valid?(self)
+    end
+
+    def read_only?
+      self.class.read_only?(self)
+    end
+
+    def merge(c)
+      other_hash = nil
+      if c.is_a?(Hash)
+        other_hash = c
+      else
+        other_hash = c.hash_object
+      end
+
+      @hash_object = hash_object.merge(other_hash) do |key, oldval, newval|
+        oldval.is_a?(Hash) ? oldval.merge(newval) : newval
+      end
+      self
+    end
+
+    def method_missing(method_sym, *arguments, &block)
+      method_name = method_sym.to_s
+      key = method_name.chomp("=")
+      return super if !self.class.supported_keys.include?(key.to_sym)
+      config, key = extract_config_and_key(key)
+
+      if method_name.end_with?("=")
+        config[key] = arguments.first
+      else
+        config[key]
+      end
+    end
+
+    def respond_to?(method_sym, include_private = false)
+      if self.class.supported_keys.include?(method_sym)
+        true
+      else
+        super
+      end
+    end
+
+    private
+
+      def extract_config_and_key(method_name)
+        if method_name =~ /^aws_(.*)$/
+          [hash_object[:aws_s3_client_options] ||= {}, $1.to_sym]
+        else
+          [hash_object, method_name.to_sym]
+        end
+      end
+
+  end
+
+end