theme-check 0.2.2 → 0.4.0

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,
         },
@@ -14,6 +18,9 @@ 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)
@@ -30,39 +37,93 @@ 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)
-        theme = ThemeCheck::Theme.new(config.root)
-        analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
+        storage = ThemeCheck::FileSystemStorage.new(
+          config.root,
+          ignored_patterns: config.ignored_patterns
+        )
+        theme = ThemeCheck::Theme.new(storage)
 
+        offenses = analyze(theme, config)
+        log("Found #{theme.all.size} templates, and #{offenses.size} offenses")
+        send_diagnostics(offenses)
+      end
+
+      def analyze(theme, config)
+        analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
         log("Checking #{config.root}")
         analyzer.analyze_theme
-        log("Found #{theme.all.size} templates, and #{analyzer.offenses.size} offenses")
-        send_diagnostics(analyzer.offenses, theme.all)
+        analyzer.offenses
       end
 
-      def send_diagnostics(offenses, templates)
-        contains_offenses = []
+      def completions(uri, line, col)
+        @completion_engine.completions(uri, line, col)
+      end
+
+      def send_diagnostics(offenses)
+        reported_files = Set.new
 
         offenses.group_by(&:template).each do |template, template_offenses|
           next unless template
           send_diagnostic(template.path, template_offenses)
-          contains_offenses.push(template.path)
+          reported_files << template.path
         end
 
-        # Publish diagnostics with empty array if template does not contain error
-        templates.select { |t| !contains_offenses.include?(t.path) }.each do |template|
-          send_diagnostic(template.path, [])
+        # Publish diagnostics with empty array if all issues on a previously reported template
+        # have been solved.
+        (@previously_reported_files - reported_files).each do |path|
+          send_diagnostic(path, [])
         end
+
+        @previously_reported_files = reported_files
       end
 
       def send_diagnostic(path, offenses)

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

@@ -9,6 +9,8 @@ module ThemeCheck
     class IncompatibleStream < StandardError; end
 
     class Server
+      attr_reader :handler
+
       def initialize(
         in_stream: STDIN,
         out_stream: STDOUT,
@@ -87,8 +89,6 @@ module ThemeCheck
 
         if @handler.respond_to?(method_name)
           @handler.send(method_name, id, params)
-        else
-          log("Handler does not respond to #{method_name}")
         end
       end
 

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

data/lib/theme_check/shopify_liquid.rb

@@ -2,3 +2,4 @@
 require_relative 'shopify_liquid/deprecated_filter'
 require_relative 'shopify_liquid/filter'
 require_relative 'shopify_liquid/object'
+require_relative 'shopify_liquid/tag'

data/lib/theme_check/shopify_liquid/object.rb

@@ -11,6 +11,12 @@ module ThemeCheck
           YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/objects.yml"))
         end
       end
+
+      def plus_labels
+        @plus_labels ||= begin
+          YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/plus_objects.yml"))
+        end
+      end
     end
   end
 end

data/lib/theme_check/shopify_liquid/tag.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require 'yaml'
+
+module ThemeCheck
+  module ShopifyLiquid
+    module Tag
+      extend self
+
+      def labels
+        @tags ||= begin
+          YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/tags.yml"))
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/storage.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class Storage
+    def read(relative_path)
+      raise NotImplementedError
+    end
+
+    def write(relative_path, content)
+      raise NotImplementedError
+    end
+
+    def path(relative_path)
+      raise NotImplementedError
+    end
+
+    def files
+      raise NotImplementedError
+    end
+
+    def directories
+      raise NotImplementedError
+    end
+  end
+end