@shopify/cli-kit 3.38.0 → 3.40.0

package/assets/cli-ruby/lib/shopify_cli/theme/extension/syncer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "syncer/extension_serve_job"
+require_relative "syncer/operation"
+
+require "shopify_cli/thread_pool"
+
+module ShopifyCLI
+  module Theme
+    module Extension
+      class Syncer
+        attr_accessor :pending_operations, :latest_sync
+
+        def initialize(ctx, extension:, project:, specification_handler:)
+          @ctx = ctx
+          @extension = extension
+          @project = project
+          @specification_handler = specification_handler
+
+          @pool = ThreadPool.new(pool_size: 1)
+          @pending_operations = extension.extension_files.map { |file| Operation.new(file, :update) }
+          @pending_operations_mutex = Mutex.new
+          @latest_sync = Time.now - ExtensionServeJob::PUSH_INTERVAL
+        end
+
+        def enqueue_creates(files)
+          operations = files.map { |file| Operation.new(file, :create) }
+          enqueue_operations(operations)
+        end
+
+        def enqueue_updates(files)
+          operations = files.map { |file| Operation.new(file, :update) }
+          enqueue_operations(operations)
+        end
+
+        def enqueue_deletes(files)
+          operations = files.map { |file| Operation.new(file, :delete) }
+          enqueue_operations(operations)
+        end
+
+        def start
+          @pool.schedule(job)
+        end
+
+        def shutdown
+          @pool.shutdown
+        end
+
+        def pending_files
+          pending_operations.map(&:file)
+        end
+
+        def any_operation?
+          pending_operations.any?
+        end
+
+        def any_blocking_operation?
+          pending_operations.any? { |operation| operation.delete? || operation.create? }
+        end
+
+        private
+
+        def enqueue_operations(operations)
+          @pending_operations_mutex.synchronize do
+            operations.each { |f| @pending_operations << f unless @pending_operations.include?(f) }
+          end
+        end
+
+        def job
+          ExtensionServeJob.new(
+            @ctx,
+            syncer: self,
+            extension: @extension,
+            project: @project,
+            specification_handler: @specification_handler
+          )
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/extension/ui/host_theme_progress_bar.rb

@@ -0,0 +1,35 @@
+
+module ShopifyCLI
+  module Theme
+    module Extension
+      module UI
+        class HostThemeProgressBar
+          GIT_CLONE_PROGRESS_SHARE = 0.2
+          SYNC_PROGRESS_SHARE = 0.8
+
+          def initialize(syncer, dir)
+            @syncer = syncer
+            @dir = dir
+          end
+
+          def progress(method, **args)
+            @syncer.lock_io!
+            CLI::UI::Progress.progress do |bar|
+              Git.public_send(:raw_clone, "https://github.com/Shopify/dawn.git", @dir) do |percent|
+                bar.tick(set_percent: percent * GIT_CLONE_PROGRESS_SHARE)
+              end
+
+              @syncer.public_send(method, **args) do |left, total|
+                next if total == 0
+                bar.tick(set_percent: (1 - left.to_f / total) * SYNC_PROGRESS_SHARE + GIT_CLONE_PROGRESS_SHARE)
+              end
+
+              bar.tick(set_percent: 1)
+            end
+            @syncer.unlock_io!
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/file.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require_relative "mime_type"
+
+module ShopifyCLI
+  module Theme
+    class File < Struct.new(:path)
+      attr_accessor :remote_checksum
+      attr_writer :warnings
+
+      def initialize(path, root)
+        super(Pathname.new(path))
+
+        # Path may be relative or absolute depending on the source.
+        # By converting both the path and the root to absolute paths, we
+        # can safely fetch a relative path.
+        @relative_path = self.path.expand_path.relative_path_from(root.expand_path)
+      end
+
+      def read
+        if text?
+          path.read(universal_newline: true)
+        else
+          path.read(mode: "rb")
+        end
+      end
+
+      def write(content)
+        path.parent.mkpath unless path.parent.directory?
+        if text?
+          path.write(content, universal_newline: true)
+        else
+          path.write(content, 0, mode: "wb")
+        end
+      rescue Encoding::UndefinedConversionError
+        ##
+        # The CLI tries to write the file and normalize EOL characters to avoid
+        # errors on Windows when files are shared across different operational systems.
+        #
+        # The CLI fallbacks any error during the conversion by writing the file
+        # in binary mode when the normalization fails (e.g., ASCII files), so no data is lost.
+        #
+        path.write(content, 0, mode: "wb")
+      end
+
+      def delete
+        path.delete
+      end
+
+      def exist?
+        path.exist?
+      end
+
+      def mime_type
+        @mime_type ||= MimeType.by_filename(@relative_path)
+      end
+
+      def text?
+        mime_type.text?
+      end
+
+      def liquid?
+        path.extname == ".liquid"
+      end
+
+      def liquid_css?
+        relative_path.end_with?(".css.liquid")
+      end
+
+      def json?
+        path.extname == ".json"
+      end
+
+      def template?
+        relative_path.start_with?("templates/")
+      end
+
+      def checksum
+        content = read
+        if mime_type.json?
+          # Normalize JSON to match backend
+          begin
+            content = normalize_json(content)
+          rescue JSON::JSONError
+            # Fallback to using the raw content
+          end
+        end
+        Digest::MD5.hexdigest(content)
+      end
+
+      # Make it possible to check whether a given File is within a list of Files with `include?`,
+      # some of which may be relative paths while others are absolute paths.
+      def ==(other)
+        relative_path == other.relative_path
+      end
+
+      def name(*args)
+        ::File.basename(path, *args)
+      end
+
+      def absolute_path
+        path.realpath.to_s
+      end
+
+      def relative_path
+        @relative_path.to_s
+      end
+
+      def warnings
+        @warnings || []
+      end
+
+      private
+
+      def normalize_json(content)
+        parsed = JSON.parse(content)
+
+        if template?
+          JsonTemplateNormalizer.new.visit_document(parsed)
+        end
+
+        normalized = JSON.generate(parsed)
+        # Backend escapes forward slashes
+        normalized.gsub!(/\//, "\\/")
+        normalized
+      end
+
+      class JsonTemplateNormalizer
+        def visit_document(value)
+          visit_hash(value["sections"])
+        end
+
+        def visit_hash(hash)
+          return unless hash.is_a?(Hash)
+          hash.each do |_, value|
+            visit_value(value)
+          end
+        end
+
+        def visit_value(value)
+          # Reinsert settings to force the same ordering as in the backend
+          settings = value.delete("settings") || {}
+          value["settings"] = settings
+
+          visit_hash(value["blocks"])
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/filter/path_matcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    module Filter
+      module PathMatcher
+        def regex_match?(regex, path)
+          regex.match?(path)
+        rescue StandardError
+          false
+        end
+
+        def glob_match?(glob, path)
+          !!::File.fnmatch?(glob, path)
+        end
+
+        def regex?(pattern)
+          pattern.start_with?("/") && pattern.end_with?("/")
+        end
+
+        def as_regex(pattern)
+          Regexp.new(pattern.gsub(%r{^\/|\/$}, ""))
+        end
+
+        def as_glob(pattern)
+          # if specifying a directory, match everything below it
+          pattern += "*" if pattern.end_with?("/")
+
+          # The pattern will be scoped to root directory, so it should match anything
+          # within that space
+          pattern.prepend("*") unless pattern.start_with?("*")
+
+          pattern
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/ignore_filter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "filter/path_matcher"
+
+module ShopifyCLI
+  module Theme
+    class IgnoreFilter
+      include Filter::PathMatcher
+
+      FILE = ".shopifyignore"
+
+      DEFAULT_REGEXES = [
+        /\.git/,
+        /\.hg/,
+        /\.bzr/,
+        /\.svn/,
+        /_darcs/,
+        /CVS/,
+        /\.sublime-(project|workspace)/,
+        /\.DS_Store/,
+        /\.sass-cache/,
+        /Thumbs\.db/,
+        /desktop\.ini/,
+        /config.yml/,
+        /node_modules/,
+      ].freeze
+
+      DEFAULT_GLOBS = [].freeze
+
+      attr_reader :root, :globs, :regexes
+
+      def self.from_path(root)
+        root = Pathname.new(root)
+        ignore_file = root.join(FILE)
+        patterns = if ignore_file.file?
+          parse_ignore_file(ignore_file)
+        else
+          []
+        end
+        new(root, patterns: patterns)
+      end
+
+      def self.parse_ignore_file(file)
+        patterns = []
+
+        file.each_line do |line|
+          line.strip!
+
+          next if line.empty? || line.start_with?("#")
+
+          patterns << line
+        end
+
+        patterns
+      end
+
+      def initialize(root, patterns: [])
+        @root = root
+
+        regexes, globs = patterns_to_regexes_and_globs(patterns)
+
+        @regexes = regexes
+        @globs = globs
+      end
+
+      def add_patterns(patterns)
+        regexes, globs = patterns_to_regexes_and_globs(patterns)
+
+        @regexes += regexes
+        @globs += globs
+      end
+
+      def match?(path)
+        path = path.to_s
+
+        return true if path.empty?
+
+        regexes.each do |regex|
+          return true if regex_match?(regex, path)
+        end
+
+        globs.each do |glob|
+          return true if glob_match?(glob, path)
+        end
+
+        false
+      end
+      alias_method :ignore?, :match?
+
+      private
+
+      # Take in string patterns and convert them to either
+      # regex patterns or glob patterns so that they are handled in an expected manner.
+      def patterns_to_regexes_and_globs(patterns)
+        new_regexes = DEFAULT_REGEXES.dup
+        new_globs = DEFAULT_GLOBS.dup
+
+        patterns
+          .map(&:strip)
+          .each do |pattern|
+            if regex?(pattern)
+              new_regexes << as_regex(pattern)
+            else
+              new_globs << as_glob(pattern)
+            end
+          end
+
+        [new_regexes, new_globs]
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/ignore_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    module IgnoreHelper
+      def ignore_operation?(operation)
+        path = operation.file_path
+        ignore_path?(path)
+      end
+
+      def ignore_file?(file)
+        path = file.relative_path
+        ignore_path?(path)
+      end
+
+      def ignore_path?(path)
+        is_ignored = ignored_by_ignore_filter?(path) || ignored_by_include_filter?(path)
+
+        if is_ignored && @ctx
+          @ctx.debug("ignore #{path}")
+        end
+
+        is_ignored
+      end
+
+      private
+
+      def ignored_by_ignore_filter?(path)
+        ignore_filter&.ignore?(path)
+      end
+
+      def ignored_by_include_filter?(path)
+        !!include_filter && !include_filter.match?(path)
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/include_filter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "filter/path_matcher"
+
+module ShopifyCLI
+  module Theme
+    class IncludeFilter
+      include Filter::PathMatcher
+
+      attr_reader :globs, :regexes
+
+      def initialize(root, patterns = [])
+        @root = Pathname.new(root)
+        @patterns = patterns.nil? ? [] : patterns.compact.reject(&:empty?)
+
+        regexes, globs = patterns_to_regexes_and_globs(@patterns)
+
+        @regexes = regexes
+        @globs = globs
+      end
+
+      def match?(path)
+        return true unless present?(@patterns)
+
+        path = path.to_s
+        return true if path.empty?
+
+        path = @root.join(path).to_s
+
+        regexes.each do |regex|
+          return true if regex_match?(regex, path)
+        end
+
+        globs.each do |glob|
+          return true if glob_match?(glob, path)
+        end
+
+        false
+      end
+
+      private
+
+      def present?(patterns)
+        !patterns.nil? && !patterns.empty?
+      end
+
+      # Take in string patterns and convert them to either
+      # regex patterns or glob patterns so that they are handled in an expected manner.
+      def patterns_to_regexes_and_globs(patterns)
+        new_regexes = []
+        new_globs = []
+
+        patterns
+          .map(&:strip)
+          .each do |pattern|
+            if regex?(pattern)
+              new_regexes << as_regex(pattern)
+            else
+              new_globs << as_glob(pattern)
+            end
+          end
+
+        [new_regexes, new_globs]
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/mime_type.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require "webrick"
+
+module ShopifyCLI
+  module Theme
+    class MimeType < Struct.new(:name)
+      MIME_TYPES = WEBrick::HTTPUtils::DefaultMimeTypes.merge(
+        "liquid" => "text/x-liquid",
+      )
+
+      class << self
+        def by_filename(filename)
+          new(WEBrick::HTTPUtils.mime_type(filename.to_s, MIME_TYPES))
+        end
+      end
+
+      def text?
+        /text/.match?(name) || json? || javascript?
+      end
+
+      def json?
+        name == "application/json"
+      end
+
+      def javascript?
+        name == "application/javascript"
+      end
+
+      def to_s
+        name
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/root.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require_relative "file"
+require "pathname"
+
+module ShopifyCLI
+  module Theme
+    class Root
+      attr_reader :root, :ctx
+
+      def initialize(ctx, root:)
+        @ctx = ctx
+        @root = Pathname.new(root) if root
+      end
+
+      def static_asset_files
+        glob("assets/*", raise_on_dir: true).reject(&:liquid?)
+      end
+
+      def liquid_files
+        glob("**/*.liquid")
+      end
+
+      def json_files
+        glob("**/*.json")
+      end
+
+      def glob(pattern, raise_on_dir: false)
+        root
+          .glob(pattern)
+          .select { |path| file?(path, raise_on_dir) }
+          .map { |path| File.new(path, root) }
+      end
+
+      def static_asset_file?(file)
+        static_asset_files.include?(self[file])
+      end
+
+      def static_asset_paths
+        static_asset_files.map(&:relative_path)
+      end
+
+      def [](file)
+        case file
+        when File
+          file
+        when Pathname
+          File.new(file, root)
+        when String
+          File.new(root.join(file), root)
+        end
+      end
+
+      def file?(path, raise_on_dir = false)
+        if raise_on_dir && ::File.directory?(path)
+          @ctx.abort(@ctx.message("theme.serve.error.invalid_subdirectory", path.to_s))
+        end
+
+        ::File.file?(path)
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/checksums.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Checksums
+        def initialize(theme)
+          @theme = theme
+          @checksum_by_key = {}
+
+          # Mutex used to coordinate changes in the checksums (shared accross `Syncer` threads)
+          @checksums_mutex = Mutex.new
+        end
+
+        def has?(file)
+          checksum_by_key.key?(to_key(file))
+        end
+
+        def file_has_changed?(file)
+          file.checksum != checksum_by_key[file.relative_path]
+        end
+
+        def delete(file)
+          checksums_mutex.synchronize do
+            checksum_by_key.delete(to_key(file))
+          end
+        end
+
+        def keys
+          checksum_by_key.keys
+        end
+
+        def [](key)
+          checksum_by_key[key]
+        end
+
+        def []=(key, value)
+          checksums_mutex.synchronize do
+            checksum_by_key[key] = value
+          end
+        end
+
+        # Generate .liquid asset files are reported twice in checksum:
+        # once of generated, once for .liquid. We only keep the .liquid, that's the one we have
+        # on disk.
+        def reject_duplicated_checksums!
+          checksums_mutex.synchronize do
+            checksum_by_key.reject! { |key, _| checksum_by_key.key?("#{key}.liquid") }
+          end
+        end
+
+        private
+
+        def to_key(file)
+          theme[file].relative_path
+        end
+
+        # Private getters only used in unit tests
+
+        attr_reader :checksum_by_key
+        attr_reader :theme
+        attr_reader :checksums_mutex
+      end
+    end
+  end
+end