fluid_cli 0.1.2

data/lib/fluid_cli/theme/syncer/uploader/forms/select_delete_strategy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_strategy_form"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class SelectDeleteStrategy < BaseStrategyForm
+            flag_arguments :file
+
+            def strategies
+              %i[
+                delete
+                restore
+                exit
+              ]
+            end
+
+            def prefix
+              "theme.serve.syncer.forms.delete_strategy"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/uploader/forms/select_update_strategy.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base_strategy_form"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class SelectUpdateStrategy < BaseStrategyForm
+            flag_arguments :file, :exists_remotely
+
+            def strategies
+              %i[
+                keep_remote
+                keep_local
+                union_merge
+                exit
+              ]
+            end
+
+            def prefix
+              "theme.serve.syncer.forms.#{exists_remotely ? "update_strategy" : "update_remote_deleted_strategy"}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/uploader/json_delete_handler.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "forms/apply_to_all"
+require_relative "forms/select_delete_strategy"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module JsonDeleteHandler
+          def enqueue_json_deletes(files)
+            return enqueue_deletes(files) if overwrite_json?
+
+            # Handle conflicts when JSON files cannot be overwritten
+            handle_delete_conflicts(files)
+          end
+
+          private
+
+          def handle_delete_conflicts(files)
+            to_delete = []
+            to_get = []
+
+            apply_to_all = Forms::ApplyToAll.new(ctx, files.size)
+
+            files.each do |file|
+              delete_strategy = apply_to_all.value || ask_delete_strategy(file)
+              apply_to_all.apply?(delete_strategy)
+
+              case delete_strategy
+              when :delete
+                to_delete << file
+              when :restore
+                to_get << file
+              end
+            end
+
+            enqueue_deletes(to_delete)
+            enqueue_get(to_get)
+          end
+
+          def ask_delete_strategy(file)
+            Forms::SelectDeleteStrategy.ask(ctx, [], file: file).strategy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/uploader/json_update_handler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "forms/apply_to_all"
+require_relative "forms/select_update_strategy"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module JsonUpdateHandler
+          def enqueue_json_updates(files)
+            return enqueue_updates(files) if overwrite_json?
+
+            # Handle conflicts when JSON files cannot be overwritten
+            handle_update_conflicts(files)
+          end
+
+          private
+
+          def handle_update_conflicts(files)
+            to_get = []
+            to_delete = []
+            to_update = []
+            to_union_merge = []
+
+            apply_to_all = Forms::ApplyToAll.new(ctx, files.size)
+
+            files.each do |file|
+              update_strategy = apply_to_all.value || ask_update_strategy(file)
+              apply_to_all.apply?(update_strategy)
+
+              case update_strategy
+              when :keep_remote
+                if file_exist_remotely?(file)
+                  to_get << file
+                else
+                  delete_locally(file)
+                end
+              when :keep_local
+                to_update << file
+              when :union_merge
+                if file_exist_remotely?(file)
+                  to_union_merge << file
+                else
+                  to_update << file
+                end
+              end
+            end
+
+            enqueue_get(to_get)
+            enqueue_deletes(to_delete)
+            enqueue_updates(to_update)
+            enqueue_union_merges(to_union_merge)
+          end
+
+          def file_exist_remotely?(file)
+            !checksums[file.relative_path].nil?
+          end
+
+          def delete_locally(file)
+            ::File.delete(file.absolute_path)
+          end
+
+          def ask_update_strategy(file)
+            Forms::SelectUpdateStrategy.ask(ctx, [], file: file, exists_remotely: file_exist_remotely?(file)).strategy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/uploader.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require_relative "uploader/json_delete_handler"
+require_relative "uploader/json_update_handler"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Uploader
+        extend Forwardable
+
+        include JsonDeleteHandler
+        include JsonUpdateHandler
+
+        attr_reader :syncer
+
+        def_delegators :syncer,
+          # helpers
+          :ctx,
+          :api_client,
+          :theme,
+          :overwrite_json?,
+          # enqueue
+          :enqueue_deletes,
+          :enqueue_get,
+          :enqueue_union_merges,
+          :enqueue_updates,
+          # checksums
+          :checksums,
+          :update_checksums,
+          :fetch_checksums!,
+          :wait!
+
+        def initialize(syncer, delete, delay_low_priority_files, &update_progress_bar_block)
+          @syncer = syncer
+          @delete = delete
+          @delay_low_priority_files = delay_low_priority_files
+          @update_progress_bar_block = update_progress_bar_block
+          @progress_bar_mutex = Mutex.new
+        end
+
+        def upload!
+          fetch_checksums!
+          delete_files!
+          async_upload!
+        end
+
+        def delete_files!
+          return unless delete?
+
+          files_present_remotely = checksums.keys
+          files_present_locally = theme.theme_files.map(&:relative_path)
+
+          files_to_delete = (files_present_remotely - files_present_locally)
+            .map { |file| theme[file] }
+
+          enqueue_deletes(files_to_delete)
+        end
+
+        private
+
+        def async_upload!
+          enqueue_updates(files)
+          wait!(&@update_progress_bar_block)
+        end
+
+        def delete?
+          @delete
+        end
+
+        def delay_low_priority_files?
+          @delay_low_priority_files
+        end
+
+        # Files
+
+        def files
+          @files ||= begin
+            theme.theme_files.select { |file| uploadable?(file) }
+          end
+        end
+
+        def uploadable?(file)
+          return false unless file.exist?
+
+          checksums.file_has_changed?(file)
+        end
+
+        # Handler errors
+
+        def report(file, error)
+          file_path = file.relative_path
+          error_message = syncer
+            .parse_api_errors(file, error)
+            .map { |msg| "#{file_path}: #{msg}" }
+            .join("\n")
+
+          syncer.report_file_error(file, error_message)
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+require "thread"
+require "json"
+require "base64"
+require "forwardable"
+
+require_relative "syncer/checksums"
+require_relative "syncer/downloader"
+require_relative "syncer/error_reporter"
+require_relative "syncer/merger"
+require_relative "syncer/operation"
+require_relative "syncer/standard_reporter"
+require_relative "syncer/unsupported_script_warning"
+require "fluid_cli/theme/syncer/uploader"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      extend Forwardable
+
+      QUEUEABLE_METHODS = [
+        :get,         # - Updates the local file with the remote file content
+        :update,      # - Updates the remote file with the local file content
+        :delete,      # - Deletes the remote file
+        :union_merge, # - Union merges the local file content with the remote file content,
+        :get_asset,   # - Downloads a binary asset from a given URL
+      ]
+
+      attr_reader :ctx, :theme, :checksums, :error_checksums, :api_client, :pending, :standard_reporter
+
+      def_delegators :@error_reporter, :has_any_error?
+
+      def initialize(ctx, theme:, overwrite_json: true)
+        @ctx = ctx
+        @theme = theme
+        @overwrite_json = overwrite_json
+        @error_reporter = ErrorReporter.new(ctx)
+        @standard_reporter = StandardReporter.new(ctx)
+        @reporters = [@error_reporter, @standard_reporter]
+
+        # Queue of `Operation`s waiting to be picked up from a thread for processing.
+        @queue = Queue.new
+
+        # `Operation`s will be removed from this Array completed.
+        @pending = []
+
+        # Thread making the API requests.
+        @threads = []
+
+        # Latest theme assets checksums. Updated on each upload.
+        @checksums = Checksums.new(theme)
+
+        # Checksums of assets with errors.
+        @error_checksums = []
+
+        # Initialize `api_client` on main thread
+        @api_client = FluidCLI::API.new(ctx)
+      end
+
+      def lock_io!
+        @reporters.each(&:disable!)
+      end
+
+      def unlock_io!
+        @reporters.each(&:enable!)
+      end
+
+      def enqueue_updates(files)
+        files.each { |file| enqueue(:update, file) }
+      end
+
+      def enqueue_get(files)
+        files.each { |file| enqueue(:get, file) }
+      end
+
+      def enqueue_deletes(files)
+        files.each { |file| enqueue(:delete, file) }
+      end
+
+      def enqueue_union_merges(files)
+        files.each { |file| enqueue(:union_merge, file) }
+      end
+
+      def size
+        @pending.size
+      end
+
+      def empty?
+        @pending.empty?
+      end
+
+      def pending_updates
+        @pending.select { |op| op.method == :update }.map(&:file)
+      end
+
+      def remote_file?(file)
+        checksums.has?(file)
+      end
+
+      def broken_file?(file)
+        error_checksums.include?(checksums[file.relative_path])
+      end
+
+      def wait!
+        raise ThreadError, "No syncer threads" if @threads.empty?
+
+        total = size
+        last_size = size
+        until empty? || @queue.closed?
+          if block_given? && last_size != size
+            yield size, total
+            last_size = size
+          end
+          Thread.pass
+        end
+      end
+
+      def fetch_checksums!
+        _status, response = api_client.get(
+          path: "application_themes/#{theme.id}/resources"
+        )
+        update_checksums(response["application_theme_resources"])
+      end
+
+
+      def get_theme_resources!
+        _status, response = api_client.get(
+          path: "application_themes/#{theme.id}/resources"
+        )
+        update_checksums(response["application_theme_resources"])
+
+        response["application_theme_resources"].each do |resource|
+          file = theme[resource["key"]]
+          next unless file
+
+          if resource["resource_type"] == "FileResource" && !file.text?
+            enqueue(:get_asset, file, { url: resource["url"] })
+          else
+            file.write(resource["content"])
+          end
+        end
+      end
+
+      def shutdown
+        @queue.close unless @queue.closed?
+      ensure
+        @threads.each { |thread| thread.join if thread.alive? }
+      end
+
+      def start_threads(count = 2)
+        count.times do
+          @threads << Thread.new do
+            loop do
+              operation = @queue.pop
+              break if operation.nil? # shutdown was called
+
+              perform(operation)
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              error_suffix = ": #{e}"
+              error_suffix += + "\n\t#{e.backtrace.join("\n\t")}" if @ctx.debug?
+              report_error(operation, error_suffix)
+            end
+          end
+        end
+      end
+
+      def upload_theme!(delay_low_priority_files: false, delete: true, &block)
+        uploader = Uploader.new(self, delete, delay_low_priority_files, &block)
+        uploader.upload!
+      end
+
+      def download_theme!(delete: true, &block)
+        downloader = Downloader.new(self, delete, &block)
+        downloader.download!
+      end
+
+      def enqueueable?(operation)
+        file = operation.file
+        method = operation.method
+
+        # Already enqueued or ignored
+        return false if @pending.include?(operation)
+        if [:update, :get].include?(method) && file.exist?
+          # File is fixed (and it has been never updated)
+          if !!@error_checksums.delete(file.checksum)
+            @standard_reporter.report(operation.as_fix_message)
+          end
+
+          return checksums.file_has_changed?(file)
+        end
+
+        true
+      end
+
+      def handle_operation_error(operation, error)
+        error_suffix = ":\n  " + parse_api_errors(operation.file, error).join("\n  ")
+        report_error(operation, error_suffix)
+      end
+
+      def overwrite_json?
+        theme_created_at_runtime? || @overwrite_json
+      end
+
+      def update_checksums(api_response)
+        api_response.each do |asset|
+          next unless asset["key"]
+
+          checksums[asset["key"]] = asset["checksum"]
+        end
+
+        checksums.reject_duplicated_checksums!
+      end
+
+      def report_file_error(file, error_message = "")
+        path = file.relative_path
+
+        @error_checksums << checksums[path]
+        @error_reporter.report(error_message)
+      end
+
+      def parse_api_errors(file, exception)
+        parsed_body = {}
+
+        if exception.respond_to?(:response)
+          response = exception.response
+
+          parsed_body = if response&.is_a?(Hash)
+            response&.[](:body)
+          else
+            JSON.parse(response&.body)
+          end
+        end
+
+        errors = parsed_body.dig("errors") # either nil or another type
+        errors = errors.dig("asset") if errors&.is_a?(Hash)
+
+        message = errors || parsed_body["message"] || exception.message
+        # Truncate to first lines
+        [message].flatten.map { |m| m.split("\n", 2).first }
+      rescue JSON::ParserError
+        [exception.message]
+      rescue StandardError => e
+        cause = "(cause: #{e.message})"
+        backtrace = e.backtrace.join("\n")
+        ["The asset #{file} could not be synced #{cause} #{backtrace}"]
+      end
+
+      private
+
+      def download_and_write_binary(url, file)
+        uri = URI.parse(url)
+        response = HttpRequest.get(uri, nil, { "Content-Type" => "application/octet-stream" })
+
+        case response.code.to_i
+        when 200..399
+          file.write(response.body)
+        else
+          raise "Failed to download binary asset from #{url}: #{response.code} #{response.body}"
+        end
+      end
+
+      def report_error(operation, error_suffix = "")
+        file = operation.file
+        error_message = "#{operation.as_error_message}#{error_suffix}"
+
+        report_file_error(file, error_message)
+      end
+
+      def enqueue(method, file, options = {})
+        raise ArgumentError, "file required" unless file
+        raise ArgumentError, "method '#{method}' cannot be queued" unless QUEUEABLE_METHODS.include?(method)
+
+        operation = Operation.new(@ctx, method, @theme[file], options)
+
+        return unless enqueueable?(operation)
+
+        @pending << operation
+        @queue << operation unless @queue.closed?
+      end
+
+      def report_performed_operation(operation)
+        file = operation.file
+
+        if file.warnings.any?
+          warning_message =
+            operation.as_synced_message(color: :yellow) +
+            UnsupportedScriptWarning.new(@ctx, file).to_s
+
+          return @error_reporter.report(warning_message)
+        end
+
+        @standard_reporter.report(operation.as_synced_message)
+      end
+
+      def perform(operation)
+        return if @queue.closed?
+
+        @ctx.debug(operation.to_s)
+
+        response = send(operation.method, operation.file, operation.options)
+
+        report_performed_operation(operation)
+      rescue StandardError => error
+        handle_operation_error(operation, error)
+      ensure
+        @pending.delete(operation)
+      end
+
+      def update(file, _options = {})
+        application_theme_resource = { key: file.relative_path }
+        path = "application_themes/#{@theme.id}/resources"
+        
+        if file.text?
+          application_theme_resource[:content] = file.read
+          _status, body, response = api_client.put(
+          path: path,
+          body: JSON.generate(application_theme_resource: application_theme_resource),
+        )
+        else
+          ::File.open(file.path) do |f|
+            _status, body, response = api_client.multipart_put(
+              path: path,
+              body: {
+                :'application_theme_resource[key]' => file.relative_path,
+                :'application_theme_resource[file]' => UploadIO.new(f, file.mime_type.name, file.name)
+              }
+            )
+          end
+        end
+
+        update_checksums([body["application_theme_resource"]])
+
+        response
+      end
+
+      def get(file, _options = {})
+        _status, body, response = api_client.get(
+          path: "themes/#{@theme.id}/assets.json",
+          query: URI.encode_www_form("asset[key]" => file.relative_path),
+        )
+
+        update_checksums(body)
+
+        attachment = body.dig("asset", "attachment")
+        if attachment
+          file.write(Base64.decode64(attachment))
+        else
+          file.write(body.dig("asset", "value"))
+        end
+
+        response
+      end
+
+
+      def get_asset(file, options = {})
+        url = options[:url]
+        uri = URI.parse(url)
+        response = HttpRequest.get(uri, nil, { "Content-Type" => "application/octet-stream" })
+
+        case response.code.to_i
+        when 200..399
+          file.write(response.body)
+        else
+          raise "Failed to download binary asset from #{url}: #{response.code} #{response.body}"
+        end
+      end
+
+      def delete(file, _options = {})
+        _status, _body, response = api_client.delete(
+          path: "application_themes/#{@theme.id}/resources",
+          body: JSON.generate(:application_theme_resource => {
+            key: file.relative_path,
+          }),
+        )
+
+        checksums.delete(file) if checksums.has?(file)
+
+        response
+      end
+
+      def union_merge(file, _options = {})
+        _status, body, response = api_client.get(
+          path: "themes/#{@theme.id}/assets.json",
+          query: URI.encode_www_form("asset[key]" => file.relative_path),
+        )
+
+        return response unless file.text?
+
+        remote_content = body.dig("asset", "value")
+
+        return response if remote_content.nil?
+
+        content = Merger.union_merge(file, remote_content)
+
+        file.write(content)
+
+        enqueue(:update, file)
+
+        response
+      end
+
+      def theme_created_at_runtime?
+        @theme.created_at_runtime?
+      end
+
+      def wait(duration)
+        sleep(duration)
+      end
+    end
+  end
+end