theme-check 0.5.0 → 0.7.3

data/lib/theme_check/language_server.rb

@@ -1,5 +1,6 @@
 # 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"
@@ -7,6 +8,7 @@ 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

data/lib/theme_check/language_server/completion_engine.rb

@@ -7,11 +7,11 @@ module ThemeCheck
 
       def initialize(storage)
         @storage = storage
-        @providers = CompletionProvider.all.map(&:new)
+        @providers = CompletionProvider.all.map { |x| x.new(storage) }
       end
 
-      def completions(name, line, col)
-        buffer = @storage.read(name)
+      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?

data/lib/theme_check/language_server/completion_provider.rb

@@ -16,6 +16,10 @@ module ThemeCheck
         end
       end
 
+      def initialize(storage = InMemoryStorage.new)
+        @storage = storage
+      end
+
       def completions(content, cursor)
         raise NotImplementedError
       end

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

@@ -7,8 +7,8 @@ module ThemeCheck
 
       def completions(content, cursor)
         return [] unless can_complete?(content, cursor)
-        ShopifyLiquid::Filter.labels
-          .select { |w| w.starts_with?(partial(content, cursor)) }
+        available_labels
+          .select { |w| w.start_with?(partial(content, cursor)) }
           .map { |filter| filter_to_completion(filter) }
       end
 
@@ -21,6 +21,10 @@ module ThemeCheck
 
       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|

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

@@ -7,7 +7,7 @@ module ThemeCheck
         return [] unless can_complete?(content, cursor)
         partial = first_word(content) || ''
         ShopifyLiquid::Object.labels
-          .select { |w| w.starts_with?(partial) }
+          .select { |w| w.start_with?(partial) }
           .map { |object| object_to_completion(object) }
       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.start_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

@@ -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,7 +170,7 @@ module ThemeCheck
         send_response(
           method: 'textDocument/publishDiagnostics',
           params: {
-            uri: "file:#{path}",
+            uri: "file://#{path}",
             diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
           },
         )

data/lib/theme_check/language_server/server.rb

@@ -1,11 +1,11 @@
 # 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
@@ -15,7 +15,7 @@ module ThemeCheck
       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])
@@ -50,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")
@@ -98,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/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