carthage_remote_cache 0.0.3 → 0.0.4

data/lib/carthage_archive.rb

@@ -1,81 +1,88 @@
 class CarthageArchive
-
-    attr_reader :archive_filename, :archive_path
-
-    def initialize(framework_name, platform)
-        raise AppError.new, "Platform #{platform.inspect} needs to be a symbol" unless platform.kind_of?(Symbol)
-
-        @framework_name = framework_name
-        @platform = platform
-        @archive_filename = "#{framework_name}-#{platform}.zip"
-        @archive_path = @archive_filename
-    end
-
-    # Aggregate following files:
-    # - Carthage/Build/iOS/Alamofire.framework
-    # - Carthage/Build/iOS/Alamofire.framework/Alamofire
-    # - Carthage/Build/iOS/618BEB79-4C7F-3692-B140-131FB983AC5E.bcsymbolmap
-    # into Alamofire-iOS.zip
-    def create_archive
-        $LOG.debug("Archiving #{@framework_name} for #{@platform}")
-
-        platform_path = File.join(CARTHAGE_BUILD_DIR, platform_to_carthage_dir_string(@platform))
-        framework_path = File.join(platform_path, "#{@framework_name}.framework")
-        raise AppError.new, "Archive can't be created, no framework directory at #{framework_path}" unless Dir.exist?(framework_path)
-
-        dsym_path = File.join(platform_path, "#{@framework_name}.framework.dSYM")
-        raise AppError.new, "DSYM File #{dsym_path} is missing" unless File.exist?(dsym_path)
-
-        binary_path = File.join(framework_path, @framework_name)
-        raise AppError.new, "Binary #{binary_path} is missing, failed to read .bcsymbolmap files" unless File.exist?(binary_path)
-
-        bcsymbolmap_paths = find_bcsymbolmap_paths(platform_path, binary_path)
-
-        archived_paths = [framework_path, dsym_path] + bcsymbolmap_paths
-
-        $LOG.debug("Adding > #{archived_paths.inspect}")
-
-        delete_archive
-        sh("zip -r #{quote @archive_path} #{quote archived_paths}")
-        $LOG.debug("Created #{@archive_path} archive, file size: #{formatted_archive_size}")
-    end
-
-    def unpack_archive
-        raise AppError.new, "Archive #{@archive_path} is missing" unless File.exist?(@archive_path)
-        $LOG.debug("Unpacking #{@archive_path}, file size: #{formatted_archive_size}")
-        sh("unzip -o #{quote @archive_path}")
-    end
-
-    def delete_archive
-        File.delete(@archive_path) if File.exist?(@archive_path)
-    end
-
-    private
-
-    def find_bcsymbolmap_paths(platform_path, binary_path)
-        raw_dwarfdump = dwarfdump(binary_path)
-        uuids = parse_uuids(raw_dwarfdump)
-        bcsymbolmap_paths = uuids.map { |uuid| File.join(platform_path, "#{uuid}.bcsymbolmap") }.select { |path| File.exist?(path) }
-        bcsymbolmap_paths
-    end
-
-    def dwarfdump(binary_path)
-        sh("/usr/bin/xcrun dwarfdump --uuid \"#{binary_path}\"")
-    end
-
-    # Example dwarfdump link:
-    # UUID: 618BEB79-4C7F-3692-B140-131FB983AC5E (i386) Carthage/Build/iOS/CocoaLumberjackSwift.framework/CocoaLumberjackSwift
-    def parse_uuids(raw_dwarfdump)
-        lines = raw_dwarfdump.split("\n")
-        uuids = lines.map { |line| line[/^UUID: ([A-Z0-9\-]+)\s+\(.*$/, 1] }
-        uuids.compact
-    end
-
-    # E.g. "1.4MB"
-    def formatted_archive_size
-        size = File.size(@archive_path)
-        megabytes = size / 1024.0 / 1024.0
-        "#{megabytes.round(1)}MB"
+  attr_reader :archive_filename, :archive_path
+
+  def initialize(framework_name, platform)
+    raise AppError.new, "Platform #{platform.inspect} needs to be a symbol" unless platform.kind_of?(Symbol)
+
+    @framework_name = framework_name
+    @platform = platform
+    @archive_filename = "#{framework_name}-#{platform}.zip"
+    @archive_path = @archive_filename
+  end
+
+  # Aggregate following files:
+  # - Carthage/Build/iOS/Alamofire.framework
+  # - Carthage/Build/iOS/Alamofire.framework/Alamofire
+  # - Carthage/Build/iOS/618BEB79-4C7F-3692-B140-131FB983AC5E.bcsymbolmap
+  # into Alamofire-iOS.zip
+  def create_archive(shell, should_include_dsym, carthage_build_dir = CARTHAGE_BUILD_DIR)
+    $LOG.debug("Archiving #{@framework_name} for #{@platform}")
+
+    platform_path = File.join(carthage_build_dir, platform_to_carthage_dir_string(@platform))
+    framework_path = File.join(platform_path, "#{@framework_name}.framework")
+    raise MissingFrameworkDirectoryError.new, "Archive can't be created, no framework directory at #{framework_path}" unless Dir.exist?(framework_path)
+
+    # It's very likely, that binary releases don't contain DSYMs.
+    dsym_path = File.join(platform_path, "#{@framework_name}.framework.dSYM")
+    unless File.exist?(dsym_path)
+      if should_include_dsym
+        raise AppError.new, "DSYM File #{dsym_path} not found"
+      else
+        $LOG.error("DSYM File #{dsym_path} not found, continuing")
+        dsym_path = nil
+      end
     end
 
+    binary_path = File.join(framework_path, @framework_name)
+    raise AppError.new, "Binary #{binary_path} is missing, failed to read .bcsymbolmap files" unless File.exist?(binary_path)
+
+    bcsymbolmap_paths = find_bcsymbolmap_paths(shell, platform_path, binary_path)
+
+    input_paths = []
+    input_paths << framework_path
+    input_paths << dsym_path unless dsym_path.nil?
+    input_paths += bcsymbolmap_paths
+
+    $LOG.debug("Adding > #{input_paths.inspect}")
+
+    delete_archive
+    shell.archive(input_paths, @archive_path)
+    $LOG.debug("Created #{@archive_path} archive, file size: #{formatted_archive_size}")
+  end
+
+  def unpack_archive(shell)
+    raise AppError.new, "Archive #{@archive_path} is missing" unless File.exist?(@archive_path)
+    $LOG.debug("Unpacking #{@archive_path}, file size: #{formatted_archive_size}")
+    shell.unpack(@archive_path)
+  end
+
+  def delete_archive
+    File.delete(@archive_path) if File.exist?(@archive_path)
+  end
+
+  def archive_size
+    raise AppError.new, "Archive #{@archive_path} is missing" unless File.exist?(@archive_path)
+    File.size(@archive_path)
+  end
+
+  private
+
+  def find_bcsymbolmap_paths(shell, platform_path, binary_path)
+    raw_dwarfdump = shell.dwarfdump(binary_path)
+    uuids = parse_uuids(raw_dwarfdump)
+    bcsymbolmap_paths = uuids.map { |uuid| File.join(platform_path, "#{uuid}.bcsymbolmap") }.select { |path| File.exist?(path) }
+    bcsymbolmap_paths
+  end
+
+  # Example dwarfdump link:
+  # UUID: 618BEB79-4C7F-3692-B140-131FB983AC5E (i386) Carthage/Build/iOS/CocoaLumberjackSwift.framework/CocoaLumberjackSwift
+  def parse_uuids(raw_dwarfdump)
+    lines = raw_dwarfdump.split("\n")
+    uuids = lines.map { |line| line[/^UUID: ([A-Z0-9\-]+)\s+\(.*$/, 1] }
+    uuids.compact
+  end
+
+  def formatted_archive_size
+    format_file_size(archive_size)
+  end
 end

data/lib/carthage_dependency.rb

@@ -1,65 +1,89 @@
+# Representation of a Cartfile.resolved entry.
+# @see https://github.com/Carthage/Carthage/blob/master/Documentation/Artifacts.md#origin
 class CarthageDependency
-
-    class << self
-        # Parses Cartfile.resolved dependency entry, e.g.
-        #   github "CocoaLumberjack/CocoaLumberjack" "3.2.1"
-        def parse_cartfile_resolved_line(line)
-            line.strip!
-            matches = line.match(/^(\w+)\s+\"([^\"]+)\"(\s+\"([^\"]+)\")$/)
-            return nil if matches.nil?
-            if matches.length == 5
-                CarthageDependency.new(type: matches[1], repository: matches[2], version: matches[4])
-            else
-                nil
-            end
-        end
+  class << self
+    # Parses Cartfile.resolved dependency entry, e.g.
+    #   github "CocoaLumberjack/CocoaLumberjack" "3.2.1"
+    def parse_cartfile_resolved_line(line)
+      line.strip!
+      matches = line.match(/^(\w+)\s+\"([^\"]+)\"(\s+\"([^\"]+)\")$/)
+      return nil if matches.nil?
+      if matches.length == 5
+        CarthageDependency.new(origin: matches[1].to_sym, source: matches[2], version: matches[4])
+      else
+        nil
+      end
     end
+  end
 
-    attr_reader :type, :repository, :version
+  attr_reader :origin, :source, :version
 
-    def initialize(args)
-        @type = args[:type]
-        @repository = args[:repository]
-        @version = args[:version]
-    end
+  def initialize(args)
+    raise AppError.new, "Expected Symbol for origin '#{args[:origin]}'" unless args[:origin].kind_of? Symbol
+    raise AppError.new, "Unrecognized origin '#{args[:oriign]}'" unless [:github, :git, :binary].include?(args[:origin])
 
-    # Since one Cartfile.resolved entry may produce multiple differently named frameworks,
-    # this is an entry point to identifying a framework name.
-    def guessed_framework_basename
-        case @type
-        when "github"
-            repository.split("/").last
-        else
-            raise AppError.new, "Determining version_filename from #{@type} dependency is not yet supported"
-        end
-    end
+    @origin = args[:origin]
+    @source = args[:source]
+    @version = args[:version]
+  end
 
-    def version_filename
-        ".#{guessed_framework_basename}.version"
+  # Since one Cartfile.resolved entry may produce multiple differently named frameworks,
+  # this is an entry point to identifying a framework name.
+  def guessed_framework_basename
+    case @origin
+    when :github
+      @source.split("/").last
+    when :git
+      filename = @source.split("/").last
+      filename.chomp(".git")
+    when :binary
+      filename = @source.split("/").last
+      filename.chomp(".json")
+    else
+      raise AppError.new, "Unrecognized origin '#{@origin}'"
     end
+  end
 
-    def version_filepath
-        File.join(CARTHAGE_BUILD_DIR, version_filename)
-    end
+  def version_filename
+    ".#{guessed_framework_basename}.version"
+  end
+
+  def version_filepath
+    File.join(CARTHAGE_BUILD_DIR, version_filename)
+  end
 
-    def validate_version_file(version_file)
-        raise OutdatedFrameworkBuildError.new, version_validation_message(version_file) if @version != version_file.version
+  def should_include_dsym
+    case @origin
+    when :github
+      true
+    when :git
+      true
+    when :binary
+      false
+    else
+      raise AppError.new, "Unrecognized origin '#{@origin}'"
     end
+  end
 
-    def to_s
-        "#{@type} \"#{@repository}\" \"#{@version}\""
+  def validate_version_file(version_file)
+    if @version != version_file.version
+      raise OutdatedFrameworkBuildError.new, version_validation_message(version_file)
     end
+  end
 
-    private
+  def to_s
+    "#{@origin.to_s} \"#{@source}\" \"#{@version}\""
+  end
 
-    def version_validation_message(version_file)
-        <<~EOS
-            Outdated version of '#{guessed_framework_basename}' framework detected:
-                Expected version '#{@version}'
-                Found version '#{version_file.version}'
+  private
 
-            Please run `carthage bootstrap` to build frameworks.
-        EOS
-    end
+  def version_validation_message(version_file)
+    <<~EOS
+      Outdated version of '#{guessed_framework_basename}' framework detected:
+        Expected version '#{@version}'
+        Found version '#{version_file.version}'
 
+      Please run `carthage bootstrap` to build frameworks.
+    EOS
+  end
 end

data/lib/carthage_remote_cache.rb

@@ -9,5 +9,7 @@ require 'configuration'
 require 'errors'
 require 'log'
 require 'networking'
+require 'shell_wrapper'
 require 'utils'
+require 'version'
 require 'version_file'

data/lib/commands/download_command.rb

@@ -1,67 +1,85 @@
 require 'concurrent'
 
 class DownloadCommand
+  def self.new_with_defaults(options)
+    shell = ShellWrapper.new
+    config = Configuration.new(shell)
+    networking = Networking.new(config)
+    api = API.new(shell, networking, options)
 
-    def initialize(options)
-        @options = options
-        @config = Configuration.new
-        @networking = Networking.new(@config)
-        @api = API.new(@networking, options)
-    end
+    DownloadCommand.new(
+      config: config,
+      networking: networking,
+      api: api,
+    )
+  end
+
+  def initialize(args)
+    @config = args[:config]
+    @networking = args[:networking]
+    @api = args[:api]
+  end
 
-    def run
-        pool = Concurrent::FixedThreadPool.new(THREAD_POOL_SIZE)
+  def run
+    pool = Concurrent::FixedThreadPool.new(THREAD_POOL_SIZE)
 
-        @number_of_downloaded_archives = 0
-        @number_of_skipped_archives = 0
-        errors = Concurrent::Array.new
+    @number_of_downloaded_archives = 0
+    @number_of_skipped_archives = 0
+    @total_archive_size = 0
+    errors = Concurrent::Array.new
 
-        for carthage_dependency in @config.carthage_dependencies
-            pool.post(carthage_dependency) do |carthage_dependency|
-                begin
-                    download(carthage_dependency)
-                rescue => e
-                    errors << e
-                end
-            end
+    for carthage_dependency in @config.carthage_dependencies
+      pool.post(carthage_dependency) do |carthage_dependency|
+        begin
+          download(carthage_dependency)
+        rescue => e
+          errors << e
         end
+      end
+    end
 
-        pool.shutdown
-        pool.wait_for_termination
+    pool.shutdown
+    pool.wait_for_termination
 
-        if errors.count > 0
-            raise MultipleErrorsError.new(errors)
-        else
-            puts "Downloaded and extracted #{@number_of_downloaded_archives} archives, skipped #{@number_of_skipped_archives} archives."
-        end
+    if errors.count > 0
+      raise MultipleErrorsError.new(errors)
+    else
+      puts "Downloaded and extracted #{@number_of_downloaded_archives} archives " +
+             "(#{format_file_size(@total_archive_size)}), " +
+             "skipped #{@number_of_skipped_archives} archives."
     end
+  end
 
-    private
+  private
 
-    def download(carthage_dependency)
-        local_version_file = if File.exist?(carthage_dependency.version_filepath)
-            VersionFile.new(carthage_dependency.version_filepath)
-        else
-            nil
-        end
+  def download(carthage_dependency)
+    local_version_file =
+      if File.exist?(carthage_dependency.version_filepath)
+        VersionFile.new(carthage_dependency.version_filepath)
+      else
+        nil
+      end
 
-        if !local_version_file.nil? && @api.version_file_matches_server?(carthage_dependency, local_version_file)
-            $LOG.debug("Version file #{local_version_file.path} matches server version, skipping download")
-            @number_of_skipped_archives += local_version_file.number_of_frameworks
-            return
-        end
+    if !local_version_file.nil? && @api.version_file_matches_server?(carthage_dependency, local_version_file)
+      $LOG.debug("Version file #{local_version_file.path} matches server version, skipping download")
+      @number_of_skipped_archives += local_version_file.number_of_frameworks
+      return
+    end
 
-        version_file = @networking.download_version_file(carthage_dependency)
-        raise AppError.new, "Version file #{carthage_dependency.version_filename} is not present on the server, please run `carthagerc upload` first" if version_file.nil?
+    version_file = @networking.download_version_file(carthage_dependency)
+    raise AppError.new, "Version file #{carthage_dependency.version_filename} is not present on the server, please run `carthagerc upload` first" if version_file.nil?
 
-        version_file.frameworks_by_platform.each do |platform, framework_names|
-            for framework_name in framework_names do
-                archive = @api.download_and_unpack_archive(carthage_dependency, framework_name, platform)
-                raise AppError.new, "Failed to download framework #{carthage_dependency} – #{framework_name} (#{platform}). Please `upload` the framework first." if archive.nil?
-                @number_of_downloaded_archives += 1
-            end
+    version_file.frameworks_by_platform.each do |platform, framework_names|
+      for framework_name in framework_names
+        archive_size = @api.download_and_unpack_archive(carthage_dependency, framework_name, platform)
+        if archive_size.nil?
+          raise AppError.new, "Failed to download framework #{carthage_dependency} – #{framework_name} (#{platform}). Please `upload` the framework first."
+        else
+          @number_of_downloaded_archives += 1
+          @total_archive_size += archive_size
         end
-        version_file.move_to_build_dir
+      end
     end
-
+    version_file.move_to_build_dir
+  end
 end

data/lib/commands/init_command.rb

@@ -1,26 +1,24 @@
 class InitCommand
+  def initialize(options)
+    @options = options
+  end
 
-    def initialize(options)
-        @options = options
+  def run
+    path = File.join(Dir.pwd, CARTRCFILE)
+    if File.exist?(path)
+      raise AppError.new, "File #{path} already exists"
+    else
+      File.write(path, file_contents)
     end
+  end
 
-    def run
-        path = File.join(Dir.pwd, CARTRCFILE)
-        if File.exist?(path)
-            raise AppError.new, "File #{path} already exists"
-        else
-            File.write(path, file_contents)
-        end
-    end
-
-    private
-
-    def file_contents
-        <<~EOS
-            Configuration.setup do |c|
-                c.server = "http://localhost:#{SERVER_DEFAULT_PORT}/"
-            end
-        EOS
-    end
+  private
 
+  def file_contents
+    <<~EOS
+      Configuration.setup do |c|
+        c.server = "http://localhost:#{SERVER_DEFAULT_PORT}/"
+      end
+    EOS
+  end
 end

data/lib/commands/server_command.rb

@@ -1,16 +1,14 @@
 class ServerCommand
+  def initialize(options)
+    @options = options
+  end
 
-    def initialize(options)
-        @options = options
-    end
-
-    def run
-        ENV['RACK_ENV'] = 'production'
-        require 'server/server_app'
-        Rack::Handler::WEBrick.run(
-            Sinatra::Application,
-            :Port => @options[:server_port]
-        )
-    end
-
+  def run
+    ENV['RACK_ENV'] = 'production'
+    require 'server/server_app'
+    Rack::Handler::WEBrick.run(
+      Sinatra::Application,
+      :Port => @options[:server_port],
+    )
+  end
 end

data/lib/commands/upload_command.rb

@@ -1,63 +1,78 @@
 require 'concurrent'
 
 class UploadCommand
+  def self.new_with_defaults(options)
+    shell = ShellWrapper.new
+    config = Configuration.new(shell)
+    networking = Networking.new(config)
+    api = API.new(shell, networking, options)
 
-    def initialize(options)
-        @config = Configuration.new
-        @networking = Networking.new(@config)
-        @api = API.new(@networking, options)
-    end
-
-    def run
-        pool = Concurrent::FixedThreadPool.new(THREAD_POOL_SIZE)
+    UploadCommand.new(
+      config: config,
+      networking: networking,
+      api: api,
+    )
+  end
 
-        $LOG.debug("Will upload frameworks: #{@config.all_framework_names}")
+  def initialize(args)
+    @config = args[:config]
+    @networking = args[:networking]
+    @api = args[:api]
+  end
 
-        @number_of_uploaded_archives = 0
-        @number_of_skipped_archives = 0
-        errors = Concurrent::Array.new
+  def run
+    pool = Concurrent::FixedThreadPool.new(THREAD_POOL_SIZE)
 
-        for carthage_dependency in @config.carthage_dependencies
-            pool.post(carthage_dependency) do |carthage_dependency|
-                begin
-                    upload(carthage_dependency)
-                rescue => e
-                    errors << e
-                end
-            end
-        end
+    $LOG.debug("Will upload frameworks: #{@config.all_framework_names}")
 
-        pool.shutdown
-        pool.wait_for_termination
+    @number_of_uploaded_archives = 0
+    @number_of_skipped_archives = 0
+    @total_archive_size = 0
+    errors = Concurrent::Array.new
 
-        if errors.count > 0
-            raise MultipleErrorsError.new(errors)
-        else
-            puts "Uploaded #{@number_of_uploaded_archives} archives, skipped #{@number_of_skipped_archives}."
+    for carthage_dependency in @config.carthage_dependencies
+      pool.post(carthage_dependency) do |carthage_dependency|
+        begin
+          upload(carthage_dependency)
+        rescue => e
+          errors << e
         end
+      end
     end
 
-    private
+    pool.shutdown
+    pool.wait_for_termination
 
-    def upload(carthage_dependency)
-        version_file = VersionFile.new(carthage_dependency.version_filepath)
+    if errors.count > 0
+      raise MultipleErrorsError.new(errors)
+    else
+      puts "Uploaded #{@number_of_uploaded_archives} archives " +
+             "(#{format_file_size(@total_archive_size)}), " +
+             "skipped #{@number_of_skipped_archives}."
+    end
+  end
 
-        carthage_dependency.validate_version_file(version_file)
+  private
 
-        if @api.version_file_matches_server?(carthage_dependency, version_file)
-            $LOG.debug("Version file #{version_file.path} matches server version, skipping upload")
-            @number_of_skipped_archives += version_file.number_of_frameworks
-            return
-        end
+  def upload(carthage_dependency)
+    version_file = VersionFile.new(carthage_dependency.version_filepath)
 
-        @networking.upload_version_file(carthage_dependency)
+    carthage_dependency.validate_version_file(version_file)
 
-        version_file.frameworks_by_platform.each do |platform, framework_names|
-            for framework_name in framework_names
-                @api.create_and_upload_archive(carthage_dependency, framework_name, platform)
-                @number_of_uploaded_archives += 1
-            end
-        end
+    if @api.version_file_matches_server?(carthage_dependency, version_file)
+      $LOG.debug("Version file #{version_file.path} matches server version, skipping upload")
+      @number_of_skipped_archives += version_file.number_of_frameworks
+      return
     end
 
+    @networking.upload_version_file(carthage_dependency)
+
+    version_file.frameworks_by_platform.each do |platform, framework_names|
+      for framework_name in framework_names
+        archive_size = @api.create_and_upload_archive(carthage_dependency, framework_name, platform)
+        @number_of_uploaded_archives += 1
+        @total_archive_size += archive_size
+      end
+    end
+  end
 end