carthage_cache_res 0.9.1

data/lib/carthage_cache_res/configuration_validator.rb

@@ -0,0 +1,134 @@
+module CarthageCacheRes
+
+  class MissingConfigurationKey < Struct.new(:keyname, :solution)
+
+    def self.missing_bucket_name
+      solution =  "You need to specify the AWS S3 bucket to be used.\n" \
+                  "You can either pass the '--bucket-name' option or "  \
+                  " add ':bucket_name: YOUR_BUCKET_NAME' to "           \
+                  ".carthage_cache_res.yml file.\nYou can also run "        \
+                  "'carthage_cache_res config' to generate the config file."
+      self.new(:bucket_name, solution)
+    end
+
+    def self.missing_aws_key(keyname, name)
+      solution =  "You need to specify the AWS #{name} to be used.\n"     \
+                  "You can either define a environmental variable "        \
+                  "AWS_REGION or add ':#{keyname}: YOUR_KEY_VALUE' "      \
+                  "under the :aws_s3_client_options: key in the "         \
+                  ".carthage_cache_res.yml file.\nYou can also run "          \
+                  "'carthage_cache_res config' to generate the config file."
+      self.new("aws_s3_client_options.#{keyname}", solution)
+    end
+
+    def self.missing_aws_region
+      missing_aws_key("region", "region")
+    end
+
+    def self.missing_aws_access_key_id
+      missing_aws_key("access_key_id", "access key ID")
+    end
+
+    def self.missing_aws_secret_access_key
+      missing_aws_key("secret_access_key", "secret access key")
+    end
+
+  end
+
+  class ValidationResult
+
+    def self.valid
+      self.new(nil)
+    end
+
+    def self.invalid(error)
+      self.new(error)
+    end
+
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+    end
+
+    def valid?
+      @error == nil
+    end
+
+  end
+
+  class ConfigurationValidator
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def valid?
+      validate.valid?
+    end
+
+    def read_only?
+      (config.aws_access_key_id.nil? || config.aws_secret_access_key.nil?) && config.aws_profile.nil?
+    end
+
+    def validate
+      return missing_bucket_name unless has_bucket_name?
+      return missing_aws_region unless has_aws_region?
+
+      return missing_aws_access_key_id if is_missing_aws_access_key_id?
+      return missing_aws_secret_access_key if is_missing_aws_secret_access_key?
+
+      ValidationResult.valid
+    end
+
+    private
+
+      def is_missing_aws_access_key_id? 
+        !has_aws_profile? && !has_aws_access_key_id? && has_aws_secret_access_key?
+      end
+
+      def is_missing_aws_secret_access_key?
+        !has_aws_profile? && has_aws_access_key_id? && !has_aws_secret_access_key?
+      end
+
+      def has_bucket_name?
+        config.bucket_name
+      end
+
+      def has_aws_region?
+        config.aws_region
+      end
+
+      def has_aws_access_key_id?
+        config.aws_access_key_id
+      end
+
+      def has_aws_secret_access_key?
+        config.aws_secret_access_key
+      end
+
+      def has_aws_profile?
+        config.aws_profile
+      end
+
+      def missing_bucket_name
+        ValidationResult.invalid(MissingConfigurationKey.missing_bucket_name)
+      end
+
+      def missing_aws_region
+        ValidationResult.invalid(MissingConfigurationKey.missing_aws_region)
+      end
+
+      def missing_aws_access_key_id
+        ValidationResult.invalid(MissingConfigurationKey.missing_aws_access_key_id)
+      end
+
+      def missing_aws_secret_access_key
+        ValidationResult.invalid(MissingConfigurationKey.missing_aws_secret_access_key)
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/configurator.rb

@@ -0,0 +1,79 @@
+require "yaml"
+
+module CarthageCacheRes
+
+  class Configurator
+
+    CONFIG_FILE_NAME = ".carthage_cache_res.yml"
+
+    attr_reader :config_file_path
+    attr_reader :base_config
+    attr_reader :terminal
+
+    def initialize(terminal, project_path, base_config = {})
+      @config_file_path = File.join(project_path, CONFIG_FILE_NAME)
+      @base_config = merge_config(base_config)
+      @terminal = terminal
+    end
+
+    def config
+      @config ||= load_config!
+    end
+
+    def save_config(config)
+      raise "Invalid configuration" unless config.valid?
+      File.open(config_file_path, 'w') { |f| f.write config.to_yaml }
+    end
+
+    private
+
+      def config_file_exist?
+        File.exist?(config_file_path)
+      end
+
+      def load_config!
+        config = load_config
+        validate!(config)
+        config
+      end
+
+      def load_config
+        if config_file_exist?
+          config = Configuration.parse(File.read(config_file_path))
+          config = base_config.merge(config)
+        else
+          base_config
+        end
+      end
+
+      def validate!(config)
+        validator = ConfigurationValidator.new(config)
+        result = validator.validate
+        unless result.valid?
+          terminal.error "error: #{result.error.solution}"
+          exit 1
+        end
+      end
+
+      def remove_nil_keys(hash)
+        hash.inject({}) do |new_hash, (k,v)|
+          unless v.nil? || (v.respond_to?(:empty?) && v.empty?)
+            if v.class == Hash
+              cleaned_hashed = remove_nil_keys(v)
+              new_hash[k] = cleaned_hashed unless cleaned_hashed.empty?
+            else
+              new_hash[k] = v
+            end
+          end
+          new_hash
+        end
+      end
+
+      def merge_config(config)
+        new_config = Configuration.default.hash_object.merge(config)
+        Configuration.new(remove_nil_keys(new_config))
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/configurator_wizard.rb

@@ -0,0 +1,49 @@
+module CarthageCacheRes
+
+  class ConfiguratorWizard
+
+    def initialize(ask_proc, password_proc)
+      @ask_proc = ask_proc
+      @password_proc = password_proc
+    end
+
+    def start
+      config = Configuration.new
+      config.bucket_name = ask("What is the Amazon S3 bucket name?", ENV["CARTHAGE_CACHE_DEFAULT_BUCKET_NAME"])
+      config.archive_base_path = ask("What base path do you want to use as archive's prefix? (default none)", nil)
+      config.prune_on_publish = confirm("Do you want to prune unused framework when publishing?")
+      config.aws_region = ask("What is the Amazon S3 region?")
+      config.aws_access_key_id = password("What is the AWS access key?")
+      config.aws_secret_access_key = password(" What is the AWS secret access key?")
+      config.aws_session_token = ask("What is the AWS session token (optional)?", nil, "*") 
+      config
+    end
+
+    private
+
+      def ask(message, default_value = nil, mask = nil)
+        message = "#{message} [#{default_value}]" if default_value
+        if mask
+          answer = @ask_proc.call(message) { |q| q.echo = mask } 
+        else
+          answer = @ask_proc.call(message)  
+        end
+        
+        if answer.empty?
+          default_value
+        else
+          answer
+        end
+      end
+
+      def confirm(message)
+        ask("#{message} [N/y]", 'N').downcase == 'y'
+      end
+
+      def password(message)
+         @password_proc.call(message)
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/description.rb

@@ -0,0 +1,3 @@
+module CarthageCacheRes
+  DESCRIPTION = "A tool that allows to cache Carthage/Build folder in Amazon S3."
+end

data/lib/carthage_cache_res/project.rb

@@ -0,0 +1,66 @@
+module CarthageCacheRes
+
+  class Project
+
+    attr_reader :cartfile
+    attr_reader :project_path
+    attr_reader :archive_base_path
+    attr_reader :cache_dir_name
+    attr_reader :terminal
+    attr_reader :tmpdir_base_path
+
+    def initialize(project_path, cache_dir_name, archive_base_path, terminal, tmpdir, swift_version_resolver = SwiftVersionResolver.new)
+      @project_path = project_path
+      @cache_dir_name = cache_dir_name
+      @archive_base_path = archive_base_path
+      @terminal = terminal
+      @tmpdir_base_path = tmpdir
+      @cartfile = CartfileResolvedFile.new(cartfile_resolved_path, terminal, swift_version_resolver)
+    end
+
+    def archive_filename
+      @archive_filename ||= "#{archive_key}.zip"
+    end
+
+    def archive_path
+      if @archive_base_path.nil?
+        @archive_path ||= archive_filename
+      else 
+        @archive_path ||= File.join(archive_base_path, archive_filename)
+      end
+    end
+
+    def archive_key
+      cartfile.digest
+    end
+
+    def tmpdir
+      @tmpdir ||= create_tmpdir
+    end
+
+    def carthage_build_directory
+      @carthage_build_directory ||= File.join(project_path, "Carthage", "Build")
+    end
+
+    def all_frameworks
+      cartfile.frameworks
+    end
+
+    private
+
+      def cartfile_resolved_path
+        @carfile_resolved_path ||= File.join(project_path, "Cartfile.resolved")
+      end
+
+      def create_tmpdir
+        dir = File.join(tmpdir_base_path, cache_dir_name)
+        unless File.exist?(dir)
+          terminal.vputs "Creating carthage cache directory at '#{dir}'."
+          FileUtils.mkdir_p(dir)
+        end
+        dir
+      end
+
+  end
+
+end

data/lib/carthage_cache_res/repository.rb

@@ -0,0 +1,58 @@
+require "aws-sdk"
+
+module CarthageCacheRes
+
+  class AWSRepository
+
+    attr_reader :client
+    attr_reader :bucket_name
+
+    def initialize(bucket_name, client_options = {})
+      @client = ::Aws::S3::Client.new(client_options)
+      @bucket_name = bucket_name
+    end
+
+    def archive_exist?(archive_filename)
+      ::Aws::S3::Object.new(bucket_name, archive_filename, client: client).exists?
+    end
+
+    def download(archive_filename, destination_path)
+      resp = client.get_object(
+        response_target: destination_path,
+        bucket: bucket_name,
+        key: archive_filename)
+    end
+
+    def upload(archive_filename, archive_path)
+      File.open(archive_path, 'rb') do |file|
+        client.put_object(bucket: bucket_name, key: archive_filename, body: file)
+      end
+    end
+
+  end
+
+  class HTTPRepository
+
+    attr_reader :base_url
+
+    def initialize(bucket_name, client_options = {})
+      region = client_options[:region]
+      bucket_name = bucket_name
+      @base_url = "https://s3-#{region}.amazonaws.com/#{bucket_name}"
+    end
+
+    def archive_exist?(archive_filename)
+      system "wget", "--method=HEAD", "#{base_url}/#{archive_filename}", "-q"
+    end
+
+    def download(archive_filename, destination_path)
+      system "wget", "--output-document=#{destination_path}", "#{base_url}/#{archive_filename}", "-q"
+    end
+
+    def upload(archive_filename, archive_path)
+      raise "carthage_cache_res is working in read-only mode. Please configure AWS credentials first"
+    end
+
+  end
+
+end

data/lib/carthage_cache_res/shell_command_executor.rb

@@ -0,0 +1,11 @@
+module CarthageCacheRes
+
+  class ShellCommandExecutor
+
+    def execute(command)
+      `#{command}`
+    end
+
+  end
+
+end

data/lib/carthage_cache_res/swift_version_resolver.rb

@@ -0,0 +1,17 @@
+module CarthageCacheRes
+
+  class SwiftVersionResolver
+
+    def initialize(executor = ShellCommandExecutor.new)
+      @executor = executor
+    end
+
+    def swift_version
+      output = @executor.execute('xcrun swift -version').chomp
+      version_string = /(\d+\.)?(\d+\.)?(\d+)/.match(output).to_s
+      Gem::Version.new(version_string)
+    end
+
+  end
+
+end

data/lib/carthage_cache_res/terminal.rb

@@ -0,0 +1,25 @@
+module CarthageCacheRes
+
+  class Terminal
+
+    attr_reader :verbose
+
+    def initialize(verbose = false)
+      @verbose = verbose
+    end
+
+    def puts(message)
+      Kernel.puts(message)
+    end
+
+    def vputs(message)
+      puts(message) if verbose
+    end
+
+    def error(message)
+      STDERR.puts(message)
+    end
+
+  end
+
+end