theme-check 0.3.1 → 0.6.0

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,47 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class DocumentLinkEngine
+      include PositionHelper
+      include RegexHelpers
+
+      def initialize(storage)
+        @storage = storage
+      end
+
+      def document_links(uri)
+        buffer = @storage.read(uri)
+        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,14 +39,77 @@ 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_document_link(id, params)
+        uri = text_document_uri(params)
+        send_response(
+          id: id,
+          result: document_links(uri)
+        )
+      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 in_memory_storage(root)
+        config = ThemeCheck::Config.from_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, root)
+      end
+
+      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 +131,14 @@ module ThemeCheck
         analyzer.offenses
       end
 
+      def completions(uri, line, col)
+        @completion_engine.completions(uri, line, col)
+      end
+
+      def document_links(uri)
+        @document_link_engine.document_links(uri)
+      end
+
       def send_diagnostics(offenses)
         reported_files = Set.new
 
@@ -90,12 +169,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

@@ -6,15 +6,18 @@ require 'active_support/core_ext/string/inflections'
 module ThemeCheck
   module LanguageServer
     class DoneStreaming < StandardError; end
+
     class IncompatibleStream < StandardError; end
 
     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: STDERR,
+        should_raise_errors: false
       )
         validate!([in_stream, out_stream, err_stream])
 
@@ -25,6 +28,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 +42,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
@@ -45,7 +51,7 @@ module ThemeCheck
 
       def send_response(response)
         response_body = JSON.dump(response)
-        log(response_body) if $DEBUG
+        log(JSON.pretty_generate(response)) if $DEBUG
 
         @out.write("Content-Length: #{response_body.size}\r\n")
         @out.write("\r\n")

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

data/lib/theme_check/liquid_check.rb

@@ -6,6 +6,17 @@ module ThemeCheck
     extend ChecksTracking
     include ParsingHelpers
 
+    TAG = /#{Liquid::TagStart}.*?#{Liquid::TagEnd}/om
+    VARIABLE = /#{Liquid::VariableStart}.*?#{Liquid::VariableEnd}/om
+    START_OR_END_QUOTE = /(^['"])|(['"]$)/
+    QUOTED_LIQUID_ATTRIBUTE = %r{
+      '(?:#{TAG}|#{VARIABLE}|[^'])*'| # any combination of tag/variable or non straight quote inside straight quotes
+      "(?:#{TAG}|#{VARIABLE}|[^"])*"  # any combination of tag/variable or non double quotes inside double quotes
+    }omix
+    ATTR = /[a-z0-9-]+/i
+    HTML_ATTRIBUTE = /#{ATTR}(?:=#{QUOTED_LIQUID_ATTRIBUTE})?/omix
+    HTML_ATTRIBUTES = /(?:#{HTML_ATTRIBUTE}|\s)*/omix
+
     def add_offense(message, node: nil, template: node&.template, markup: nil, line_number: nil, &block)
       offenses << Offense.new(check: self, message: message, template: template, node: node, markup: markup, line_number: line_number, correction: block)
     end

data/lib/theme_check/offense.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 module ThemeCheck
+  Position = Struct.new(:line, :column)
+
   class Offense
     MAX_SOURCE_EXCERPT_SIZE = 120
 
@@ -35,6 +37,9 @@ module ThemeCheck
       elsif @node
         @node.line_number
       end
+
+      @start_position = nil
+      @end_position = nil
     end
 
     def source_excerpt
@@ -50,27 +55,19 @@ module ThemeCheck
     end
 
     def start_line
-      return 0 unless line_number
-      line_number - 1
+      start_position.line
     end
 
-    def end_line
-      if markup
-        start_line + markup.count("\n")
-      else
-        start_line
-      end
+    def start_column
+      start_position.column
     end
 
-    def start_column
-      return 0 unless line_number && markup
-      template.full_line(start_line + 1).index(markup.split("\n", 2).first)
+    def end_line
+      end_position.line
     end
 
     def end_column
-      return 0 unless line_number && markup
-      markup_end = markup.split("\n").last
-      template.full_line(end_line + 1).index(markup_end) + markup_end.size
+      end_position.column
     end
 
     def code_name
@@ -116,5 +113,45 @@ module ThemeCheck
         message
       end
     end
+
+    private
+
+    def full_line(line)
+      # Liquid::Template is 1-indexed.
+      template.full_line(line + 1)
+    end
+
+    def lines_of_content
+      @lines ||= markup.lines.map { |x| x.sub(/\n$/, '') }
+    end
+
+    # 0-indexed, inclusive
+    def start_position
+      return @start_position if @start_position
+      return @start_position = Position.new(0, 0) unless line_number && markup
+
+      position = Position.new
+      position.line = line_number - 1
+      position.column = full_line(position.line).index(lines_of_content.first) || 0
+
+      @start_position = position
+    end
+
+    # 0-indexed, exclusive. It's the line + col that are exclusive.
+    # This is why it doesn't make sense to calculate them separately.
+    def end_position
+      return @end_position if @end_position
+      return @end_position = Position.new(0, 0) unless line_number && markup
+
+      position = Position.new
+      position.line = start_line + lines_of_content.size - 1
+      position.column = if start_line == position.line
+        start_column + markup.size
+      else
+        lines_of_content.last.size
+      end
+
+      @end_position = position
+    end
   end
 end