theme-check 1.7.0 → 1.9.0

data/lib/theme_check/checks/valid_schema.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 module ThemeCheck
   class ValidSchema < LiquidCheck
-    severity :suggestion
+    severity :error
     category :json
     doc docs_url(__FILE__)
 
     def on_schema(node)
-      JSON.parse(node.value.nodelist.join)
+      JSON.parse(node.inner_markup)
     rescue JSON::ParserError => e
       add_offense(format_json_parse_error(e), node: node)
     end

data/lib/theme_check/corrector.rb

@@ -2,52 +2,63 @@
 
 module ThemeCheck
   class Corrector
+    include JsonHelpers
+
     def initialize(theme_file:)
       @theme_file = theme_file
     end
 
-    def insert_after(node, content)
-      @theme_file.rewriter.insert_after(node, content)
+    def insert_after(node, content, character_range = nil)
+      @theme_file.rewriter.insert_after(node, content, character_range)
+    end
+
+    def insert_before(node, content, character_range = nil)
+      @theme_file.rewriter.insert_before(node, content, character_range)
     end
 
-    def insert_before(node, content)
-      @theme_file.rewriter.insert_before(node, content)
+    def remove(node)
+      @theme_file.rewriter.remove(node)
     end
 
-    def replace(node, content)
-      @theme_file.rewriter.replace(node, content)
+    def replace(node, content, character_range = nil)
+      @theme_file.rewriter.replace(node, content, character_range)
       node.markup = content
     end
 
+    def replace_inner_markup(node, content)
+      @theme_file.rewriter.replace_inner_markup(node, content)
+    end
+
+    def replace_inner_json(node, json, **pretty_json_opts)
+      replace_inner_markup(node, pretty_json(json, **pretty_json_opts))
+    end
+
     def wrap(node, insert_before, insert_after)
       @theme_file.rewriter.wrap(node, insert_before, insert_after)
     end
 
-    def create(theme, relative_path, content)
-      theme.storage.write(relative_path, content)
+    def create_file(storage, relative_path, content)
+      storage.write(relative_path, content)
     end
 
-    def create_default_locale_json(theme)
-      theme.default_locale_json = JsonFile.new("locales/#{theme.default_locale}.default.json", theme.storage)
-      theme.default_locale_json.update_contents({})
+    def remove_file(storage, relative_path)
+      storage.remove(relative_path)
     end
 
-    def remove(theme, relative_path)
-      theme.storage.remove(relative_path)
+    def mkdir(storage, relative_path)
+      storage.mkdir(relative_path)
     end
 
-    def mkdir(theme, relative_path)
-      theme.storage.mkdir(relative_path)
+    def add_translation(json_file, path, value)
+      hash = json_file.content
+      SchemaHelper.set(hash, path, value)
+      json_file.update_contents(hash)
     end
 
-    def add_default_translation_key(file, key, value)
-      hash = file.content
-      key.reduce(hash) do |pointer, token|
-        return pointer[token] = value if token == key.last
-        pointer[token] = {} unless pointer.key?(token)
-        pointer[token]
-      end
-      file.update_contents(hash)
+    def remove_translation(json_file, path)
+      hash = json_file.content
+      SchemaHelper.delete(hash, path)
+      json_file.update_contents(hash)
     end
   end
 end

data/lib/theme_check/exceptions.rb

@@ -22,6 +22,7 @@ module ThemeCheck
     Errno::EAGAIN,
     Errno::EHOSTUNREACH,
     Errno::ENETUNREACH,
+    Errno::EADDRNOTAVAIL,
   ]
 
   NET_HTTP_EXCEPTIONS = [

data/lib/theme_check/file_system_storage.rb

@@ -11,6 +11,10 @@ module ThemeCheck
       @files = {}
     end
 
+    def relative_path(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(@root).to_s
+    end
+
     def path(relative_path)
       @root.join(relative_path)
     end
@@ -32,13 +36,14 @@ module ThemeCheck
     end
 
     def mkdir(relative_path)
-      reset_memoizers unless file_exists?(relative_path)
-
-      file(relative_path).mkpath unless file(relative_path).directory?
+      return if file_exists?(relative_path)
+      reset_memoizers
+      file(relative_path).mkpath
     end
 
     def files
       @file_array ||= glob("**/*")
+        .reject { |path| File.directory?(path) }
         .map { |path| path.relative_path_from(@root).to_s }
     end
 

data/lib/theme_check/html_node.rb

@@ -5,12 +5,75 @@ module ThemeCheck
   class HtmlNode < Node
     extend Forwardable
     include RegexHelpers
+    include PositionHelper
     attr_reader :theme_file, :parent
 
-    def initialize(value, theme_file, placeholder_values = [], parent = nil)
+    class << self
+      include RegexHelpers
+
+      def parse(liquid_file)
+        placeholder_values = []
+        parseable_source = +liquid_file.source.clone
+
+        # Replace all non-empty liquid tags with ≬{i}######≬ to prevent the HTML
+        # parser from freaking out. We transparently replace those placeholders in
+        # HtmlNode.
+        #
+        # We're using base36 to prevent index bleeding on 36^3 tags.
+        # `{{x}}` -> `≬#{i}≬` would properly be transformed for 46656 tags in a single file.
+        # Should be enough.
+        #
+        # The base10 alternative would have overflowed at 1000 (`{{x}}` -> `≬1000≬`) which seemed more likely.
+        #
+        # Didn't go with base64 because of the `=` character that would have messed with HTML parsing.
+        #
+        # (Note, we're also maintaining newline characters in there so
+        # that line numbers match the source...)
+        matches(parseable_source, LIQUID_TAG_OR_VARIABLE).each do |m|
+          value = m[0]
+          next unless value.size > 4 # skip empty tags/variables {%%} and {{}}
+          placeholder_values.push(value)
+          key = (placeholder_values.size - 1).to_s(36)
+
+          # Doing shenanigans so that line numbers match... Ugh.
+          keyed_placeholder = parseable_source[m.begin(0)...m.end(0)]
+
+          # First and last chars are ≬
+          keyed_placeholder[0] = "≬"
+          keyed_placeholder[-1] = "≬"
+
+          # Non newline characters are #
+          keyed_placeholder.gsub!(/[^\n≬]/, '#')
+
+          # First few # are replaced by the base10 ID of the tag
+          i = -1
+          keyed_placeholder.gsub!('#') do
+            i += 1
+            if i > key.size - 1
+              '#'
+            else
+              key[i]
+            end
+          end
+
+          # Replace source by placeholder
+          parseable_source[m.begin(0)...m.end(0)] = keyed_placeholder
+        end
+
+        new(
+          Nokogiri::HTML5.fragment(parseable_source, max_tree_depth: 400, max_attributes: 400),
+          liquid_file,
+          placeholder_values,
+          parseable_source
+        )
+      end
+    end
+
+    def initialize(value, theme_file, placeholder_values, parseable_source, parent = nil)
       @value = value
       @theme_file = theme_file
       @placeholder_values = placeholder_values
+      @parseable_source = parseable_source
       @parent = parent
     end
 
@@ -27,11 +90,11 @@ module ThemeCheck
     def children
       @children ||= @value
         .children
-        .map { |child| HtmlNode.new(child, theme_file, @placeholder_values, self) }
+        .map { |child| HtmlNode.new(child, theme_file, @placeholder_values, @parseable_source, self) }
     end
 
     def markup
-      @markup ||= replace_placeholders(@value.to_html)
+      @markup ||= replace_placeholders(parseable_markup)
     end
 
     def line_number
@@ -39,11 +102,27 @@ module ThemeCheck
     end
 
     def start_index
-      raise NotImplementedError
+      position.start_index
     end
 
     def end_index
-      raise NotImplementedError
+      position.end_index
+    end
+
+    def start_row
+      position.start_row
+    end
+
+    def start_column
+      position.start_column
+    end
+
+    def end_row
+      position.end_row
+    end
+
+    def end_column
+      position.end_column
     end
 
     def literal?
@@ -60,6 +139,12 @@ module ThemeCheck
         .to_h
     end
 
+    def parseable_markup
+      start_index = from_row_column_to_index(@parseable_source, line_number - 1, 0)
+      @parseable_source
+        .match(/<\s*#{@value.name}[^>]*>/im, start_index)[0]
+    end
+
     def content
       @content ||= replace_placeholders(@value.content)
     end
@@ -74,10 +159,18 @@ module ThemeCheck
 
     private
 
+    def position
+      @position ||= Position.new(
+        markup,
+        theme_file.source,
+        line_number_1_indexed: line_number,
+      )
+    end
+
     def replace_placeholders(string)
       # Replace all ≬{i}####≬ with the actual content.
       string.gsub(HTML_LIQUID_PLACEHOLDER) do |match|
-        key = /[0-9a-z]+/.match(match)[0]
+        key = /[0-9a-z]+/.match(match.gsub("\n", ''))[0]
         @placeholder_values[key.to_i(36)]
       end
     end

data/lib/theme_check/html_visitor.rb

@@ -4,7 +4,6 @@ require "forwardable"
 
 module ThemeCheck
   class HtmlVisitor
-    include RegexHelpers
     attr_reader :checks
 
     def initialize(checks)
@@ -12,43 +11,13 @@ module ThemeCheck
     end
 
     def visit_liquid_file(liquid_file)
-      doc, placeholder_values = parse(liquid_file)
-      visit(HtmlNode.new(doc, liquid_file, placeholder_values))
+      visit(HtmlNode.parse(liquid_file))
     rescue ArgumentError => e
       call_checks(:on_parse_error, e, liquid_file)
     end
 
     private
 
-    def parse(liquid_file)
-      placeholder_values = []
-      parseable_source = +liquid_file.source.clone
-
-      # Replace all non-empty liquid tags with ≬{i}######≬ to prevent the HTML
-      # parser from freaking out. We transparently replace those placeholders in
-      # HtmlNode.
-      #
-      # We're using base36 to prevent index bleeding on 36^3 tags.
-      # `{{x}}` -> `≬#{i}≬` would properly be transformed for 46656 tags in a single file.
-      # Should be enough.
-      #
-      # The base10 alternative would have overflowed at 1000 (`{{x}}` -> `≬1000≬`) which seemed more likely.
-      #
-      # Didn't go with base64 because of the `=` character that would have messed with HTML parsing.
-      matches(parseable_source, LIQUID_TAG_OR_VARIABLE).each do |m|
-        value = m[0]
-        next unless value.size > 4 # skip empty tags/variables {%%} and {{}}
-        placeholder_values.push(value)
-        key = (placeholder_values.size - 1).to_s(36)
-        parseable_source[m.begin(0)...m.end(0)] = "≬#{key.ljust(m.end(0) - m.begin(0) - 2, '#')}≬"
-      end
-
-      [
-        Nokogiri::HTML5.fragment(parseable_source, max_tree_depth: 400, max_attributes: 400),
-        placeholder_values,
-      ]
-    end
-
     def visit(node)
       call_checks(:on_element, node) if node.element?
       call_checks(:"on_#{node.name}", node)

data/lib/theme_check/in_memory_storage.rb

@@ -6,6 +6,8 @@
 # as a big hash already, leave it like that and save yourself some IO.
 module ThemeCheck
   class InMemoryStorage < Storage
+    attr_reader :root
+
     def initialize(files = {}, root = "/dev/null")
       @files = files
       @root = Pathname.new(root)
@@ -29,6 +31,7 @@ module ThemeCheck
 
     def mkdir(relative_path)
       @files[relative_path] = nil
+      reset_memoizers
     end
 
     def files
@@ -46,5 +49,11 @@ module ThemeCheck
     def relative_path(absolute_path)
       Pathname.new(absolute_path).relative_path_from(@root).to_s
     end
+
+    private
+
+    def reset_memoizers
+      @directories = nil
+    end
   end
 end

data/lib/theme_check/json_helpers.rb

@@ -5,5 +5,19 @@ module ThemeCheck
       message = error.message[/\d+: (.+)$/, 1] || 'Invalid syntax'
       "#{message} in JSON"
     end
+
+    def pretty_json(hash, start_level: 1, indent: "  ")
+      start_indent = indent * start_level
+
+      <<~JSON
+
+        #{start_indent}#{JSON.pretty_generate(
+          hash,
+          indent: indent,
+          array_nl: "\n#{start_indent}",
+          object_nl: "\n#{start_indent}",
+        )}
+      JSON
+    end
   end
 end

data/lib/theme_check/language_server/bridge.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# This class exists as a bridge (or boundary) between our handlers and the outside world.
+#
+# It is concerned with all the Language Server Protocol constructs. i.e.
+#
+#   - sending Hash messages as JSON
+#   - reading JSON messages as Hashes
+#   - preparing, sending and resolving requests
+#   - preparing and sending responses
+#   - preparing and sending notifications
+#   - preparing and sending progress notifications
+#
+# But it _not_ concerned by _how_ those messages are sent to the
+# outside world. That's the job of the messenger.
+#
+# This enables us to have all the language server protocol logic
+# in here living independently of how we communicate with the
+# client (STDIO or websocket)
+module ThemeCheck
+  module LanguageServer
+    class Bridge
+      attr_writer :supports_work_done_progress
+
+      def initialize(messenger)
+        # The messenger is responsible for IO.
+        # Could be STDIO or WebSockets or Mock.
+        @messenger = messenger
+
+        # Whether the client supports work done progress notifications
+        @supports_work_done_progress = false
+      end
+
+      def log(message)
+        @messenger.log(message)
+      end
+
+      def read_message
+        message_body = @messenger.read_message
+        message_json = JSON.parse(message_body, symbolize_names: true)
+        @messenger.log(JSON.pretty_generate(message_json)) if ThemeCheck.debug?
+        message_json
+      end
+
+      def send_message(message_hash)
+        message_hash[:jsonrpc] = '2.0'
+        message_body = JSON.dump(message_hash)
+        @messenger.log(JSON.pretty_generate(message_hash)) if ThemeCheck.debug?
+        @messenger.send_message(message_body)
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#requestMessage
+      def send_request(method, params = nil)
+        channel = Channel.create
+        message = { id: channel.id }
+        message[:method] = method
+        message[:params] = params if params
+        send_message(message)
+        channel.pop
+      ensure
+        channel.close
+      end
+
+      def receive_response(id, result)
+        Channel.by_id(id) << result
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
+      def send_response(id, result = nil, error = nil)
+        message = { id: id }
+        if error
+          message[:error] = error
+        else
+          message[:result] = result
+        end
+        send_message(message)
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#responseError
+      def send_internal_error(id, e)
+        send_response(id, nil, {
+          code: ErrorCodes::INTERNAL_ERROR,
+          message: <<~EOS,
+            #{e.class}: #{e.message}
+              #{e.backtrace.join("\n  ")}
+          EOS
+        })
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
+      def send_notification(method, params)
+        message = { method: method }
+        message[:params] = params
+        send_message(message)
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#progress
+      def send_progress(token, value)
+        send_notification("$/progress", token: token, value: value)
+      end
+
+      def supports_work_done_progress?
+        @supports_work_done_progress
+      end
+
+      def send_create_work_done_progress_request(token)
+        return unless supports_work_done_progress?
+        send_request("window/workDoneProgress/create", {
+          token: token,
+        })
+      end
+
+      def send_work_done_progress_begin(token, title)
+        return unless supports_work_done_progress?
+        send_progress(token, {
+          kind: 'begin',
+          title: title,
+          cancellable: false,
+          percentage: 0,
+        })
+      end
+
+      def send_work_done_progress_report(token, message, percentage)
+        return unless supports_work_done_progress?
+        send_progress(token, {
+          kind: 'report',
+          message: message,
+          cancellable: false,
+          percentage: percentage,
+        })
+      end
+
+      def send_work_done_progress_end(token, message)
+        return unless supports_work_done_progress?
+        send_progress(token, {
+          kind: 'end',
+          message: message,
+        })
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/channel.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    # How you'd use this class:
+    #
+    # In thread #1:
+    #   def foo
+    #     chan = Channel.create
+    #     send_request(chan.id, ...)
+    #     result = chan.pop
+    #     do_stuff_with_result(result)
+    #   ensure
+    #     chan.close
+    #   end
+    #
+    # In thread #2:
+    #   Channel.by_id(id) << result
+    class Channel
+      MUTEX = Mutex.new
+      CHANNELS = {}
+
+      class << self
+        def create
+          id = new_id
+          CHANNELS[id] = new(id)
+          CHANNELS[id]
+        end
+
+        def by_id(id)
+          CHANNELS[id]
+        end
+
+        def close(id)
+          CHANNELS.delete(id)
+        end
+
+        private
+
+        def new_id
+          MUTEX.synchronize do
+            @id ||= 0
+            @id += 1
+          end
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+        @response = SizedQueue.new(1)
+      end
+
+      def pop
+        @response.pop
+      end
+
+      def <<(value)
+        @response << value
+      end
+
+      def close
+        @response.close
+        Channel.close(id)
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/client_capabilities.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class ClientCapabilities
+      def initialize(capabilities)
+        @capabilities = capabilities
+      end
+
+      def supports_work_done_progress?
+        @capabilities.dig(:window, :workDoneProgress) || false
+      end
+
+      def supports_workspace_configuration?
+        @capabilities.dig(:workspace, :configuration) || false
+      end
+
+      def supports_workspace_did_change_configuration_dynamic_registration?
+        @capabilities.dig(:workspace, :didChangeConfiguration, :dynamicRegistration) || false
+      end
+
+      def initialization_option(key)
+        @capabilities.dig(:initializationOptions, key)
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/code_action_engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CodeActionEngine
+      include PositionHelper
+
+      def initialize(storage, diagnostics_manager)
+        @storage = storage
+        @providers = CodeActionProvider.all.map { |c| c.new(storage, diagnostics_manager) }
+      end
+
+      def code_actions(absolute_path, start_position, end_position, only_kinds = [])
+        relative_path = @storage.relative_path(absolute_path)
+        buffer = @storage.read(relative_path)
+        start_index = from_row_column_to_index(buffer, start_position[0], start_position[1])
+        end_index = from_row_column_to_index(buffer, end_position[0], end_position[1])
+        range = (start_index...end_index)
+
+        @providers
+          .filter do |provider|
+            only_kinds.empty? ||
+            only_kinds.include?(provider.kind) ||
+            only_kinds.include?(provider.base_kind)
+          end
+          .flat_map do |provider|
+            provider.code_actions(relative_path, range)
+          end
+      end
+    end
+  end
+end