theme-check 0.2.2 → 0.4.0

data/lib/theme_check/corrector.rb

@@ -9,27 +9,23 @@ module ThemeCheck
     def insert_after(node, content)
       line = @template.full_line(node.line_number)
       line.insert(node.range[1] + 1, content)
-      @template.update!
     end
 
     def insert_before(node, content)
       line = @template.full_line(node.line_number)
       line.insert(node.range[0], content)
-      @template.update!
     end
 
     def replace(node, content)
       line = @template.full_line(node.line_number)
       line[node.range[0]..node.range[1]] = content
       node.markup = content
-      @template.update!
     end
 
     def wrap(node, insert_before, insert_after)
       line = @template.full_line(node.line_number)
       line.insert(node.range[0], insert_before)
       line.insert(node.range[1] + 1 + insert_before.length, insert_after)
-      @template.update!
     end
   end
 end

data/lib/theme_check/disabled_checks.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class DisabledChecks
+    DISABLE_START = 'theme-check-disable'
+    DISABLE_END = 'theme-check-enable'
+    DISABLE_PREFIX_PATTERN = /#{DISABLE_START}|#{DISABLE_END}/
+
+    ACTION_DISABLE_CHECKS = :disable
+    ACTION_ENABLE_CHECKS = :enable
+    ACTION_UNRELATED_COMMENT = :unrelated
+
+    def initialize
+      @disabled = []
+      @all_disabled = false
+      @full_document_disabled = false
+    end
+
+    def update(node)
+      text = comment_text(node)
+
+      if start_disabling?(text)
+        @disabled = checks_from_text(text)
+        @all_disabled = @disabled.empty?
+
+        if node&.line_number == 1
+          @full_document_disabled = true
+        end
+      elsif stop_disabling?(text)
+        checks = checks_from_text(text)
+        @disabled = checks.empty? ? [] : @disabled - checks
+
+        @all_disabled = false
+      end
+    end
+
+    # Whether any checks are currently disabled
+    def any?
+      !@disabled.empty? || @all_disabled
+    end
+
+    # Whether all checks should be disabled
+    def all_disabled?
+      @all_disabled
+    end
+
+    # Get a list of all the individual disabled checks
+    def all
+      @disabled
+    end
+
+    # If the first line of the document is a theme-check-disable comment
+    def full_document_disabled?
+      @full_document_disabled
+    end
+
+    private
+
+    def comment_text(node)
+      node.value.nodelist.join
+    end
+
+    def start_disabling?(text)
+      text.strip.starts_with?(DISABLE_START)
+    end
+
+    def stop_disabling?(text)
+      text.strip.starts_with?(DISABLE_END)
+    end
+
+    # Return a list of checks from a theme-check-disable comment
+    # Returns [] if all checks are meant to be disabled
+    def checks_from_text(text)
+      text.gsub(DISABLE_PREFIX_PATTERN, '').strip.split(',').map(&:strip)
+    end
+  end
+end

data/lib/theme_check/file_system_storage.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "pathname"
+
+module ThemeCheck
+  class FileSystemStorage < Storage
+    attr_reader :root
+
+    def initialize(root, ignored_patterns: [])
+      @root = Pathname.new(root)
+      @ignored_patterns = ignored_patterns
+      @files = {}
+    end
+
+    def path(relative_path)
+      @root.join(relative_path)
+    end
+
+    def read(relative_path)
+      file(relative_path).read
+    end
+
+    def write(relative_path, content)
+      file(relative_path).write(content)
+    end
+
+    def files
+      @file_array ||= glob("**/*")
+        .map { |path| path.relative_path_from(@root).to_s }
+    end
+
+    def directories
+      @directories ||= glob('*')
+        .select { |f| File.directory?(f) }
+        .map { |f| f.relative_path_from(@root).to_s }
+    end
+
+    private
+
+    def glob(pattern)
+      @root.glob(pattern).reject do |path|
+        relative_path = path.relative_path_from(@root)
+        @ignored_patterns.any? { |ignored| relative_path.fnmatch?(ignored) }
+      end
+    end
+
+    def file(name)
+      return @files[name] if @files[name]
+      @files[name] = root.join(name)
+    end
+  end
+end

data/lib/theme_check/in_memory_storage.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# An in-memory storage is not written to disk. The reasons why you'd
+# want to do that are your own. The idea is to not write to disk
+# something that doesn't need to be there. If you have your template
+# as a big hash already, leave it like that and save yourself some IO.
+module ThemeCheck
+  class InMemoryStorage < Storage
+    def initialize(files = {})
+      @files = files
+    end
+
+    def path(name)
+      name
+    end
+
+    def read(name)
+      @files[name]
+    end
+
+    def write(name, content)
+      @files[name] = content
+    end
+
+    def files
+      @values ||= @files.keys
+    end
+
+    def directories
+      @directories ||= @files
+        .keys
+        .flat_map { |relative_path| Pathname.new(relative_path).ascend.to_a }
+        .map(&:to_s)
+        .uniq
+    end
+  end
+end

data/lib/theme_check/json_file.rb

@@ -4,22 +4,20 @@ require "pathname"
 
 module ThemeCheck
   class JsonFile
-    attr_reader :path
-
-    def initialize(path, root)
-      @path = Pathname(path)
-      @root = Pathname(root)
+    def initialize(relative_path, storage)
+      @relative_path = relative_path
+      @storage = storage
       @loaded = false
       @content = nil
       @parser_error = nil
     end
 
-    def relative_path
-      @path.relative_path_from(@root)
+    def path
+      @storage.path(@relative_path)
     end
 
-    def name
-      relative_path.sub_ext('').to_s
+    def relative_path
+      @relative_pathname ||= Pathname.new(@relative_path)
     end
 
     def content
@@ -32,12 +30,16 @@ module ThemeCheck
       @parser_error
     end
 
+    def name
+      relative_path.sub_ext('').to_s
+    end
+
     private
 
     def load!
       return if @loaded
 
-      @content = JSON.parse(File.read(@path))
+      @content = JSON.parse(@storage.read(@relative_path))
     rescue JSON::ParserError => e
       @parser_error = e
     ensure

data/lib/theme_check/language_server.rb

@@ -1,6 +1,16 @@
 # frozen_string_literal: true
+require_relative "language_server/protocol"
 require_relative "language_server/handler"
 require_relative "language_server/server"
+require_relative "language_server/tokens"
+require_relative "language_server/position_helper"
+require_relative "language_server/completion_helper"
+require_relative "language_server/completion_provider"
+require_relative "language_server/completion_engine"
+
+Dir[__dir__ + "/language_server/completion_providers/*.rb"].each do |file|
+  require file
+end
 
 module ThemeCheck
   module LanguageServer

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,35 @@
+# 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
+
+      def matches(s, re)
+        start_at = 0
+        matches = []
+        while (m = s.match(re, start_at))
+          matches.push(m)
+          start_at = m.end(0)
+        end
+        matches
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_provider.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CompletionProvider
+      include CompletionHelper
+
+      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