theme-check 0.3.2 → 0.7.0

data/lib/theme_check/language_server/completion_provider.rb

@@ -0,0 +1,28 @@
+# 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 initialize(storage = InMemoryStorage.new)
+        @storage = storage
+      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,51 @@
+# 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)
+        available_labels
+          .select { |w| w.start_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 available_labels
+        @labels ||= ShopifyLiquid::Filter.labels - ShopifyLiquid::DeprecatedFilter.labels
+      end
+
+      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.start_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/render_snippet_completion_provider.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class RenderSnippetCompletionProvider < CompletionProvider
+      def completions(content, cursor)
+        return [] unless cursor_on_quoted_argument?(content, cursor)
+        partial = snippet(content) || ''
+        snippets
+          .select { |x| x.start_with?(partial) }
+          .map { |x| snippet_to_completion(x) }
+      end
+
+      private
+
+      def cursor_on_quoted_argument?(content, cursor)
+        match = content.match(PARTIAL_RENDER)
+        return false if match.nil?
+        match.begin(:partial) <= cursor && cursor <= match.end(:partial)
+      end
+
+      def snippet(content)
+        match = content.match(PARTIAL_RENDER)
+        return if match.nil?
+        match[:partial]
+      end
+
+      def snippets
+        @storage
+          .files
+          .select { |x| x.include?('snippets/') }
+      end
+
+      def snippet_to_completion(file)
+        {
+          label: File.basename(file, '.liquid'),
+          kind: CompletionItemKinds::SNIPPET,
+          detail: file,
+        }
+      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.start_with?(partial) }
+          .map { |tag| tag_to_completion(tag) }
+      end
+
+      def can_complete?(content, cursor)
+        content.start_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/constants.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    PARTIAL_RENDER = %r{
+      \{\%\s*render\s+'(?<partial>[^']*)'|
+      \{\%\s*render\s+"(?<partial>[^"]*)"
+    }mix
+  end
+end

data/lib/theme_check/language_server/document_link_engine.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class DocumentLinkEngine
+      include PositionHelper
+      include RegexHelpers
+
+      def initialize(storage)
+        @storage = storage
+      end
+
+      def document_links(relative_path)
+        buffer = @storage.read(relative_path)
+        return [] unless buffer
+        matches(buffer, PARTIAL_RENDER).map do |match|
+          start_line, start_character = from_index_to_line_column(
+            buffer,
+            match.begin(:partial),
+          )
+
+          end_line, end_character = from_index_to_line_column(
+            buffer,
+            match.end(:partial)
+          )
+
+          {
+            target: link(match[:partial]),
+            range: {
+              start: {
+                line: start_line,
+                character: start_character,
+              },
+              end: {
+                line: end_line,
+                character: end_character,
+              },
+            },
+          }
+        end
+      end
+
+      def link(partial)
+        "file://#{@storage.path('snippets/' + partial + '.liquid')}"
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/handler.rb

@@ -4,9 +4,14 @@ module ThemeCheck
   module LanguageServer
     class Handler
       CAPABILITIES = {
+        completionProvider: {
+          triggerCharacters: ['.', '{{ ', '{% '],
+          context: true,
+        },
+        documentLinkProvider: true,
         textDocumentSync: {
           openClose: true,
-          change: false,
+          change: TextDocumentSyncKind::FULL,
           willSave: false,
           save: true,
         },
@@ -19,6 +24,9 @@ module ThemeCheck
 
       def on_initialize(id, params)
         @root_path = params["rootPath"]
+        @storage = in_memory_storage(@root_path)
+        @completion_engine = CompletionEngine.new(@storage)
+        @document_link_engine = DocumentLinkEngine.new(@storage)
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
         send_response(
           id: id,
@@ -31,17 +39,88 @@ module ThemeCheck
       def on_exit(_id, _params)
         close!
       end
+      alias_method :on_shutdown, :on_exit
+
+      def on_text_document_did_change(_id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        @storage.write(relative_path, content_changes_text(params))
+      end
+
+      def on_text_document_did_close(_id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        @storage.write(relative_path, "")
+      end
 
       def on_text_document_did_open(_id, params)
-        analyze_and_send_offenses(params.dig('textDocument', 'uri').sub('file://', ''))
+        relative_path = relative_path_from_text_document_uri(params)
+        @storage.write(relative_path, text_document_text(params))
+        analyze_and_send_offenses(text_document_uri(params))
+      end
+
+      def on_text_document_did_save(_id, params)
+        analyze_and_send_offenses(text_document_uri(params))
+      end
+
+      def on_text_document_document_link(id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        send_response(
+          id: id,
+          result: document_links(relative_path)
+        )
+      end
+
+      def on_text_document_completion(id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        line = params.dig('position', 'line')
+        col = params.dig('position', 'character')
+        send_response(
+          id: id,
+          result: completions(relative_path, line, col)
+        )
       end
-      alias_method :on_text_document_did_save, :on_text_document_did_open
 
       private
 
-      def analyze_and_send_offenses(file_path)
-        root = ThemeCheck::Config.find(file_path) || @root_path
-        config = ThemeCheck::Config.from_path(root)
+      def in_memory_storage(root)
+        config = config_for_path(root)
+
+        # Make a real FS to get the files from the snippets folder
+        fs = ThemeCheck::FileSystemStorage.new(
+          config.root,
+          ignored_patterns: config.ignored_patterns
+        )
+
+        # Turn that into a hash of empty buffers
+        files = fs.files
+          .map { |fn| [fn, ""] }
+          .to_h
+
+        InMemoryStorage.new(files, config.root)
+      end
+
+      def text_document_uri(params)
+        params.dig('textDocument', 'uri').sub('file://', '')
+      end
+
+      def relative_path_from_text_document_uri(params)
+        @storage.relative_path(text_document_uri(params))
+      end
+
+      def text_document_text(params)
+        params.dig('textDocument', 'text')
+      end
+
+      def content_changes_text(params)
+        params.dig('contentChanges', 0, 'text')
+      end
+
+      def config_for_path(path)
+        root = ThemeCheck::Config.find(path) || @root_path
+        ThemeCheck::Config.from_path(root)
+      end
+
+      def analyze_and_send_offenses(absolute_path)
+        config = config_for_path(absolute_path)
         storage = ThemeCheck::FileSystemStorage.new(
           config.root,
           ignored_patterns: config.ignored_patterns
@@ -60,6 +139,14 @@ module ThemeCheck
         analyzer.offenses
       end
 
+      def completions(relative_path, line, col)
+        @completion_engine.completions(relative_path, line, col)
+      end
+
+      def document_links(relative_path)
+        @document_link_engine.document_links(relative_path)
+      end
+
       def send_diagnostics(offenses)
         reported_files = Set.new
 
@@ -83,19 +170,27 @@ module ThemeCheck
         send_response(
           method: 'textDocument/publishDiagnostics',
           params: {
-            uri: "file:#{path}",
+            uri: "file://#{path}",
             diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
           },
         )
       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