theme-check 0.3.2 → 0.7.0

data/lib/theme_check/checks/translation_key_exists.rb

@@ -1,8 +1,21 @@
 # frozen_string_literal: true
 module ThemeCheck
+  module SystemTranslations
+    extend self
+
+    def translations
+      @translations ||= YAML.load(File.read("#{__dir__}/../../../data/shopify_translation_keys.yml")).to_set
+    end
+
+    def include?(key)
+      translations.include?(key)
+    end
+  end
+
   class TranslationKeyExists < LiquidCheck
     severity :error
     category :translation
+    doc docs_url(__FILE__)
 
     def on_variable(node)
       return unless @theme.default_locale_json&.content&.is_a?(Hash)
@@ -11,7 +24,7 @@ module ThemeCheck
       return unless (key_node = node.children.first)
       return unless key_node.value.is_a?(String)
 
-      unless key_exists?(key_node.value)
+      unless key_exists?(key_node.value) || SystemTranslations.include?(key_node.value)
         add_offense(
           "'#{key_node.value}' does not have a matching entry in '#{@theme.default_locale_json.relative_path}'",
           node: node,

data/lib/theme_check/checks/undefined_object.rb

@@ -2,7 +2,7 @@
 module ThemeCheck
   class UndefinedObject < LiquidCheck
     category :liquid
-    doc "https://shopify.dev/docs/themes/liquid/reference/objects"
+    doc docs_url(__FILE__)
     severity :error
 
     class TemplateInfo
@@ -21,7 +21,13 @@ module ThemeCheck
       end
 
       def add_variable_lookup(name:, node:)
-        line_number = node.parent.line_number
+        parent = node
+        line_number = nil
+        loop do
+          line_number = parent.line_number
+          parent = parent.parent
+          break unless line_number.nil? && parent
+        end
         key = [name, line_number]
         @all_variable_lookups[key] = node
       end
@@ -129,12 +135,12 @@ module ThemeCheck
 
     def each_template
       @files.each do |(name, info)|
-        next if name.starts_with?('snippets/')
+        next if name.start_with?('snippets/')
         yield [name, info]
       end
     end
 
-    def check_object(info, all_global_objects, render_node = nil)
+    def check_object(info, all_global_objects, render_node = nil, visited_snippets = Set.new)
       check_undefined(info, all_global_objects, render_node)
 
       info.each_snippet do |(snippet_name, node)|
@@ -143,7 +149,10 @@ module ThemeCheck
 
         snippet_variables = node.value.attributes.keys +
           Array[node.value.instance_variable_get("@alias_name")]
-        check_object(snippet_info, all_global_objects + snippet_variables, node)
+        unless visited_snippets.include?(snippet_name)
+          visited_snippets << snippet_name
+          check_object(snippet_info, all_global_objects + snippet_variables, node, visited_snippets)
+        end
       end
     end
 
@@ -151,7 +160,7 @@ module ThemeCheck
       all_variables = info.all_variables
 
       info.each_variable_lookup(!!render_node) do |(key, node)|
-        name, _line_number = key
+        name, line_number = key
         next if all_variables.include?(name)
         next if all_global_objects.include?(name)
 
@@ -161,7 +170,7 @@ module ThemeCheck
         if render_node
           add_offense("Missing argument `#{name}`", node: render_node)
         else
-          add_offense("Undefined object `#{name}`", node: node)
+          add_offense("Undefined object `#{name}`", node: node, line_number: line_number)
         end
       end
     end

data/lib/theme_check/checks/unknown_filter.rb

@@ -12,6 +12,7 @@ module ThemeCheck
   class UnknownFilter < LiquidCheck
     severity :error
     category :liquid
+    doc docs_url(__FILE__)
 
     def on_variable(node)
       used_filters = node.value.filters.map { |name, *_rest| name }

data/lib/theme_check/checks/unused_assign.rb

@@ -4,14 +4,16 @@ module ThemeCheck
   class UnusedAssign < LiquidCheck
     severity :suggestion
     category :liquid
+    doc docs_url(__FILE__)
 
     class TemplateInfo < Struct.new(:used_assigns, :assign_nodes, :includes)
-      def collect_used_assigns(templates)
+      def collect_used_assigns(templates, visited = Set.new)
         collected = used_assigns
         # Check recursively inside included snippets for use
         includes.each do |name|
-          if templates[name]
-            collected += templates[name].collect_used_assigns(templates)
+          if templates[name] && !visited.include?(name)
+            visited << name
+            collected += templates[name].collect_used_assigns(templates, visited)
           end
         end
         collected

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,9 +5,10 @@ require 'nokogumbo'
 module ThemeCheck
   class ValidHTMLTranslation < JsonCheck
     severity :suggestion
+    doc docs_url(__FILE__)
 
     def on_file(file)
-      return unless file.name.starts_with?("locales/")
+      return unless file.name.start_with?("locales/")
       return unless file.content.is_a?(Hash)
 
       visit_nested(file.content)

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

@@ -6,13 +6,18 @@ module ThemeCheck
     USAGE = <<~END
       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
+      Basic Options:
+        -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
+        -a, --auto-correct                   Automatically fix offenses
+
+      Miscellaneous:
+        --init                               Generate a .theme-check.yml file
+        --print-config                       Output active config to STDOUT
+        -h, --help                           Show this. Hi!
+        -l, --list                           List enabled checks
+        -v, --version                        Print Theme Check version
 
       Description:
         Theme Check helps you follow Shopify Themes & Liquid best practices by analyzing the
@@ -22,12 +27,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 +42,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 +52,28 @@ module ThemeCheck
           command = :list
         when "--auto-correct", "-a"
           auto_correct = true
+        when "--init"
+          command = :init
+        when "--print"
+          command = :print
         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
+          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 +96,21 @@ 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 print
+      puts YAML.dump(@config.to_h)
+    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/disabled_checks.rb

@@ -61,11 +61,11 @@ module ThemeCheck
     end
 
     def start_disabling?(text)
-      text.strip.starts_with?(DISABLE_START)
+      text.strip.start_with?(DISABLE_START)
     end
 
     def stop_disabling?(text)
-      text.strip.starts_with?(DISABLE_END)
+      text.strip.start_with?(DISABLE_END)
     end
 
     # Return a list of checks from a theme-check-disable comment

data/lib/theme_check/in_memory_storage.rb

@@ -6,24 +6,25 @@
 # 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 = "/dev/null")
       @files = files
+      @root = Pathname.new(root)
     end
 
-    def path(name)
-      name
+    def path(relative_path)
+      @root.join(relative_path)
     end
 
-    def read(name)
-      @files[name]
+    def read(relative_path)
+      @files[relative_path]
     end
 
-    def write(name, content)
-      @files[name] = content
+    def write(relative_path, content)
+      @files[relative_path] = content
     end
 
     def files
-      @values ||= @files.keys
+      @files.keys
     end
 
     def directories
@@ -33,5 +34,9 @@ module ThemeCheck
         .map(&:to_s)
         .uniq
     end
+
+    def relative_path(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(@root).to_s
+    end
   end
 end

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(relative_path, line, col)
+        buffer = @storage.read(relative_path)
+        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