emerge 0.1.0

data/lib/commands/upload/snapshots/snapshots.rb

@@ -0,0 +1,247 @@
+require 'dry/cli'
+require 'json'
+require 'uri'
+require 'chunky_png'
+require 'async'
+require 'async/barrier'
+require 'async/semaphore'
+require 'async/http/internet/instance'
+
+module EmergeCLI
+  module Commands
+    module Upload
+      class Snapshots < EmergeCLI::Commands::GlobalOptions
+        desc 'Upload snapshot images to Emerge'
+
+        option :id, type: :string, required: true, desc: 'Unique identifier to group runs together'
+        option :name, type: :string, required: true, desc: 'Name of the run'
+
+        # Optional options
+        option :api_token, type: :string, required: false,
+                           desc: 'API token for authentication, defaults to ENV[EMERGE_API_TOKEN]'
+        option :sha, type: :string, required: false, desc: 'SHA of the commit'
+        option :branch, type: :string, required: false, desc: 'Branch name'
+        option :repo_name, type: :string, required: false, desc: 'Repository name'
+        option :base_sha, type: :string, required: false, desc: 'Base SHA'
+        option :previous_sha, type: :string, required: false, desc: 'Previous SHA'
+        option :pr_number, type: :string, required: false, desc: 'PR number'
+        option :concurrency, type: :integer, default: 5, desc: 'Number of concurrency for parallel uploads'
+
+        option :client_library, type: :string, required: false, values: %w[swift-snapshot-testing paparazzi],
+                                desc: 'Client library used for snapshots'
+        option :project_root, type: :string, required: false, desc: 'Path to the project root'
+
+        option :profile, type: :boolean, default: false, desc: 'Enable performance profiling metrics'
+
+        argument :image_paths, type: :array, required: false, desc: 'Paths to folders containing images'
+
+        def initialize(network: nil, git_info_provider: nil)
+          @network = network
+          @git_info_provider = git_info_provider
+          @profiler = EmergeCLI::Profiler.new
+        end
+
+        def call(image_paths:, **options)
+          @options = options
+          @profiler = EmergeCLI::Profiler.new(enabled: options[:profile])
+          before(options)
+
+          start_time = Time.now
+          run_id = nil
+
+          begin
+            api_token = @options[:api_token] || ENV['EMERGE_API_TOKEN']
+            raise 'API token is required' unless api_token
+
+            @network ||= EmergeCLI::Network.new(api_token:)
+            @git_info_provider ||= GitInfoProvider.new
+
+            Sync do
+              validate_options(image_paths)
+
+              client = create_client(image_paths)
+
+              image_files = @profiler.measure('find_image_files') { find_image_files(client) }
+
+              @profiler.measure('check_duplicate_files') { check_duplicate_files(image_files, client) }
+
+              run_id = @profiler.measure('create_run') { create_run }
+
+              upload_images(run_id, options[:concurrency], image_files, client)
+
+              @profiler.measure('finish_run') { finish_run(run_id) }
+            end
+
+            Logger.info 'Upload completed successfully!'
+            Logger.info "Time taken: #{(Time.now - start_time).round(2)} seconds"
+            @profiler.report
+            Logger.info "✅ View your snapshots at https://emergetools.com/snapshot/#{run_id}"
+          rescue StandardError => e
+            Logger.error "CLI Error: #{e.message}"
+            Sync { report_error(run_id, e.message, 'crash') } if run_id
+          ensure
+            @network&.close
+          end
+        end
+
+        private
+
+        def validate_options(image_paths)
+          if @options[:client_library] && !@options[:project_root]
+            raise 'Project path is required when using a client library'
+          end
+          if @options[:project_root] && !@options[:client_library]
+            raise 'Client library is required when using a project path'
+          end
+          return unless (@options[:project_root] || @options[:client_library]) && !image_paths.empty?
+          raise 'Cannot specify image paths when using a project path or client library'
+        end
+
+        def create_client(image_paths)
+          case @options[:client_library]
+          when 'swift-snapshot-testing'
+            ClientLibraries::SwiftSnapshotTesting.new(@options[:project_root])
+          when 'paparazzi'
+            ClientLibraries::Paparazzi.new(@options[:project_root])
+          else
+            ClientLibraries::Default.new(image_paths)
+          end
+        end
+
+        def find_image_files(client)
+          found_images = client.image_files
+          Logger.info "Found #{found_images.size} images"
+          found_images
+        end
+
+        def check_duplicate_files(image_files, client)
+          seen_files = {}
+          image_files.each do |image_path|
+            file_name = client.parse_file_info(image_path)[:file_name]
+
+            if seen_files[file_name]
+              Logger.warn "Duplicate file name detected: '#{file_name}'. " \
+                        "Previous occurrence: '#{seen_files[file_name]}'. " \
+                        'This upload will overwrite the previous one.'
+            end
+            seen_files[file_name] = image_path
+          end
+        end
+
+        def create_run
+          Logger.info 'Creating run...'
+
+          git_result = @git_info_provider.fetch_git_info
+
+          sha = @options[:sha] || git_result.sha
+          branch = @options[:branch] || git_result.branch
+          base_sha = @options[:base_sha] || git_result.base_sha
+          previous_sha = @options[:previous_sha] || git_result.previous_sha
+          pr_number = @options[:pr_number] || git_result.pr_number
+
+          # TODO: Make optional
+          raise 'SHA is required' unless sha
+          raise 'Branch is required' unless branch
+          raise 'Repo name is required' unless @options[:repo_name]
+
+          payload = {
+            id: @options[:id],
+            name: @options[:name],
+            sha:,
+            branch:,
+            repo_name: @options[:repo_name],
+            # Optional
+            base_sha:,
+            previous_sha:,
+            pr_number: pr_number&.to_s
+          }.compact
+
+          response = @network.post(path: '/v1/snapshots/run', body: payload)
+          run_id = JSON.parse(response.read).fetch('run_id')
+          Logger.info "Created run: #{run_id}"
+
+          run_id
+        end
+
+        def upload_images(run_id, concurrency, image_files, client)
+          Logger.info 'Uploading images...'
+
+          post_image_barrier = Async::Barrier.new
+          post_image_semaphore = Async::Semaphore.new(concurrency, parent: post_image_barrier)
+
+          upload_image_barrier = Async::Barrier.new
+          upload_image_semaphore = Async::Semaphore.new(concurrency, parent: upload_image_barrier)
+
+          image_files.each_with_index do |image_path, index|
+            post_image_semaphore.async do
+              Logger.debug "Fetching upload URL for image #{index + 1}/#{image_files.size}: #{image_path}"
+
+              file_info = client.parse_file_info(image_path)
+
+              dimensions = @profiler.measure('chunky_png_processing') do
+                datastream = ChunkyPNG::Datastream.from_file(image_path)
+                {
+                  width: datastream.header_chunk.width,
+                  height: datastream.header_chunk.height
+                }
+              end
+
+              body = {
+                run_id:,
+                file_name: file_info[:file_name],
+                group_name: file_info[:group_name],
+                variant_name: file_info[:variant_name],
+                width: dimensions[:width],
+                height: dimensions[:height]
+              }
+
+              upload_url = @profiler.measure('create_image_upload_url') do
+                response = @network.post(path: '/v1/snapshots/run/image', body:)
+                JSON.parse(response.read).fetch('image_url')
+              end
+
+              # Start uploading the image without waiting for it to finish
+              upload_image_semaphore.async do
+                Logger.info "Uploading image #{index + 1}/#{image_files.size}: #{image_path}"
+
+                @profiler.measure('upload_image') do
+                  @network.put(
+                    path: upload_url,
+                    headers: { 'Content-Type' => 'image/png' },
+                    body: File.read(image_path)
+                  )
+                end
+              end
+            end
+          end
+
+          post_image_barrier.wait
+          upload_image_barrier.wait
+        ensure
+          post_image_barrier&.stop
+          upload_image_barrier&.stop
+        end
+
+        def finish_run(run_id)
+          Logger.info 'Finishing run...'
+          @network.post(path: '/v1/snapshots/run/finish', body: { run_id: })
+          nil
+        end
+
+        def report_error(run_id, error_message, error_code = 'generic')
+          @network.post(
+            path: '/v1/snapshots/run/error',
+            body: {
+              run_id:,
+              error_code:,
+              error_message:
+            }
+          )
+          Logger.info 'Reported error to Emerge'
+        rescue StandardError => e
+          Logger.error "Failed to report error to Emerge: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/emerge_cli.rb

@@ -0,0 +1,37 @@
+require_relative './commands/global_options'
+require_relative './commands/upload/snapshots/snapshots'
+require_relative './commands/upload/snapshots/client_libraries/swift_snapshot_testing'
+require_relative './commands/upload/snapshots/client_libraries/paparazzi'
+require_relative './commands/upload/snapshots/client_libraries/default'
+require_relative './commands/integrate/fastlane'
+require_relative './commands/config/snapshots/snapshots_ios'
+
+require_relative './utils/git_info_provider'
+require_relative './utils/git_result'
+require_relative './utils/github'
+require_relative './utils/git'
+require_relative './utils/logger'
+require_relative './utils/network'
+require_relative './utils/profiler'
+require_relative './utils/project_detector'
+
+require 'dry/cli'
+
+module EmergeCLI
+  extend Dry::CLI::Registry
+
+  register 'upload', aliases: ['u'] do |prefix|
+    prefix.register 'snapshots', Commands::Upload::Snapshots
+  end
+
+  register 'integrate' do |prefix|
+    prefix.register 'fastlane-ios', Commands::Integrate::Fastlane, aliases: ['i']
+  end
+
+  register 'configure' do |prefix|
+    prefix.register 'snapshots-ios', Commands::Config::SnapshotsIOS, aliases: ['c']
+  end
+end
+
+# By default the log level is INFO, but can be overridden by the --debug flag
+EmergeCLI::Logger.configure(::Logger::INFO)

data/lib/utils/git.rb

@@ -0,0 +1,103 @@
+require 'open3'
+
+module EmergeCLI
+  module Git
+    def self.branch
+      command = 'git rev-parse --abbrev-ref HEAD'
+      Logger.debug command
+      stdout, _, status = Open3.capture3(command)
+      unless status.success?
+        Logger.error 'Failed to get the current branch name'
+        return nil
+      end
+
+      branch_name = stdout.strip
+      if branch_name == 'HEAD'
+        # We're in a detached HEAD state
+        # Find all branches that contains the current HEAD commit
+        #
+        # Example output:
+        # * (HEAD detached at dec13a5)
+        # telkins/detached-test
+        # remotes/origin/telkins/detached-test
+        #
+        # So far I've seen this output be fairly stable
+        # If the input is invalid for whatever reason, sed/awk will return an empty string
+        command = "git branch -a --contains HEAD | sed -n 2p | awk '{ printf $1 }'"
+        Logger.debug command
+        head_stdout, _, head_status = Open3.capture3(command)
+
+        unless head_status.success?
+          Logger.error 'Failed to get the current branch name for detached HEAD'
+          return nil
+        end
+
+        branch_name = head_stdout.strip
+      end
+
+      branch_name == 'HEAD' ? nil : branch_name
+    end
+
+    def self.sha
+      command = 'git rev-parse HEAD'
+      Logger.debug command
+      stdout, _, status = Open3.capture3(command)
+      stdout.strip if status.success?
+    end
+
+    def self.base_sha
+      current_branch = branch
+      remote_head = remote_head_branch
+      return nil if current_branch.nil? || remote_head.nil?
+
+      command = "git merge-base #{remote_head} #{current_branch}"
+      Logger.debug command
+      stdout, _, status = Open3.capture3(command)
+      return nil if stdout.strip.empty? || !status.success?
+      current_sha = sha
+      stdout.strip == current_sha ? nil : stdout.strip
+    end
+
+    def self.previous_sha
+      command = 'git rev-parse HEAD^'
+      Logger.debug command
+      stdout, _, status = Open3.capture3(command)
+      stdout.strip if status.success?
+    end
+
+    def self.primary_remote
+      remote = remote()
+      return nil if remote.nil?
+      remote.include?('origin') ? 'origin' : remote.first
+    end
+
+    def self.remote_head_branch(remote = primary_remote)
+      return nil if remote.nil?
+      command = "git remote show #{remote}"
+      Logger.debug command
+      stdout, _, status = Open3.capture3(command)
+      return nil if stdout.nil? || !status.success?
+      stdout
+        .split("\n")
+        .map(&:strip)
+        .find { |line| line.start_with?('HEAD branch: ') }
+        &.split(' ')
+        &.last
+    end
+
+    def self.remote_url(remote = primary_remote)
+      return nil if remote.nil?
+      command = "git config --get remote.#{remote}.url"
+      Logger.debug command
+      stdout, _, status = Open3.capture3(command)
+      stdout if status.success?
+    end
+
+    def self.remote
+      command = 'git remote'
+      Logger.debug command
+      stdout, _, status = Open3.capture3(command)
+      stdout.split("\n") if status.success?
+    end
+  end
+end

data/lib/utils/git_info_provider.rb

@@ -0,0 +1,25 @@
+module EmergeCLI
+  class GitInfoProvider
+    def fetch_git_info
+      if EmergeCLI::Github.supported_github_event?
+        Logger.info 'Fetching Git info from Github event'
+        EmergeCLI::GitResult.new(
+          sha: EmergeCLI::Github.sha,
+          base_sha: EmergeCLI::Github.base_sha,
+          branch: EmergeCLI::Github.branch,
+          pr_number: EmergeCLI::Github.pr_number,
+          repo_name: EmergeCLI::Github.repo_name,
+          previous_sha: EmergeCLI::Github.previous_sha
+        )
+      else
+        Logger.info 'Fetching Git info from system Git'
+        EmergeCLI::GitResult.new(
+          sha: EmergeCLI::Git.sha,
+          base_sha: EmergeCLI::Git.base_sha,
+          branch: EmergeCLI::Git.branch,
+          previous_sha: EmergeCLI::Git.previous_sha
+        )
+      end
+    end
+  end
+end

data/lib/utils/git_result.rb

@@ -0,0 +1,14 @@
+module EmergeCLI
+  class GitResult
+    attr_accessor :sha, :base_sha, :previous_sha, :branch, :pr_number, :repo_name
+
+    def initialize(sha:, base_sha:, branch:, pr_number: nil, repo_name: nil, previous_sha: nil)
+      @pr_number = pr_number
+      @sha = sha
+      @base_sha = base_sha
+      @previous_sha = previous_sha
+      @branch = branch
+      @repo_name = repo_name
+    end
+  end
+end

data/lib/utils/github.rb

@@ -0,0 +1,71 @@
+module EmergeCLI
+  module Github
+    GITHUB_EVENT_PR = 'pull_request'.freeze
+    GITHUB_EVENT_PUSH = 'push'.freeze
+
+    def self.event_name
+      ENV['GITHUB_EVENT_NAME']
+    end
+
+    def self.supported_github_event?
+      Logger.info "GitHub event name: #{event_name}"
+      pull_request? || push?
+    end
+
+    def self.pull_request?
+      event_name == GITHUB_EVENT_PR
+    end
+
+    def self.push?
+      event_name == GITHUB_EVENT_PUSH
+    end
+
+    def self.sha
+      if push?
+        ENV['GITHUB_SHA']
+      elsif pull_request?
+        github_event_data.dig(:pull_request, :head, :sha)
+      end
+    end
+
+    def self.base_sha
+      return unless pull_request?
+      github_event_data.dig(:pull_request, :base, :sha)
+    end
+
+    def self.pr_number
+      pull_request? ? github_event_data[:number] : nil
+    end
+
+    def self.branch
+      pull_request? ? github_event_data.dig(:pull_request, :head, :ref) : Git.branch
+    end
+
+    def self.repo_owner
+      github_event_data.dig(:repository, :owner, :login)
+    end
+
+    def self.repo_name
+      github_event_data.dig(:repository, :full_name)
+    end
+
+    def self.previous_sha
+      Git.previous_sha
+    end
+
+    def self.github_event_data
+      @github_event_data ||= begin
+        github_event_path = ENV['GITHUB_EVENT_PATH']
+        Logger.error 'GITHUB_EVENT_PATH is not set' if github_event_path.nil?
+
+        Logger.error "File #{github_event_path} doesn't exist" unless File.exist?(github_event_path)
+
+        file_content = File.read(github_event_path)
+        file_json = JSON.parse(file_content, symbolize_names: true)
+        Logger.debug "Parsed GitHub event data: #{file_json.inspect}"
+
+        file_json
+      end
+    end
+  end
+end

data/lib/utils/logger.rb

@@ -0,0 +1,60 @@
+require 'logger'
+require 'colorize'
+
+module EmergeCLI
+  class Logger
+    class << self
+      def configure(log_level)
+        logger.level = log_level
+      end
+
+      def info(message)
+        log(:info, message)
+      end
+
+      def warn(message)
+        log(:warn, message)
+      end
+
+      def error(message)
+        log(:error, message)
+      end
+
+      def debug(message)
+        log(:debug, message)
+      end
+
+      private
+
+      def logger
+        @logger ||= create_logger
+      end
+
+      def create_logger
+        logger = ::Logger.new(STDOUT)
+        logger.formatter = proc do |severity, datetime, _progname, msg|
+          timestamp = datetime.strftime('%Y-%m-%d %H:%M:%S.%L')
+          formatted_severity = severity.ljust(5)
+          colored_message = case severity
+                            when 'INFO'
+                              msg.to_s.white
+                            when 'WARN'
+                              msg.to_s.yellow
+                            when 'ERROR'
+                              msg.to_s.red
+                            when 'DEBUG'
+                              msg.to_s.light_blue
+                            else
+                              msg.to_s
+                            end
+          "[#{timestamp}] #{formatted_severity} -- : #{colored_message}\n"
+        end
+        logger
+      end
+
+      def log(level, message)
+        logger.send(level, message)
+      end
+    end
+  end
+end

data/lib/utils/network.rb

@@ -0,0 +1,95 @@
+require 'net/http'
+require 'json'
+require 'uri'
+require 'async/http/internet/instance'
+
+module EmergeCLI
+  class Network
+    EMERGE_API_PROD_URL = 'api.emergetools.com'.freeze
+    public_constant :EMERGE_API_PROD_URL
+
+    RETRY_DELAY = 5
+    MAX_RETRIES = 1
+
+    def initialize(api_token:, base_url: EMERGE_API_PROD_URL)
+      @base_url = base_url
+      @api_token = api_token
+      @internet = Async::HTTP::Internet.new
+    end
+
+    def get(path:, headers: {})
+      request(:get, path, nil, headers)
+    end
+
+    def post(path:, body:, headers: {})
+      request(:post, path, body, headers)
+    end
+
+    def put(path:, body:, headers: {})
+      request(:put, path, body, headers)
+    end
+
+    def close
+      @internet.close
+    end
+
+    private
+
+    def request(method, path, body, custom_headers)
+      uri = if path.start_with?('http')
+              URI.parse(path)
+            else
+              URI::HTTPS.build(host: @base_url, path:)
+            end
+      absolute_uri = uri.to_s
+
+      headers = { 'X-API-Token' => @api_token }
+      headers['Content-Type'] = 'application/json' if method == :post && body.is_a?(Hash)
+      headers.merge!(custom_headers)
+
+      body = JSON.dump(body) if body.is_a?(Hash) && method == :post
+
+      Logger.debug "Request: #{method} #{truncate_uri(absolute_uri)} #{method == :post ? body : 'N/A'}"
+
+      retries = 0
+      begin
+        response = perform_request(method, absolute_uri, headers, body)
+
+        unless response.success?
+          Logger.error "Request failed: #{absolute_uri} #{response}"
+          raise "Request failed: #{absolute_uri} #{response}"
+        end
+
+        response
+      rescue StandardError => e
+        # Workaround for an issue where the request is not fully written, haven't determined the root cause yet
+        if e.message.include?('Wrote 0 bytes') && retries < MAX_RETRIES
+          retries += 1
+          Logger.warn "Request failed due to incomplete write. Retrying in #{RETRY_DELAY} seconds..."
+          sleep RETRY_DELAY
+          retry
+        else
+          Logger.error "Request failed: #{absolute_uri} #{e.message}"
+          raise e
+        end
+      end
+    end
+
+    def perform_request(method, absolute_uri, headers, body)
+      case method
+      when :get
+        @internet.get(absolute_uri, headers:)
+      when :post
+        @internet.post(absolute_uri, headers:, body:)
+      when :put
+        @internet.put(absolute_uri, headers:, body:)
+      else
+        raise "Unsupported method: #{method}"
+      end
+    end
+
+    def truncate_uri(uri, max_length = 100)
+      uri.length > max_length ? "#{uri[0..max_length]}..." : uri
+    end
+  end
+end