theme-check 0.4.0 → 0.7.2

data/lib/theme_check/language_server/completion_providers/tag_completion_provider.rb

@@ -7,12 +7,12 @@ module ThemeCheck
         return [] unless can_complete?(content, cursor)
         partial = first_word(content) || ''
         ShopifyLiquid::Tag.labels
-          .select { |w| w.starts_with?(partial) }
+          .select { |w| w.start_with?(partial) }
           .map { |tag| tag_to_completion(tag) }
       end
 
       def can_complete?(content, cursor)
-        content.starts_with?(Liquid::TagStart) && (
+        content.start_with?(Liquid::TagStart) && (
           cursor_on_first_word?(content, cursor) ||
           cursor_on_start_content?(content, cursor, Liquid::TagStart)
         )

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,48 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class DocumentLinkEngine
+      include PositionHelper
+      include RegexHelpers
+
+      def initialize(storage)
+        @storage = storage
+      end
+
+      def document_links(relative_path)
+        buffer = @storage.read(relative_path)
+        return [] unless buffer
+        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

@@ -8,6 +8,7 @@ module ThemeCheck
           triggerCharacters: ['.', '{{ ', '{% '],
           context: true,
         },
+        documentLinkProvider: true,
         textDocumentSync: {
           openClose: true,
           change: TextDocumentSyncKind::FULL,
@@ -19,12 +20,13 @@ 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)
         @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,
@@ -40,41 +42,70 @@ module ThemeCheck
       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))
+        relative_path = relative_path_from_text_document_uri(params)
+        @storage.write(relative_path, content_changes_text(params))
       end
 
       def on_text_document_did_close(_id, params)
-        uri = text_document_uri(params)
-        @storage.write(uri, nil)
+        relative_path = relative_path_from_text_document_uri(params)
+        @storage.write(relative_path, "")
       end
 
       def on_text_document_did_open(_id, params)
-        uri = text_document_uri(params)
-        @storage.write(uri, text_document_text(params))
-        analyze_and_send_offenses(uri)
+        relative_path = relative_path_from_text_document_uri(params)
+        @storage.write(relative_path, text_document_text(params))
+        analyze_and_send_offenses(text_document_uri(params))
       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)
+        relative_path = relative_path_from_text_document_uri(params)
+        send_response(
+          id: id,
+          result: document_links(relative_path)
+        )
+      end
+
       def on_text_document_completion(id, params)
-        uri = text_document_uri(params)
+        relative_path = relative_path_from_text_document_uri(params)
         line = params.dig('position', 'line')
         col = params.dig('position', 'character')
         send_response(
           id: id,
-          result: completions(uri, line, col)
+          result: completions(relative_path, line, col)
         )
       end
 
       private
 
+      def in_memory_storage(root)
+        config = config_for_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, config.root)
+      end
+
       def text_document_uri(params)
         params.dig('textDocument', 'uri').sub('file://', '')
       end
 
+      def relative_path_from_text_document_uri(params)
+        @storage.relative_path(text_document_uri(params))
+      end
+
       def text_document_text(params)
         params.dig('textDocument', 'text')
       end
@@ -83,9 +114,13 @@ module ThemeCheck
         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)
+      def config_for_path(path)
+        root = ThemeCheck::Config.find(path) || @root_path
+        ThemeCheck::Config.from_path(root)
+      end
+
+      def analyze_and_send_offenses(absolute_path)
+        config = config_for_path(absolute_path)
         storage = ThemeCheck::FileSystemStorage.new(
           config.root,
           ignored_patterns: config.ignored_patterns
@@ -104,8 +139,12 @@ module ThemeCheck
         analyzer.offenses
       end
 
-      def completions(uri, line, col)
-        @completion_engine.completions(uri, line, col)
+      def completions(relative_path, line, col)
+        @completion_engine.completions(relative_path, line, col)
+      end
+
+      def document_links(relative_path)
+        @document_link_engine.document_links(relative_path)
       end
 
       def send_diagnostics(offenses)
@@ -131,19 +170,27 @@ module ThemeCheck
         send_response(
           method: 'textDocument/publishDiagnostics',
           params: {
-            uri: "file:#{path}",
+            uri: "file://#{path}",
             diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
           },
         )
       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/server.rb

@@ -1,20 +1,22 @@
 # frozen_string_literal: true
 require 'json'
 require 'stringio'
-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 +27,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 +41,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 +50,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")
@@ -93,7 +98,7 @@ module ThemeCheck
       end
 
       def to_snake_case(method_name)
-        method_name.gsub(/[^\w]/, '_').underscore
+        StringHelpers.underscore(method_name.gsub(/[^\w]/, '_'))
       end
 
       def initial_line

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/node.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'active_support/core_ext/string/inflections'
 
 module ThemeCheck
   # A node from the Liquid AST, the result of parsing a template.
@@ -101,7 +100,7 @@ module ThemeCheck
     # The `:under_score_name` of this type of node. Used to dispatch to the `on_<type_name>`
     # and `after_<type_name>` check methods.
     def type_name
-      @type_name ||= @value.class.name.demodulize.underscore.to_sym
+      @type_name ||= StringHelpers.underscore(StringHelpers.demodulize(@value.class.name)).to_sym
     end
 
     # Is this node inside a `{% liquid ... %}` block?

data/lib/theme_check/offense.rb

@@ -32,6 +32,8 @@ module ThemeCheck
         node&.markup
       end
 
+      raise ArgumentError, "Offense markup cannot be an empty string" if @markup.is_a?(String) && @markup.empty?
+
       @line_number = if line_number
         line_number
       elsif @node
@@ -83,7 +85,7 @@ module ThemeCheck
     end
 
     def check_name
-      check.class.name.demodulize
+      StringHelpers.demodulize(check.class.name)
     end
 
     def doc

data/lib/theme_check/packager.rb

@@ -24,7 +24,7 @@ module ThemeCheck
       puts "Grabbing sha256 checksum from Rubygems.org"
       require 'digest/sha2'
       require 'open-uri'
-      gem_checksum = open("https://rubygems.org/downloads/theme-check-#{ThemeCheck::VERSION}.gem") do |io|
+      gem_checksum = URI.open("https://rubygems.org/downloads/theme-check-#{ThemeCheck::VERSION}.gem") do |io|
         Digest::SHA256.new.hexdigest(io.read)
       end
 

data/lib/theme_check/regex_helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module RegexHelpers
+    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

data/lib/theme_check/releaser.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'theme_check/version'
+
+module ThemeCheck
+  class Releaser
+    ROOT = File.expand_path('../../..', __FILE__)
+    LIB = File.join(ROOT, 'lib')
+
+    class VersionError < StandardError; end
+
+    def release(version)
+      raise VersionError, "Missing version argument." if version.nil?
+      raise VersionError, "Version should be a string." unless version.is_a?(String)
+      raise VersionError, "Version should be a valid semver version." unless version =~ /^\d+\.\d+.\d+$/
+      update_docs(version)
+      update_version(version)
+    end
+
+    def update_version(version)
+      version_file_path = File.join(LIB, 'theme_check/version.rb')
+      version_file = File.read(version_file_path)
+      updated_version_file = version_file.gsub(ThemeCheck::VERSION, version)
+
+      return if updated_version_file == version_file
+      puts "Updating version to #{version} in #{version_file_path}."
+      File.write(version_file_path, updated_version_file)
+    end
+
+    def update_docs(version)
+      Dir[ROOT + '/docs/checks/*.md'].each do |filename|
+        doc_content = File.read(filename)
+        updated_doc_content = doc_content.gsub('THEME_CHECK_VERSION', version)
+        next if updated_doc_content == doc_content
+        puts "Replacing `THEME_CHECK_VERSION` with #{version} in #{Pathname.new(filename).relative_path_from(ROOT)}"
+        File.write(filename, updated_doc_content)
+      end
+    end
+  end
+end

data/lib/theme_check/remote_asset_file.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require "net/http"
+require "pathname"
+
+module ThemeCheck
+  class RemoteAssetFile
+    class << self
+      def cache
+        @cache ||= {}
+      end
+
+      def from_src(src)
+        key = uri(src).to_s
+        cache[key] = RemoteAssetFile.new(src) unless cache.key?(key)
+        cache[key]
+      end
+
+      def uri(src)
+        URI.parse(src.sub(%r{^//}, "https://"))
+      end
+    end
+
+    def initialize(src)
+      @uri = RemoteAssetFile.uri(src)
+      @content = nil
+    end
+
+    def content
+      return @content unless @content.nil?
+
+      res = Net::HTTP.start(@uri.hostname, @uri.port, use_ssl: @uri.scheme == 'https') do |http|
+        req = Net::HTTP::Get.new(@uri)
+        req['Accept-Encoding'] = 'gzip, deflate, br'
+        http.request(req)
+      end
+
+      @content = res.body
+    end
+
+    def gzipped_size
+      @gzipped_size ||= content.bytesize
+    end
+  end
+end