shopify-cli 2.7.1 → 2.8.0

data/lib/shopify_cli/theme/dev_server/hot-reload.js

@@ -17,19 +17,48 @@
 
   connect();
 
+  function isRefreshRequired(files) {
+    return files.some((file) => !isCssFile(file) && !isSectionFile(file));
+  }
+
+  function refreshFile(file) {
+    if (isCssFile(file)) {
+      reloadCssFile(file);
+      return;
+    }
+
+    if (isSectionFile(file)) {
+      reloadSection(file);
+      return;
+    }
+  }
+
+  function setHotReloadCookie(files) {
+    var date = new Date();
+
+    // Hot reload cookie expires in 3 seconds
+    date.setSeconds(date.getSeconds() + 3);
+    
+    var sections = files.join(',');
+    var expires = date.toUTCString();
+
+    document.cookie = `hot_reload_sections=${sections}; expires=${expires}; path=/`;
+  }
+
+  function refreshPage(files) {
+    setHotReloadCookie(files);
+    console.log('[HotReload] Refreshing entire page');
+    window.location.reload();
+  }
+
   function handleUpdate(message) {
     var data = JSON.parse(message.data);
+    var modifiedFiles = data.modified;
 
-    // Assume only one file is modified at a time
-    var modified = data.modified[0];
-
-    if (isCssFile(modified)) {
-      reloadCssFile(modified)
-    } else if (isSectionFile(modified)) {
-      reloadSection(modified);
+    if (isRefreshRequired(modifiedFiles)) {
+      refreshPage(modifiedFiles);
     } else {
-      console.log(`[HotReload] Refreshing entire page`);
-      window.location.reload();
+      modifiedFiles.forEach(refreshFile);
     }
   }
 

data/lib/shopify_cli/theme/dev_server/proxy/template_param_builder.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module ShopifyCLI
+  module Theme
+    module DevServer
+      class Proxy
+        class TemplateParamBuilder
+          def build
+            # Core doesn't support replace_templates
+            return {} if core?(current_path)
+
+            (syncer_templates + request_templates)
+              .select { |file| file.liquid? || file.json? }
+              .uniq(&:relative_path)
+              .map { |file| as_param(file) }
+              .to_h
+          end
+
+          def with_core_endpoints(core_endpoints)
+            @core_endpoints = core_endpoints
+            self
+          end
+
+          def with_syncer(syncer)
+            @syncer = syncer
+            self
+          end
+
+          def with_rack_env(rack_env)
+            @rack_env = rack_env
+            self
+          end
+
+          def with_theme(theme)
+            @theme = theme
+            self
+          end
+
+          private
+
+          def as_param(file)
+            ["replace_templates[#{file.relative_path}]", file.read]
+          end
+
+          def syncer_templates
+            @syncer&.pending_updates || []
+          end
+
+          def request_templates
+            cookie_sections
+              .map { |section| @theme[section] unless @theme.nil? }
+              .compact
+          end
+
+          def cookie_sections
+            CGI::Cookie.parse(cookie)["hot_reload_sections"].join.split(",") || []
+          end
+
+          def core?(path)
+            core_endpoints.include?(path)
+          end
+
+          def current_path
+            rack_env["PATH_INFO"]
+          end
+
+          def cookie
+            rack_env["HTTP_COOKIE"]
+          end
+
+          def core_endpoints
+            @core_endpoints || []
+          end
+
+          def rack_env
+            @rack_env || {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/theme/dev_server/proxy.rb

@@ -2,6 +2,9 @@
 require "net/http"
 require "stringio"
 require "time"
+require "cgi"
+
+require_relative "proxy/template_param_builder"
 
 module ShopifyCLI
   module Theme
@@ -112,21 +115,12 @@ module ShopifyCLI
         end
 
         def build_replace_templates_param(env)
-          params = {}
-
-          # Core doesn't support replace_templates
-          return params if @core_endpoints.include?(env["PATH_INFO"])
-
-          pending_templates = @syncer.pending_updates.select do |file|
-            # Only replace Liquid or JSON files
-            file.liquid? || file.json?
-          end
-
-          pending_templates.each do |path|
-            params["replace_templates[#{path.relative_path}]"] = path.read
-          end
-
-          params
+          TemplateParamBuilder.new
+            .with_core_endpoints(@core_endpoints)
+            .with_syncer(@syncer)
+            .with_theme(@theme)
+            .with_rack_env(env)
+            .build
         end
 
         def add_session_cookie(cookie_header)

data/lib/shopify_cli/theme/dev_server.rb

@@ -3,6 +3,7 @@ require_relative "development_theme"
 require_relative "ignore_filter"
 require_relative "syncer"
 
+require_relative "dev_server/cdn_fonts"
 require_relative "dev_server/hot_reload"
 require_relative "dev_server/header_hash"
 require_relative "dev_server/local_assets"
@@ -24,7 +25,7 @@ module ShopifyCLI
       class << self
         attr_accessor :ctx
 
-        def start(ctx, root, http_bind: "127.0.0.1", port: 9292, poll: false)
+        def start(ctx, root, host: "127.0.0.1", port: 9292, poll: false)
           @ctx = ctx
           theme = DevelopmentTheme.new(ctx, root: root)
           ignore_filter = IgnoreFilter.from_path(root)
@@ -33,10 +34,11 @@ module ShopifyCLI
 
           # Setup the middleware stack. Mimics Rack::Builder / config.ru, but in reverse order
           @app = Proxy.new(ctx, theme: theme, syncer: @syncer)
+          @app = CdnFonts.new(@app, theme: theme)
           @app = LocalAssets.new(ctx, @app, theme: theme)
           @app = HotReload.new(ctx, @app, theme: theme, watcher: watcher, ignore_filter: ignore_filter)
           stopped = false
-          address = "http://#{http_bind}:#{port}"
+          address = "http://#{host}:#{port}"
 
           theme.ensure_exists!
 
@@ -70,7 +72,7 @@ module ShopifyCLI
           watcher.start
           WebServer.run(
             @app,
-            BindAddress: http_bind,
+            BindAddress: host,
             Port: port,
             Logger: logger,
             AccessLog: [],
@@ -83,7 +85,7 @@ module ShopifyCLI
         rescue Errno::EADDRINUSE
           abort_address_already_in_use(address)
         rescue Errno::EADDRNOTAVAIL
-          raise AddressBindingError, "Error binding to the address #{http_bind}."
+          raise AddressBindingError, "Error binding to the address #{host}."
         end
 
         def stop

data/lib/shopify_cli/theme/syncer/error_reporter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      ##
+      # ShopifyCLI::Theme::Syncer::ErrorReporter allows delaying log of errors,
+      # mainly to not break the progress bar.
+      #
+      class ErrorReporter
+        attr_reader :ctx, :delayed_errors
+
+        def initialize(ctx)
+          @ctx = ctx
+          @has_any_error = false
+          @delay_errors = false
+          @delayed_errors = []
+        end
+
+        def disable!
+          @delay_errors = true
+        end
+
+        def enable!
+          @delay_errors = false
+          @delayed_errors.each { |error| report(error) }
+          @delayed_errors.clear
+        end
+
+        def report(error_message)
+          if @delay_errors
+            @delayed_errors << error_message
+          else
+            @has_any_error = true
+            @ctx.error(error_message)
+          end
+        end
+
+        def has_any_error?
+          @has_any_error
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/theme/syncer/operation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Operation
+        attr_accessor :method, :file
+
+        COLOR_BY_STATUS = {
+          error: :red,
+          synced: :green,
+          fixed: :cyan,
+        }
+
+        def initialize(ctx, method, file)
+          @ctx = ctx
+          @method = method
+          @file = file
+        end
+
+        def to_s
+          "#{method} #{file_path}"
+        end
+
+        def as_error_message
+          as_message_with(status: :error)
+        end
+
+        def as_synced_message
+          as_message_with(status: :synced)
+        end
+
+        def as_fix_message
+          as_message_with(status: :fixed)
+        end
+
+        def file_path
+          file&.relative_path.to_s
+        end
+
+        private
+
+        def as_message_with(status:)
+          status_color = COLOR_BY_STATUS[status]
+          status_text = @ctx.message("theme.serve.operation.status.#{status}").ljust(6)
+
+          "#{timestamp} {{#{status_color}:#{status_text}}} {{>}} {{blue:#{self}}}"
+        end
+
+        def timestamp
+          Time.now.strftime("%T")
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/theme/syncer/standard_reporter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      ##
+      # ShopifyCLI::Theme::Syncer::StdReporter allows disabling/enabling
+      # messages reported in the standard output (ShopifyCLI::Context#puts).
+      #
+      class StandardReporter
+        attr_reader :ctx
+
+        def initialize(ctx)
+          @enabled = true
+          @ctx = ctx
+        end
+
+        def disable!
+          @enabled = false
+        end
+
+        def enable!
+          @enabled = true
+        end
+
+        def report(message)
+          ctx.puts(message) if @enabled
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/theme/syncer.rb

@@ -2,24 +2,31 @@
 require "thread"
 require "json"
 require "base64"
+require "forwardable"
+
+require_relative "syncer/error_reporter"
+require_relative "syncer/standard_reporter"
+require_relative "syncer/operation"
 
 module ShopifyCLI
   module Theme
     class Syncer
-      class Operation < Struct.new(:method, :file)
-        def to_s
-          "#{method} #{file&.relative_path}"
-        end
-      end
+      extend Forwardable
+
       API_VERSION = "unstable"
 
       attr_reader :checksums
       attr_accessor :ignore_filter
 
+      def_delegators :@error_reporter, :has_any_error?
+
       def initialize(ctx, theme:, ignore_filter: nil)
         @ctx = ctx
         @theme = theme
         @ignore_filter = ignore_filter
+        @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
@@ -30,12 +37,19 @@ module ShopifyCLI
         # Mutex used to pause all threads when backing-off when hitting API rate limits
         @backoff_mutex = Mutex.new
 
-        # Allows delaying log of errors, mainly to not break the progress bar.
-        @delay_errors = false
-        @delayed_errors = []
-
         # Latest theme assets checksums. Updated on each upload.
         @checksums = {}
+
+        # Checksums of assets with errors. 
+        @error_checksums = []
+      end
+
+      def lock_io!
+        @reporters.each { |reporter| reporter.disable! }
+      end
+
+      def unlock_io!
+        @reporters.each { |reporter| reporter.enable! }
       end
 
       def enqueue_updates(files)
@@ -103,25 +117,14 @@ module ShopifyCLI
               break if operation.nil? # shutdown was called
               perform(operation)
             rescue Exception => e
-              report_error(
-                "{{red:ERROR}} {{blue:#{operation}}}: #{e}" +
-                (@ctx.debug? ? "\n\t#{e.backtrace.join("\n\t")}" : "")
-              )
+              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 delay_errors!
-        @delay_errors = true
-      end
-
-      def report_errors!
-        @delay_errors = false
-        @delayed_errors.each { |error| report_error(error) }
-        @delayed_errors.clear
-      end
-
       def upload_theme!(delay_low_priority_files: false, delete: true, &block)
         fetch_checksums!
 
@@ -177,21 +180,27 @@ module ShopifyCLI
 
       private
 
+      def report_error(operation, error_suffix = "")
+        @error_checksums << @checksums[operation.file_path]
+        @error_reporter.report("#{operation.as_error_message}#{error_suffix}")
+      end
+
       def enqueue(method, file)
         raise ArgumentError, "file required" unless file
 
-        operation = Operation.new(method, @theme[file])
+        operation = Operation.new(@ctx, method, @theme[file])
 
         # Already enqueued
         return if @pending.include?(operation)
 
-        if @ignore_filter&.ignore?(operation.file.relative_path)
-          @ctx.debug("ignore #{operation.file.relative_path}")
+        if @ignore_filter&.ignore?(operation.file_path)
+          @ctx.debug("ignore #{operation.file_path}")
           return
         end
 
         if [:update, :get].include?(method) && operation.file.exist? && !file_has_changed?(operation.file)
-          @ctx.debug("skip #{operation}")
+          is_fixed = !!@error_checksums.delete(operation.file.checksum)
+          @standard_reporter.report(operation.as_fix_message) if is_fixed
           return
         end
 
@@ -206,16 +215,16 @@ module ShopifyCLI
 
         response = send(operation.method, operation.file)
 
+        @standard_reporter.report(operation.as_synced_message)
+
         # Check if the API told us we're near the rate limit
         if !backingoff? && (limit = response["x-shopify-shop-api-call-limit"])
           used, total = limit.split("/").map(&:to_i)
           backoff_if_near_limit!(used, total)
         end
       rescue ShopifyCLI::API::APIRequestError => e
-        report_error(
-          "{{red:ERROR}} {{blue:#{operation}}}:\n  " +
-          parse_api_errors(e).join("\n  ")
-        )
+        error_suffix = ":\n  " + parse_api_errors(e).join("\n  ")
+        report_error(operation, error_suffix)
       ensure
         @pending.delete(operation)
       end
@@ -295,14 +304,6 @@ module ShopifyCLI
         file.checksum != @checksums[file.relative_path.to_s]
       end
 
-      def report_error(error)
-        if @delay_errors
-          @delayed_errors << error
-        else
-          @ctx.puts(error)
-        end
-      end
-
       def parse_api_errors(exception)
         parsed_body = JSON.parse(exception&.response&.body)
         message = parsed_body.dig("errors", "asset") || parsed_body["message"] || exception.message

data/lib/shopify_cli/theme/theme.rb

@@ -162,26 +162,38 @@ module ShopifyCLI
         }
       end
 
-      def self.all(ctx, root: nil)
-        _status, body = AdminAPI.rest_request(
-          ctx,
-          shop: AdminAPI.get_shop_or_abort(ctx),
-          path: "themes.json",
-          api_version: "unstable",
-        )
+      class << self
+        def all(ctx, root: nil)
+          _status, body = fetch_themes(ctx)
+
+          body["themes"]
+            .sort_by { |theme_attrs| Time.parse(theme_attrs["updated_at"]) }
+            .reverse
+            .map { |theme_attrs| new(ctx, root: root, **allowed_attrs(theme_attrs)) }
+        end
+
+        def live(ctx, root: nil)
+          _status, body = fetch_themes(ctx)
 
-        body["themes"]
-          .sort_by { |attributes| Time.parse(attributes["updated_at"]) }
-          .reverse
-          .map do |attributes|
-            new(
-              ctx,
-              root: root,
-              id: attributes["id"],
-              name: attributes["name"],
-              role: attributes["role"],
-            )
-          end
+          body["themes"]
+            .find { |theme_attrs| theme_attrs["role"] == "main" }
+            .tap { |theme_attrs| break new(ctx, root: root, **allowed_attrs(theme_attrs)) }
+        end
+
+        private
+
+        def allowed_attrs(attrs)
+          attrs.slice("id", "name", "role").transform_keys(&:to_sym)
+        end
+
+        def fetch_themes(ctx)
+          AdminAPI.rest_request(
+            ctx,
+            shop: AdminAPI.get_shop_or_abort(ctx),
+            path: "themes.json",
+            api_version: "unstable",
+          )
+        end
       end
 
       private

data/lib/shopify_cli/thread_pool/job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  class ThreadPool
+    class Job
+      attr_reader :error
+
+      def perform!
+        raise "`#{self.class.name}#perform!` must be defined"
+      end
+
+      def call
+        perform!
+      rescue StandardError => error
+        @error = error
+      end
+
+      def success?
+        !@error
+      end
+
+      def error?
+        !!@error
+      end
+    end
+  end
+end

data/lib/shopify_cli/thread_pool.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  class ThreadPool
+    attr_reader :errors
+
+    def initialize(pool_size: 10)
+      @jobs = Queue.new
+      @pool = Array.new(pool_size) { spawn_thread }
+    end
+
+    def schedule(job)
+      @jobs << job
+    end
+
+    def shutdown
+      @pool.size.times do
+        schedule(-> { throw(:stop_thread) })
+      end
+      @pool.map(&:join)
+    ensure
+      @jobs.close
+    end
+
+    private
+
+    def spawn_thread
+      Thread.new do
+        catch(:stop_thread) do
+          loop do
+            @jobs.pop.call
+          end
+        end
+      end
+    end
+  end
+end