theme-check 0.3.0 → 0.5.0

data/lib/theme_check/language_server/completion_engine.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CompletionEngine
+      include PositionHelper
+
+      def initialize(storage)
+        @storage = storage
+        @providers = CompletionProvider.all.map(&:new)
+      end
+
+      def completions(name, line, col)
+        buffer = @storage.read(name)
+        cursor = from_line_column_to_index(buffer, line, col)
+        token = find_token(buffer, cursor)
+        return [] if token.nil?
+
+        @providers.flat_map do |p|
+          p.completions(
+            token.content,
+            cursor - token.start
+          )
+        end
+      end
+
+      def find_token(buffer, cursor)
+        Tokens.new(buffer).find do |token|
+          # Here we include the next character and exclude the first
+          # one becase when we want to autocomplete inside a token
+          # and at most 1 outside it since the cursor could be placed
+          # at the end of the token.
+          token.start < cursor && cursor <= token.end
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module CompletionHelper
+      WORD = /\w+/
+
+      def cursor_on_start_content?(content, cursor, regex)
+        content.slice(0, cursor).match?(/#{regex}(?:\s|\n)*$/m)
+      end
+
+      def cursor_on_first_word?(content, cursor)
+        word = content.match(WORD)
+        return false if word.nil?
+        word_start = word.begin(0)
+        word_end = word.end(0)
+        word_start <= cursor && cursor <= word_end
+      end
+
+      def first_word(content)
+        return content.match(WORD)[0] if content.match?(WORD)
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_provider.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CompletionProvider
+      include CompletionHelper
+      include RegexHelpers
+
+      class << self
+        def all
+          @all ||= []
+        end
+
+        def inherited(subclass)
+          all << subclass
+        end
+      end
+
+      def completions(content, cursor)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_providers/filter_completion_provider.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class FilterCompletionProvider < CompletionProvider
+      NAMED_FILTER = /#{Liquid::FilterSeparator}\s*(\w+)/o
+
+      def completions(content, cursor)
+        return [] unless can_complete?(content, cursor)
+        ShopifyLiquid::Filter.labels
+          .select { |w| w.starts_with?(partial(content, cursor)) }
+          .map { |filter| filter_to_completion(filter) }
+      end
+
+      def can_complete?(content, cursor)
+        content.match?(Liquid::FilterSeparator) && (
+          cursor_on_start_content?(content, cursor, Liquid::FilterSeparator) ||
+          cursor_on_filter?(content, cursor)
+        )
+      end
+
+      private
+
+      def cursor_on_filter?(content, cursor)
+        return false unless content.match?(NAMED_FILTER)
+        matches(content, NAMED_FILTER).any? do |match|
+          match.begin(1) <= cursor && cursor < match.end(1) + 1 # including next character
+        end
+      end
+
+      def partial(content, cursor)
+        return '' unless content.match?(NAMED_FILTER)
+        partial_match = matches(content, NAMED_FILTER).find do |match|
+          match.begin(1) <= cursor && cursor < match.end(1) + 1 # including next character
+        end
+        partial_match[1]
+      end
+
+      def filter_to_completion(filter)
+        {
+          label: filter,
+          kind: CompletionItemKinds::FUNCTION,
+        }
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_providers/object_completion_provider.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class ObjectCompletionProvider < CompletionProvider
+      def completions(content, cursor)
+        return [] unless can_complete?(content, cursor)
+        partial = first_word(content) || ''
+        ShopifyLiquid::Object.labels
+          .select { |w| w.starts_with?(partial) }
+          .map { |object| object_to_completion(object) }
+      end
+
+      def can_complete?(content, cursor)
+        content.match?(Liquid::VariableStart) && (
+          cursor_on_first_word?(content, cursor) ||
+          cursor_on_start_content?(content, cursor, Liquid::VariableStart)
+        )
+      end
+
+      private
+
+      def object_to_completion(object)
+        {
+          label: object,
+          kind: CompletionItemKinds::VARIABLE,
+        }
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_providers/tag_completion_provider.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class TagCompletionProvider < CompletionProvider
+      def completions(content, cursor)
+        return [] unless can_complete?(content, cursor)
+        partial = first_word(content) || ''
+        ShopifyLiquid::Tag.labels
+          .select { |w| w.starts_with?(partial) }
+          .map { |tag| tag_to_completion(tag) }
+      end
+
+      def can_complete?(content, cursor)
+        content.starts_with?(Liquid::TagStart) && (
+          cursor_on_first_word?(content, cursor) ||
+          cursor_on_start_content?(content, cursor, Liquid::TagStart)
+        )
+      end
+
+      private
+
+      def tag_to_completion(tag)
+        {
+          label: tag,
+          kind: CompletionItemKinds::KEYWORD,
+        }
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/handler.rb

@@ -4,9 +4,13 @@ module ThemeCheck
   module LanguageServer
     class Handler
       CAPABILITIES = {
+        completionProvider: {
+          triggerCharacters: ['.', '{{ ', '{% '],
+          context: true,
+        },
         textDocumentSync: {
           openClose: true,
-          change: false,
+          change: TextDocumentSyncKind::FULL,
           willSave: false,
           save: true,
         },
@@ -15,6 +19,8 @@ module ThemeCheck
       def initialize(server)
         @server = server
         @previously_reported_files = Set.new
+        @storage = InMemoryStorage.new
+        @completion_engine = CompletionEngine.new(@storage)
       end
 
       def on_initialize(id, params)
@@ -31,14 +37,52 @@ module ThemeCheck
       def on_exit(_id, _params)
         close!
       end
+      alias_method :on_shutdown, :on_exit
+
+      def on_text_document_did_change(_id, params)
+        uri = text_document_uri(params)
+        @storage.write(uri, content_changes_text(params))
+      end
+
+      def on_text_document_did_close(_id, params)
+        uri = text_document_uri(params)
+        @storage.write(uri, nil)
+      end
 
       def on_text_document_did_open(_id, params)
-        analyze_and_send_offenses(params.dig('textDocument', 'uri').sub('file://', ''))
+        uri = text_document_uri(params)
+        @storage.write(uri, text_document_text(params))
+        analyze_and_send_offenses(uri)
+      end
+
+      def on_text_document_did_save(_id, params)
+        analyze_and_send_offenses(text_document_uri(params))
+      end
+
+      def on_text_document_completion(id, params)
+        uri = text_document_uri(params)
+        line = params.dig('position', 'line')
+        col = params.dig('position', 'character')
+        send_response(
+          id: id,
+          result: completions(uri, line, col)
+        )
       end
-      alias_method :on_text_document_did_save, :on_text_document_did_open
 
       private
 
+      def text_document_uri(params)
+        params.dig('textDocument', 'uri').sub('file://', '')
+      end
+
+      def text_document_text(params)
+        params.dig('textDocument', 'text')
+      end
+
+      def content_changes_text(params)
+        params.dig('contentChanges', 0, 'text')
+      end
+
       def analyze_and_send_offenses(file_path)
         root = ThemeCheck::Config.find(file_path) || @root_path
         config = ThemeCheck::Config.from_path(root)
@@ -60,6 +104,10 @@ module ThemeCheck
         analyzer.offenses
       end
 
+      def completions(uri, line, col)
+        @completion_engine.completions(uri, line, col)
+      end
+
       def send_diagnostics(offenses)
         reported_files = Set.new
 
@@ -90,12 +138,20 @@ module ThemeCheck
       end
 
       def offense_to_diagnostic(offense)
-        {
+        diagnostic = {
+          code: offense.code_name,
+          message: offense.message,
           range: range(offense),
           severity: severity(offense),
-          code: offense.code_name,
           source: "theme-check",
-          message: offense.message,
+        }
+        diagnostic["codeDescription"] = code_description(offense) unless offense.doc.nil?
+        diagnostic
+      end
+
+      def code_description(offense)
+        {
+          href: offense.doc,
         }
       end
 

data/lib/theme_check/language_server/position_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# Note: Everything is 0-indexed here.
+
+module ThemeCheck
+  module LanguageServer
+    module PositionHelper
+      def from_line_column_to_index(content, row, col)
+        i = 0
+        result = 0
+        lines = content.lines
+        while i < row
+          result += lines[i].size
+          i += 1
+        end
+        result += col
+        result
+      end
+
+      def from_index_to_line_column(content, index)
+        lines = content[0..index].lines
+        row = lines.size - 1
+        col = lines.last.size - 1
+        [row, col]
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/protocol.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+# Here we define the Language Server Protocol Constants we're using.
+# For complete docs, see the following:
+# https://microsoft.github.io/language-server-protocol/specifications/specification-current
+module ThemeCheck
+  module LanguageServer
+    module CompletionItemKinds
+      TEXT = 1
+      METHOD = 2
+      FUNCTION = 3
+      CONSTRUCTOR = 4
+      FIELD = 5
+      VARIABLE = 6
+      CLASS = 7
+      INTERFACE = 8
+      MODULE = 9
+      PROPERTY = 10
+      UNIT = 11
+      VALUE = 12
+      ENUM = 13
+      KEYWORD = 14
+      SNIPPET = 15
+      COLOR = 16
+      FILE = 17
+      REFERENCE = 18
+      FOLDER = 19
+      ENUM_MEMBER = 20
+      CONSTANT = 21
+      STRUCT = 22
+      EVENT = 23
+      OPERATOR = 24
+      TYPE_PARAMETER = 25
+    end
+
+    module TextDocumentSyncKind
+      NONE = 0
+      FULL = 1
+      INCREMENTAL = 2
+    end
+  end
+end

data/lib/theme_check/language_server/server.rb

@@ -10,11 +10,13 @@ module ThemeCheck
 
     class Server
       attr_reader :handler
+      attr_reader :should_raise_errors
 
       def initialize(
         in_stream: STDIN,
         out_stream: STDOUT,
-        err_stream: $DEBUG ? File.open('/tmp/lsp.log', 'a') : STDERR
+        err_stream: $DEBUG ? File.open('/tmp/lsp.log', 'a') : STDERR,
+        should_raise_errors: false
       )
         validate!([in_stream, out_stream, err_stream])
 
@@ -25,6 +27,8 @@ module ThemeCheck
 
         @out.sync = true # do not buffer
         @err.sync = true # do not buffer
+
+        @should_raise_errors = should_raise_errors
       end
 
       def listen
@@ -37,6 +41,7 @@ module ThemeCheck
           return 0
 
         rescue Exception => e # rubocop:disable Lint/RescueException
+          raise e if should_raise_errors
           log(e)
           log(e.backtrace)
           return 1

data/lib/theme_check/language_server/tokens.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  Token = Struct.new(
+    :content,
+    :start, # inclusive
+    :end, # exclusive
+  )
+
+  TAG_START = Liquid::TagStart
+  TAG_END = Liquid::TagEnd
+  VARIABLE_START = Liquid::VariableStart
+  VARIABLE_END = Liquid::VariableEnd
+  SPLITTER = %r{
+    (?=(?:#{TAG_START}|#{VARIABLE_START}))| # positive lookahead on tag/variable start
+    (?<=(?:#{TAG_END}|#{VARIABLE_END}))     # positive lookbehind on tag/variable end
+  }xom
+
+  # Implemented as an Enumerable so we stop iterating on the find once
+  # we have what we want. Kind of a perf thing.
+  class Tokens
+    include Enumerable
+
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block_given?
+
+      chunks = @buffer.split(SPLITTER)
+      chunks.shift if chunks[0]&.empty?
+
+      prev = Token.new('', 0, 0)
+      curr = Token.new('', 0, 0)
+
+      while (content = chunks.shift)
+
+        curr.start = prev.end
+        curr.end = curr.start + content.size
+
+        block.call(Token.new(
+          content,
+          curr.start,
+          curr.end,
+        ))
+
+        # recycling structs
+        tmp = prev
+        prev = curr
+        curr = tmp
+      end
+    end
+  end
+end