shopify-cli 2.7.4 → 2.10.1

data/lib/shopify_cli/environment.rb

@@ -4,6 +4,21 @@ module ShopifyCLI
   module Environment
     TRUTHY_ENV_VARIABLE_VALUES = ["1", "true", "TRUE", "yes", "YES"]
 
+    def self.interactive=(interactive)
+      @interactive = interactive
+    end
+
+    def self.interactive?(env_variables: ENV)
+      if env_variables.key?(Constants::EnvironmentVariables::TTY)
+        env_variable_truthy?(
+          Constants::EnvironmentVariables::TTY,
+          env_variables: env_variables
+        )
+      else
+        @interactive ||= STDIN.tty?
+      end
+    end
+
     def self.development?(env_variables: ENV)
       env_variable_truthy?(
         Constants::EnvironmentVariables::DEVELOPMENT,
@@ -11,10 +26,6 @@ module ShopifyCLI
       )
     end
 
-    def self.interactive?
-      ShopifyCLI::Context.new.tty?
-    end
-
     def self.use_local_partners_instance?(env_variables: ENV)
       env_variable_truthy?(
         Constants::EnvironmentVariables::LOCAL_PARTNERS,
@@ -50,17 +61,10 @@ module ShopifyCLI
       )
     end
 
-    def self.use_spin_partners_instance?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::SPIN_PARTNERS,
-        env_variables: env_variables
-      )
-    end
-
     def self.partners_domain(env_variables: ENV)
       if use_local_partners_instance?(env_variables: env_variables)
         "partners.myshopify.io"
-      elsif use_spin_partners_instance?(env_variables: env_variables)
+      elsif use_spin?(env_variables: env_variables)
         "partners.#{spin_url(env_variables: env_variables)}"
       else
         "partners.shopify.com"
@@ -68,15 +72,31 @@ module ShopifyCLI
     end
 
     def self.use_spin?(env_variables: ENV)
-      !env_variables[Constants::EnvironmentVariables::SPIN_WORKSPACE].nil? &&
-        !env_variables[Constants::EnvironmentVariables::SPIN_NAMESPACE].nil?
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::SPIN,
+        env_variables: env_variables
+      ) || env_variable_truthy?(
+        Constants::EnvironmentVariables::SPIN_PARTNERS,
+        env_variables: env_variables
+      )
+    end
+
+    def self.infer_spin?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::INFER_SPIN,
+        env_variables: env_variables
+      )
     end
 
     def self.spin_url(env_variables: ENV)
-      spin_workspace = spin_workspace(env_variables: env_variables)
-      spin_namespace = spin_namespace(env_variables: env_variables)
-      spin_host = spin_host(env_variables: env_variables)
-      "#{spin_workspace}.#{spin_namespace}.#{spin_host}"
+      if infer_spin?(env_variables: env_variables)
+        %x(spin info fqdn 2> /dev/null).strip
+      else
+        spin_workspace = spin_workspace(env_variables: env_variables)
+        spin_namespace = spin_namespace(env_variables: env_variables)
+        spin_host = spin_host(env_variables: env_variables)
+        "#{spin_workspace}.#{spin_namespace}.#{spin_host}"
+      end
     end
 
     def self.send_monorail_events?(env_variables: ENV)
@@ -95,11 +115,21 @@ module ShopifyCLI
     end
 
     def self.spin_workspace(env_variables: ENV)
-      env_variables[Constants::EnvironmentVariables::SPIN_WORKSPACE]
+      env_value = env_variables[Constants::EnvironmentVariables::SPIN_WORKSPACE]
+      return env_value unless env_value.nil?
+
+      if env_value.nil?
+        raise "No value set for #{Constants::EnvironmentVariables::SPIN_WORKSPACE}"
+      end
     end
 
     def self.spin_namespace(env_variables: ENV)
-      env_variables[Constants::EnvironmentVariables::SPIN_NAMESPACE]
+      env_value = env_variables[Constants::EnvironmentVariables::SPIN_NAMESPACE]
+      return env_value unless env_value.nil?
+
+      if env_value.nil?
+        raise "No value set for #{Constants::EnvironmentVariables::SPIN_NAMESPACE}"
+      end
     end
 
     def self.spin_host(env_variables: ENV)

data/lib/shopify_cli/identity_auth.rb

@@ -229,6 +229,7 @@ module ShopifyCLI
       uri = URI.parse("#{auth_url}#{endpoint}")
       https = Net::HTTP.new(uri.host, uri.port)
       https.use_ssl = true
+      https.verify_mode = OpenSSL::SSL::VERIFY_NONE if ENV["SSL_VERIFY_NONE"]
       request = Net::HTTP::Post.new(uri.path)
       request["User-Agent"] = "Shopify CLI #{::ShopifyCLI::VERSION}"
       request.body = URI.encode_www_form(params)
@@ -255,7 +256,7 @@ module ShopifyCLI
     def auth_url
       if Environment.use_local_partners_instance?
         "https://identity.myshopify.io/oauth"
-      elsif Environment.use_spin_partners_instance?
+      elsif Environment.use_spin?
         "https://identity.#{Environment.spin_url}/oauth"
       else
         "https://accounts.shopify.com/oauth"
@@ -263,7 +264,7 @@ module ShopifyCLI
     end
 
     def client_id_for_application(application_name)
-      client_ids = if Environment.use_local_partners_instance? || Environment.use_spin_partners_instance?
+      client_ids = if Environment.use_local_partners_instance? || Environment.use_spin?
         DEV_APPLICATION_CLIENT_IDS
       else
         APPLICATION_CLIENT_IDS
@@ -279,7 +280,7 @@ module ShopifyCLI
     end
 
     def client_id
-      if Environment.use_local_partners_instance? || Environment.use_spin_partners_instance?
+      if Environment.use_local_partners_instance? || Environment.use_spin?
         Constants::Identity::CLIENT_ID_DEV
       else
         # In the future we might want to use Identity's dynamic

data/lib/shopify_cli/messages/messages.rb

@@ -790,6 +790,8 @@ module ShopifyCLI
           logged_in_partner_only: "Logged into partner organization {{green:%s}}",
           logged_in_partner_and_shop: "Logged into store {{green:%s}} in partner organization {{green:%s}}",
         },
+        error: "Error",
+        try_this: "Try this",
       },
     }.freeze
   end

data/lib/shopify_cli/method_object.rb

@@ -66,15 +66,27 @@ module ShopifyCLI
       # initializer or to `call`. If the keyword argument matches the name of
       # property, it is forwarded to the initializer, otherwise to call.
       #
-      def call(*args, **kwargs, &block)
-        properties.keys.yield_self do |properties|
-          instance = new(**kwargs.slice(*properties))
-          kwargs = kwargs.slice(*(kwargs.keys - properties))
-          if kwargs.any?
-            instance.call(*args, **kwargs, &block)
-          else
-            instance.call(*args, &block)
-          end
+      ruby2_keywords def call(*args, &block)
+        # This is an extremely complicated case of delegation. The method wants
+        # to delegate arguments, but to have control over which keyword
+        # arguments are delegated. I'm not sure the forward and backward
+        # compatibility of this unusual form of delegation has really been
+        # explored or there's any good way to support it. So I have done
+        # done something hacky here and I'm looking at the last argument and
+        # modifying the package of arguments to be delegated in-place.
+        if args.last.is_a?(Hash)
+          kwargs = args.last
+
+          initializer_kwargs = kwargs.slice(*properties.keys)
+          instance = new(**initializer_kwargs)
+
+          kwargs.reject! { |key| initializer_kwargs.key?(key) }
+          args.pop if kwargs.empty?
+          instance.call(*args, &block)
+        else
+          # Since the former is so complicated - let's have a fast path that
+          # is much simpler.
+          new.call(*args, &block)
         end
       end
 

data/lib/shopify_cli/resources/env_file.rb

@@ -14,6 +14,10 @@ module ShopifyCLI
       }
 
       class << self
+        def path(directory)
+          File.join(directory, FILENAME)
+        end
+
         def read(_directory = Dir.pwd, overrides: {})
           input = parse_external_env(overrides: overrides)
           new(input)
@@ -24,7 +28,7 @@ module ShopifyCLI
         end
 
         def parse(directory)
-          File.read(File.join(directory, FILENAME))
+          File.read(path(directory))
             .gsub("\r\n", "\n").split("\n").each_with_object({}) do |line, output|
             match = /\A([A-Za-z_0-9]+)\s*=\s*(.*)\z/.match(line)
             if match

data/lib/shopify_cli/result.rb

@@ -363,70 +363,72 @@ module ShopifyCLI
       Result::Failure.new(error)
     end
 
-    ##
-    # takes either a value or a block and chooses the appropriate result
-    # container based on the type of the value or the type of the block's return
-    # value. If the type is an exception, it is wrapped in a
-    # `ShopifyCLI::Result::Failure` and otherwise in a
-    # `ShopifyCLI::Result::Success`. If a block was provided instead of value, a
-    # `Proc` is returned and the result wrapping doesn't occur until the block
-    # is invoked.
-    #
-    # #### Parameters
-    #
-    # * `*args` should be an `Array` with zero or one element
-    # * `&block` should be a `Proc` that takes zero or one argument
-    #
-    # #### Returns
-    #
-    # Returns either a `Result::Success`, `Result::Failure` or a `Proc` that
-    # produces one of the former when invoked.
-    #
-    # #### Examples
-    #
-    #   Result.wrap(1) # => ShopifyCLI::Result::Success
-    #   Result.wrap(RuntimeError.new) # => ShopifyCLI::Result::Failure
-    #
-    #   Result.wrap { 1 } # => Proc
-    #   Result.wrap { 1 }.call # => ShopifyCLI::Result::Success
-    #   Result.wrap { raise }.call # => ShopifyCLI::Result::Failure
-    #
-    #   Result.wrap { |s| s.upcase }.call("hello").tap do |result|
-    #     result # => Result::Success
-    #     result.value # => "HELLO"
-    #   end
-    #
-    def self.wrap(*values, &block)
-      raise ArgumentError, "expected either a value or a block" unless (values.length == 1) ^ block
+    class << self
+      ##
+      # takes either a value or a block and chooses the appropriate result
+      # container based on the type of the value or the type of the block's return
+      # value. If the type is an exception, it is wrapped in a
+      # `ShopifyCli::Result::Failure` and otherwise in a
+      # `ShopifyCli::Result::Success`. If a block was provided instead of value, a
+      # `Proc` is returned and the result wrapping doesn't occur until the block
+      # is invoked.
+      #
+      # #### Parameters
+      #
+      # * `*args` should be an `Array` with zero or one element
+      # * `&block` should be a `Proc` that takes zero or one argument
+      #
+      # #### Returns
+      #
+      # Returns either a `Result::Success`, `Result::Failure` or a `Proc` that
+      # produces one of the former when invoked.
+      #
+      # #### Examples
+      #
+      #   Result.wrap(1) # => ShopifyCli::Result::Success
+      #   Result.wrap(RuntimeError.new) # => ShopifyCli::Result::Failure
+      #
+      #   Result.wrap { 1 } # => Proc
+      #   Result.wrap { 1 }.call # => ShopifyCli::Result::Success
+      #   Result.wrap { raise }.call # => ShopifyCli::Result::Failure
+      #
+      #   Result.wrap { |s| s.upcase }.call("hello").tap do |result|
+      #     result # => Result::Success
+      #     result.value # => "HELLO"
+      #   end
+      #
+      ruby2_keywords def wrap(*values, &block)
+        raise ArgumentError, "expected either a value or a block" unless (values.length == 1) ^ block
 
-      if values.length == 1
-        values.pop.yield_self do |value|
-          case value
-          when Result::Success, Result::Failure
-            value
-          when NilClass, Exception
-            Result.failure(value)
-          else
-            Result.success(value)
-          end
-        end
-      else
-        ->(*args) do
-          begin
-            wrap(block.call(*args))
-          rescue Exception => error # rubocop:disable Lint/RescueException
-            wrap(error)
+        if values.length == 1
+          values.pop.yield_self do |value|
+            case value
+            when Result::Success, Result::Failure
+              value
+            when NilClass, Exception
+              Result.failure(value)
+            else
+              Result.success(value)
+            end
           end
+        else
+          ->(*args) do
+            begin
+              wrap(block.call(*args))
+            rescue Exception => error # rubocop:disable Lint/RescueException
+              wrap(error)
+            end
+          end.ruby2_keywords
         end
       end
-    end
 
-    ##
-    # Wraps the given block and invokes it with the passed arguments.
-    #
-    def self.call(*args, &block)
-      raise ArgumentError, "expected a block" unless block
-      wrap(&block).call(*args)
+      ##
+      # Wraps the given block and invokes it with the passed arguments.
+      #
+      ruby2_keywords def call(*args, &block)
+        raise ArgumentError, "expected a block" unless block
+        wrap(&block).call(*args)
+      end
     end
   end
 end

data/lib/shopify_cli/task.rb

@@ -2,9 +2,11 @@ require "shopify_cli"
 
 module ShopifyCLI
   class Task
-    def self.call(*args, **kwargs)
-      task = new
-      task.call(*args, **kwargs)
+    class << self
+      ruby2_keywords def call(*args)
+        task = new
+        task.call(*args)
+      end
     end
 
     private

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

@@ -15,9 +15,23 @@
     eventSource.onerror = () => eventSource.close();
   }
 
-  connect();
+  function reloadMode() {
+    var namespace = window.__SHOPIFY_CLI_ENV__;
+    return namespace.mode;
+  }
+
+  function isFullPageReloadMode(){
+    return reloadMode() === "full-page";
+  }
+
+  function isReloadModeActive(){
+    return reloadMode() !== "off";
+  }
 
   function isRefreshRequired(files) {
+    if (isFullPageReloadMode()) {
+      return true;
+    }
     return files.some((file) => !isCssFile(file) && !isSectionFile(file));
   }
 
@@ -119,4 +133,8 @@
       }
     }
   }
+
+  if (isReloadModeActive()) {
+    connect();
+  }
 })();

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

@@ -4,10 +4,11 @@ module ShopifyCLI
   module Theme
     module DevServer
       class HotReload
-        def initialize(ctx, app, theme:, watcher:, ignore_filter: nil)
+        def initialize(ctx, app, theme:, watcher:, mode:, ignore_filter: nil)
           @ctx = ctx
           @app = app
           @theme = theme
+          @mode = mode
           @streams = SSE::Streams.new
           @watcher = watcher
           @watcher.add_observer(self, :notify_streams_of_file_change)
@@ -48,12 +49,27 @@ module ShopifyCLI
 
         def inject_hot_reload_javascript(body)
           hot_reload_js = ::File.read("#{__dir__}/hot-reload.js")
-          hot_reload_script = "<script>\n#{hot_reload_js}</script>"
+          hot_reload_script = [
+            "<script>",
+            params_js,
+            hot_reload_js,
+            "</script>",
+          ].join("\n")
+
           body = body.join.gsub("</body>", "#{hot_reload_script}\n</body>")
 
           [body]
         end
 
+        def params_js
+          env = { mode: @mode }
+          <<~JS
+            (() => {
+              window.__SHOPIFY_CLI_ENV__ = #{env.to_json};
+            })();
+          JS
+        end
+
         def create_stream
           stream = @streams.new
 

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

@@ -18,6 +18,7 @@ module ShopifyCLI
         "trailer",
         "transfer-encoding",
         "upgrade",
+        "content-security-policy",
       ]
 
       class Proxy

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    module DevServer
+      class ReloadMode
+        MODES = [:"hot-reload", :"full-page", :off]
+
+        class << self
+          def default
+            :"hot-reload"
+          end
+
+          def get!(mode)
+            MODES.find { |m| m == mode.to_sym } || raise_error(mode)
+          end
+
+          private
+
+          def raise_error(invalid_mode)
+            error_message = ShopifyCLI::Context.message("theme.serve.reload_mode_is_not_valid", invalid_mode)
+            help_message = ShopifyCLI::Context.message("theme.serve.try_a_valid_reload_mode", valid_modes)
+
+            ShopifyCLI::Context.abort(error_message, help_message)
+          end
+
+          def valid_modes
+            MODES.map { |v| "`#{v}`" }.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/theme/dev_server.rb

@@ -6,6 +6,7 @@ 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/reload_mode"
 require_relative "dev_server/local_assets"
 require_relative "dev_server/proxy"
 require_relative "dev_server/sse"
@@ -25,7 +26,7 @@ module ShopifyCLI
       class << self
         attr_accessor :ctx
 
-        def start(ctx, root, host: "127.0.0.1", port: 9292, poll: false)
+        def start(ctx, root, host: "127.0.0.1", port: 9292, poll: false, mode: ReloadMode.default)
           @ctx = ctx
           theme = DevelopmentTheme.new(ctx, root: root)
           ignore_filter = IgnoreFilter.from_path(root)
@@ -36,7 +37,7 @@ module ShopifyCLI
           @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)
+          @app = HotReload.new(ctx, @app, theme: theme, watcher: watcher, mode: mode, ignore_filter: ignore_filter)
           stopped = false
           address = "http://#{host}:#{port}"
 
@@ -83,7 +84,9 @@ module ShopifyCLI
                ShopifyCLI::API::APIRequestUnauthorizedError
           raise ShopifyCLI::Abort, @ctx.message("theme.serve.ensure_user", theme.shop)
         rescue Errno::EADDRINUSE
-          abort_address_already_in_use(address)
+          error_message = @ctx.message("theme.serve.address_already_in_use", address)
+          help_message = @ctx.message("theme.serve.try_port_option")
+          @ctx.abort(error_message, help_message)
         rescue Errno::EADDRNOTAVAIL
           raise AddressBindingError, "Error binding to the address #{host}."
         end
@@ -94,24 +97,6 @@ module ShopifyCLI
           @syncer.shutdown
           WebServer.shutdown
         end
-
-        private
-
-        def abort_address_already_in_use(address)
-          open_frame(@ctx.message("theme.serve.already_in_use_error"), color: :red) do
-            @ctx.puts(@ctx.message("theme.serve.address_already_in_use", address))
-          end
-
-          open_frame(@ctx.message("theme.serve.try_this"), color: :green) do
-            @ctx.puts(@ctx.message("theme.serve.try_port_option"))
-          end
-
-          raise ShopifyCLI::AbortSilent
-        end
-
-        def open_frame(title, color:, &block)
-          CLI::UI::Frame.open(title, color: CLI::UI.resolve_color(color), timing: false, &block)
-        end
       end
     end
   end

data/lib/shopify_cli/theme/file.rb

@@ -18,7 +18,7 @@ module ShopifyCLI
 
       def read
         if text?
-          path.read
+          path.read(universal_newline: true)
         else
           path.read(mode: "rb")
         end
@@ -27,7 +27,7 @@ module ShopifyCLI
       def write(content)
         path.parent.mkpath unless path.parent.directory?
         if text?
-          path.write(content)
+          path.write(content, universal_newline: true)
         else
           path.write(content, 0, mode: "wb")
         end

data/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

data/lib/shopify_cli/theme/ignore_filter.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative "filter/path_matcher"
+
 module ShopifyCLI
   module Theme
     class IgnoreFilter
+      include Filter::PathMatcher
+
       FILE = ".shopifyignore"
 
       DEFAULT_REGEXES = [
@@ -72,11 +76,11 @@ module ShopifyCLI
         return true if path.empty?
 
         regexes.each do |regex|
-          return true if regex.match(path)
+          return true if regex_match?(regex, path)
         end
 
         globs.each do |glob|
-          return true if ::File.fnmatch?(glob, path)
+          return true if glob_match?(glob, path)
         end
 
         false
@@ -91,24 +95,16 @@ module ShopifyCLI
         new_regexes = DEFAULT_REGEXES.dup
         new_globs = DEFAULT_GLOBS.dup
 
-        patterns.each do |pattern|
-          pattern = pattern.strip
-
-          if pattern.start_with?("/") && pattern.end_with?("/")
-            new_regexes << Regexp.new(pattern.gsub(%r{^\/|\/$}, ""))
-            next
+        patterns
+          .map(&:strip)
+          .each do |pattern|
+            if regex?(pattern)
+              new_regexes << as_regex(pattern)
+            else
+              new_globs << as_glob(pattern)
+            end
           end
 
-          # 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?("*")
-
-          new_globs << pattern
-        end
-
         [new_regexes, new_globs]
       end
     end