theme-check 0.3.1 → 0.6.0

data/lib/theme_check/checks/unused_snippet.rb

@@ -5,6 +5,7 @@ module ThemeCheck
   class UnusedSnippet < LiquidCheck
     severity :suggestion
     category :liquid
+    doc docs_url(__FILE__)
 
     def initialize
       @used_templates = Set.new

data/lib/theme_check/checks/valid_html_translation.rb

@@ -5,6 +5,7 @@ require 'nokogumbo'
 module ThemeCheck
   class ValidHTMLTranslation < JsonCheck
     severity :suggestion
+    doc docs_url(__FILE__)
 
     def on_file(file)
       return unless file.name.starts_with?("locales/")

data/lib/theme_check/checks/valid_json.rb

@@ -3,6 +3,7 @@ module ThemeCheck
   class ValidJson < JsonCheck
     severity :error
     category :json
+    doc docs_url(__FILE__)
 
     def on_file(file)
       if file.parse_error

data/lib/theme_check/checks/valid_schema.rb

@@ -3,6 +3,7 @@ module ThemeCheck
   class ValidSchema < LiquidCheck
     severity :suggestion
     category :json
+    doc docs_url(__FILE__)
 
     def on_schema(node)
       JSON.parse(node.value.nodelist.join)

data/lib/theme_check/cli.rb

@@ -7,12 +7,14 @@ module ThemeCheck
       Usage: theme-check [options] /path/to/your/theme
 
       Options:
-        -c, [--category]          # Only run this category of checks
-        -x, [--exclude-category]  # Exclude this category of checks
-        -l, [--list]              # List enabled checks
-        -a, [--auto-correct]      # Automatically fix offenses
-        -h, [--help]              # Show this. Hi!
-        -v, [--version]           # Print Theme Check version
+        --init                               Generate a .theme-check.yml file in the current directory
+        -C, --config <path>                  Use the config provided, overriding .theme-check.yml if present
+        -c, --category <category>            Only run this category of checks
+        -x, --exclude-category  <category>   Exclude this category of checks
+        -l, --list                           List enabled checks
+        -a, --auto-correct                   Automatically fix offenses
+        -h, --help                           Show this. Hi!
+        -v, --version                        Print Theme Check version
 
       Description:
         Theme Check helps you follow Shopify Themes & Liquid best practices by analyzing the
@@ -22,12 +24,13 @@ module ThemeCheck
     END
 
     def run(argv)
-      path = "."
+      @path = "."
 
       command = :check
       only_categories = []
       exclude_categories = []
       auto_correct = false
+      config_path = nil
 
       args = argv.dup
       while (arg = args.shift)
@@ -36,6 +39,8 @@ module ThemeCheck
           raise Abort, USAGE
         when "--version", "-v"
           command = :version
+        when "--config", "-C"
+          config_path = Pathname.new(args.shift)
         when "--category", "-c"
           only_categories << args.shift.to_sym
         when "--exclude-category", "-x"
@@ -44,15 +49,26 @@ module ThemeCheck
           command = :list
         when "--auto-correct", "-a"
           auto_correct = true
+        when "--init"
+          command = :init
         else
-          path = arg
+          @path = arg
         end
       end
 
-      @config = ThemeCheck::Config.from_path(path)
-      @config.only_categories = only_categories
-      @config.exclude_categories = exclude_categories
-      @config.auto_correct = auto_correct
+      unless [:version, :init].include?(command)
+        @config = if config_path.present?
+          ThemeCheck::Config.new(
+            root: @path,
+            configuration: ThemeCheck::Config.load_file(config_path)
+          )
+        else
+          ThemeCheck::Config.from_path(@path)
+        end
+        @config.only_categories = only_categories
+        @config.exclude_categories = exclude_categories
+        @config.auto_correct = auto_correct
+      end
 
       send(command)
     end
@@ -75,6 +91,17 @@ module ThemeCheck
       puts ThemeCheck::VERSION
     end
 
+    def init
+      dotfile_path = ThemeCheck::Config.find(@path)
+      if dotfile_path.nil?
+        File.write(File.join(@path, ThemeCheck::Config::DOTFILE), File.read(ThemeCheck::Config::DEFAULT_CONFIG))
+
+        puts "Writing new #{ThemeCheck::Config::DOTFILE} to #{@path}"
+      else
+        raise Abort, "#{ThemeCheck::Config::DOTFILE} already exists at #{@path}."
+      end
+    end
+
     def check
       puts "Checking #{@config.root} ..."
       storage = ThemeCheck::FileSystemStorage.new(@config.root, ignored_patterns: @config.ignored_patterns)

data/lib/theme_check/config.rb

@@ -10,6 +10,8 @@ module ThemeCheck
     attr_accessor :only_categories, :exclude_categories, :auto_correct
 
     class << self
+      attr_reader :last_loaded_config
+
       def from_path(path)
         if (filename = find(path))
           new(root: filename.dirname, configuration: load_file(filename))
@@ -36,6 +38,7 @@ module ThemeCheck
       end
 
       def load_file(absolute_path)
+        @last_loaded_config = absolute_path
         YAML.load_file(absolute_path)
       end
 
@@ -83,8 +86,8 @@ module ThemeCheck
 
         check_class = ThemeCheck.const_get(check_name)
 
-        next if exclude_categories.include?(check_class.category)
-        next if only_categories.any? && !only_categories.include?(check_class.category)
+        next if check_class.categories.any? { |category| exclude_categories.include?(category) }
+        next if only_categories.any? && check_class.categories.none? { |category| only_categories.include?(category) }
 
         options_for_check = options.transform_keys(&:to_sym)
         options_for_check.delete(:enabled)

data/lib/theme_check/in_memory_storage.rb

@@ -6,20 +6,28 @@
 # as a big hash already, leave it like that and save yourself some IO.
 module ThemeCheck
   class InMemoryStorage < Storage
-    def initialize(files)
+    def initialize(files = {}, root = nil)
       @files = files
+      @root = root
     end
 
     def path(name)
+      return File.join(@root, name) unless @root.nil?
+      name
+    end
+
+    def relative_path(name)
+      path = Pathname.new(name)
+      return path.relative_path_from(@root).to_s unless path.relative? || @root.nil?
       name
     end
 
     def read(name)
-      @files[name]
+      @files[relative_path(name)]
     end
 
     def write(name, content)
-      @files[name] = content
+      @files[relative_path(name)] = content
     end
 
     def files

data/lib/theme_check/language_server.rb

@@ -1,6 +1,18 @@
 # frozen_string_literal: true
+require_relative "language_server/protocol"
+require_relative "language_server/constants"
 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"
+require_relative "language_server/document_link_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 { |x| x.new(storage) }
+      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,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.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 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.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/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.starts_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.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