theme-check 1.11.0 → 1.12.0

data/lib/theme_check/checks/undefined_object.rb

@@ -120,6 +120,10 @@ module ThemeCheck
           # NOTE: `email` is exceptionally exposed as a theme object in
           #       the customers' reset password template
           check_object(info, all_global_objects + ['email'])
+        elsif 'templates/robots.txt' == name
+          # NOTE: `robots` is the only object exposed object in
+          #       the robots.txt template
+          check_object(info, ['robots'])
         elsif 'layout/checkout' == name
           # NOTE: Shopify Plus has exceptionally exposed objects in
           #       the checkout template

data/lib/theme_check/language_server/completion_context.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CompletionContext
+      include PositionHelper
+
+      attr_reader :storage, :relative_path, :line, :col
+
+      def initialize(storage, relative_path, line, col)
+        @storage = storage
+        @relative_path = relative_path
+        @line = line
+        @col = col
+      end
+
+      def buffer
+        @buffer ||= storage.read(relative_path)
+      end
+
+      def buffer_until_previous_row
+        @buffer_without_current_row ||= buffer[0..absolute_cursor].lines[0...-1].join
+      end
+
+      def absolute_cursor
+        @absolute_cursor ||= from_row_column_to_index(buffer, line, col)
+      end
+
+      def cursor
+        @cursor ||= absolute_cursor - token&.start || 0
+      end
+
+      def content
+        @content ||= token&.content
+      end
+
+      def token
+        @token ||= Tokens.new(buffer).find do |t|
+          # 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.
+          t.start < absolute_cursor && absolute_cursor <= t.end
+        end
+      end
+
+      def clone_and_overwrite(col:)
+        CompletionContext.new(storage, relative_path, line, col)
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_engine.rb

@@ -3,35 +3,29 @@
 module ThemeCheck
   module LanguageServer
     class CompletionEngine
-      include PositionHelper
-
-      def initialize(storage)
+      def initialize(storage, bridge = nil)
         @storage = storage
+        @bridge = bridge
         @providers = CompletionProvider.all.map { |x| x.new(storage) }
       end
 
       def completions(relative_path, line, col)
-        buffer = @storage.read(relative_path)
-        cursor = from_row_column_to_index(buffer, line, col)
-        token = find_token(buffer, cursor)
-        return [] if token.nil?
+        context = context(relative_path, line, col)
+
+        @providers
+          .flat_map { |provider| provider.completions(context) }
+          .uniq { |completion_item| completion_item[:label] }
+      rescue StandardError => error
+        @bridge || raise(error)
+
+        message = error.message
+        backtrace = error.backtrace.join("\n")
 
-        @providers.flat_map do |p|
-          p.completions(
-            token.content,
-            cursor - token.start
-          )
-        end
+        @bridge.log("[completion error] error: #{message}\n#{backtrace}")
       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
+      def context(relative_path, line, col)
+        CompletionContext.new(@storage, relative_path, line, col)
       end
     end
   end

data/lib/theme_check/language_server/completion_provider.rb

@@ -6,6 +6,10 @@ module ThemeCheck
       include CompletionHelper
       include RegexHelpers
 
+      attr_reader :storage
+
+      CurrentToken = Struct.new(:content, :cursor, :absolute_cursor, :buffer)
+
       class << self
         def all
           @all ||= []
@@ -20,9 +24,20 @@ module ThemeCheck
         @storage = storage
       end
 
-      def completions(content, cursor)
+      def completions(relative_path, line, col)
         raise NotImplementedError
       end
+
+      def doc_hash(content)
+        return {} if content.nil? || content.empty?
+
+        {
+          documentation: {
+            kind: MarkupKinds::MARKDOWN,
+            value: content,
+          },
+        }
+      end
     end
   end
 end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class AssignmentsCompletionProvider < CompletionProvider
+      def completions(context)
+        content = context.buffer_until_previous_row
+
+        return [] if content.nil?
+        return [] unless (variable_lookup = VariableLookupFinder.lookup(context))
+        return [] unless variable_lookup.lookups.empty?
+        return [] if context.content[context.cursor - 1] == "."
+
+        finder = VariableLookupFinder::AssignmentsFinder.new(content)
+        finder.find!
+
+        finder.assignments.map do |label, potential_lookup|
+          object, _property = VariableLookupTraverser.lookup_object_and_property(potential_lookup)
+          object_to_completion(label, object.name)
+        end
+      end
+
+      private
+
+      def object_to_completion(label, object)
+        content = ShopifyLiquid::Documentation.object_doc(object)
+
+        {
+          label: label,
+          kind: CompletionItemKinds::VARIABLE,
+          **doc_hash(content),
+        }
+      end
+    end
+  end
+end

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

@@ -4,11 +4,19 @@ module ThemeCheck
   module LanguageServer
     class FilterCompletionProvider < CompletionProvider
       NAMED_FILTER = /#{Liquid::FilterSeparator}\s*(\w+)/o
+      FILTER_SEPARATOR_INCLUDING_SPACES = /\s*#{Liquid::FilterSeparator}/
+      INPUT_TYPE_VARIABLE = 'variable'
 
-      def completions(content, cursor)
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
         return [] unless can_complete?(content, cursor)
-        available_labels
-          .select { |w| w.start_with?(partial(content, cursor)) }
+
+        context = context_with_cursor_before_potential_filter_separator(context)
+        available_filters_for(determine_input_type(context))
+          .select { |w| w.name.start_with?(partial(content, cursor)) }
           .map { |filter| filter_to_completion(filter) }
       end
 
@@ -21,12 +29,41 @@ module ThemeCheck
 
       private
 
-      def available_labels
-        @labels ||= ShopifyLiquid::Filter.labels - ShopifyLiquid::DeprecatedFilter.labels
+      def context_with_cursor_before_potential_filter_separator(context)
+        content = context.content
+        diff = content.index(FILTER_SEPARATOR_INCLUDING_SPACES) - context.cursor
+
+        return context unless content.scan(FILTER_SEPARATOR_INCLUDING_SPACES).size == 1
+
+        context.clone_and_overwrite(col: context.col + diff)
+      end
+
+      def determine_input_type(context)
+        variable_lookup = VariableLookupFinder.lookup(context)
+
+        if variable_lookup
+          object, property = VariableLookupTraverser.lookup_object_and_property(variable_lookup)
+          return property.return_type if property
+          return object.name if object
+        end
+      end
+
+      def available_filters_for(input_type)
+        filters = ShopifyLiquid::SourceIndex.filters
+          .select { |filter| input_type.nil? || filter.input_type == input_type }
+        return all_labels if filters.empty?
+        return filters if input_type == INPUT_TYPE_VARIABLE
+
+        filters + available_filters_for(INPUT_TYPE_VARIABLE)
+      end
+
+      def all_labels
+        available_filters_for(nil)
       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
@@ -34,17 +71,23 @@ module ThemeCheck
 
       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
         return '' if partial_match.nil?
+
         partial_match[1]
       end
 
       def filter_to_completion(filter)
+        content = ShopifyLiquid::Documentation.render_doc(filter)
+
         {
-          label: filter,
+          label: filter.name,
           kind: CompletionItemKinds::FUNCTION,
+          tags: filter.deprecated? ? [CompletionItemTag::DEPRECATED] : [],
+          **doc_hash(content),
         }
       end
     end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class ObjectAttributeCompletionProvider < CompletionProvider
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
+        return [] unless (variable_lookup = VariableLookupFinder.lookup(context))
+        return [] if content[cursor - 1] == "." && content[cursor - 2] == "."
+
+        # Navigate through lookups until the last valid [object, property] level
+        object, property = VariableLookupTraverser.lookup_object_and_property(variable_lookup)
+
+        # If the last lookup level is incomplete/invalid, use the partial term
+        # to filter object properties.
+        partial = partial_property_name(property, variable_lookup)
+
+        return [] unless object
+
+        object
+          .properties
+          .select { |prop| partial.nil? || prop.name.start_with?(partial) }
+          .map { |prop| property_to_completion(prop) }
+      end
+
+      private
+
+      def partial_property_name(property, variable_lookup)
+        last_property = variable_lookup.lookups.last
+        last_property if last_property != property&.name
+      end
+
+      def property_to_completion(prop)
+        content = ShopifyLiquid::Documentation.render_doc(prop)
+
+        {
+          label: prop.name,
+          kind: CompletionItemKinds::PROPERTY,
+          **doc_hash(content),
+        }
+      end
+    end
+  end
+end

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

@@ -3,19 +3,19 @@
 module ThemeCheck
   module LanguageServer
     class ObjectCompletionProvider < CompletionProvider
-      def completions(content, cursor)
-        return [] unless (variable_lookup = variable_lookup_at_cursor(content, cursor))
+      def completions(context)
+        content = context.content
+
+        return [] if content.nil?
+        return [] unless (variable_lookup = VariableLookupFinder.lookup(context))
         return [] unless variable_lookup.lookups.empty?
-        return [] if content[cursor - 1] == "."
+        return [] if content[context.cursor - 1] == "."
+
         ShopifyLiquid::Object.labels
           .select { |w| w.start_with?(partial(variable_lookup)) }
           .map { |object| object_to_completion(object) }
       end
 
-      def variable_lookup_at_cursor(content, cursor)
-        VariableLookupFinder.lookup(content, cursor)
-      end
-
       def partial(variable_lookup)
         variable_lookup.name || ''
       end
@@ -23,9 +23,12 @@ module ThemeCheck
       private
 
       def object_to_completion(object)
+        content = ShopifyLiquid::Documentation.object_doc(object)
+
         {
           label: object,
           kind: CompletionItemKinds::VARIABLE,
+          **doc_hash(content),
         }
       end
     end

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

@@ -3,7 +3,11 @@
 module ThemeCheck
   module LanguageServer
     class RenderSnippetCompletionProvider < CompletionProvider
-      def completions(content, cursor)
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
         return [] unless cursor_on_quoted_argument?(content, cursor)
         partial = snippet(content) || ''
         snippets

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

@@ -3,7 +3,11 @@
 module ThemeCheck
   module LanguageServer
     class TagCompletionProvider < CompletionProvider
-      def completions(content, cursor)
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
         return [] unless can_complete?(content, cursor)
         partial = first_word(content) || ''
         labels = ShopifyLiquid::Tag.labels
@@ -23,9 +27,12 @@ module ThemeCheck
       private
 
       def tag_to_completion(tag)
+        content = ShopifyLiquid::Documentation.tag_doc(tag)
+
         {
           label: tag,
           kind: CompletionItemKinds::KEYWORD,
+          **doc_hash(content),
         }
       end
     end

data/lib/theme_check/language_server/handler.rb

@@ -67,7 +67,7 @@ module ThemeCheck
         @bridge.supports_work_done_progress = @client_capabilities.supports_work_done_progress?
         @storage = in_memory_storage(@root_path)
         @diagnostics_manager = DiagnosticsManager.new
-        @completion_engine = CompletionEngine.new(@storage)
+        @completion_engine = CompletionEngine.new(@storage, @bridge)
         @document_link_engine = DocumentLinkEngine.new(@storage)
         @diagnostics_engine = DiagnosticsEngine.new(@storage, @bridge, @diagnostics_manager)
         @execute_command_engine = ExecuteCommandEngine.new
@@ -90,6 +90,8 @@ module ThemeCheck
 
         @configuration.fetch
         @configuration.register_did_change_capability
+
+        ShopifyLiquid::SourceManager.download_or_refresh_files
       end
 
       def on_shutdown(id, _params)

data/lib/theme_check/language_server/protocol.rb

@@ -41,5 +41,14 @@ module ThemeCheck
     module ErrorCodes
       INTERNAL_ERROR = -32603
     end
+
+    module MarkupKinds
+      PLAIN_TEXT = 'plaintext'
+      MARKDOWN = 'markdown'
+    end
+
+    module CompletionItemTag
+      DEPRECATED = 1
+    end
   end
 end

data/lib/theme_check/language_server/type_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module TypeHelper
+      def input_type_of(literal)
+        case literal
+        when String
+          'string'
+        when Numeric
+          'number'
+        when TrueClass, FalseClass
+          'boolean'
+        when NilClass
+          'nil'
+        else
+          'untyped'
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/variable_lookup_finder/assignments_finder/node_handler.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class NodeHandler
+          def on_assign(node, scope)
+            # When a variable is redefined in a new scope we
+            # no longer can guarantee the type in the global scope
+            #
+            # Example:
+            # ```liquid
+            # {%- liquid
+            #   assign var1 = some_value
+            #
+            #   if condition
+            #     assign var1 = another_value
+            #            ^^^^ from here we no longer can guarantee
+            #                 the type of `var1` in the global scope
+            # -%}
+            # ```
+            p_scope = scope
+            while (p_scope = p_scope.parent)
+              p_scope.variables.delete(node.value.to)
+            end
+
+            scope << node
+            scope
+          end
+
+          ##
+          # Table row tags do not rely on blocks to define scopes,
+          # so we index their value here
+          def on_table_row(node, scope)
+            scope = scope.new_child
+
+            scope << node
+            scope
+          end
+
+          ##
+          # Define a new scope every time a new block is created
+          def on_block_body(node, scope)
+            scope = scope.new_child
+
+            ##
+            # 'for' tags handle blocks flattenly and differently
+            # than the other tags (if, unless, case).
+            #
+            # The scope of 'for' tags exists only in the first
+            # block, as the following one refers to the else
+            # statement of the iteration.
+            parent = node.parent
+
+            scope << parent if parent.type_name == :for && parent.children.first == node
+            scope
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/variable_lookup_finder/assignments_finder/scope.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class Scope < Struct.new(:variables, :parent)
+          include TypeHelper
+
+          def new_child
+            child_scope = dup
+            child_scope.variables = variables.dup
+            child_scope.parent = self
+            child_scope
+          end
+
+          def <<(node)
+            tag = node.value
+
+            case tag
+            when Liquid::Assign
+              variable_name = tag.to
+              variables[variable_name] = assign_tag_as_potential_lookup(tag)
+            when Liquid::For, Liquid::TableRow
+              variable_name = tag.variable_name
+              variables[variable_name] = iteration_tag_as_potential_lookup(tag)
+            end
+          end
+
+          private
+
+          def assign_tag_as_potential_lookup(tag)
+            variable_lookup = tag.from.name
+
+            unless variable_lookup.is_a?(Liquid::VariableLookup)
+              return PotentialLookup.new(input_type_of(variable_lookup), [], variables)
+            end
+
+            name = variable_lookup.name
+            lookups = variable_lookup.lookups
+
+            PotentialLookup.new(name, lookups, variables)
+          end
+
+          def iteration_tag_as_potential_lookup(tag)
+            variable_lookup = tag.collection_name
+
+            name = variable_lookup.name
+            lookups = [*variable_lookup.lookups, 'first']
+
+            PotentialLookup.new(name, lookups, variables)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/variable_lookup_finder/assignments_finder/scope_visitor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class ScopeVisitor
+          attr_reader :global_scope, :current_scope
+
+          def initialize
+            @node_handler = NodeHandler.new
+            @global_scope = Scope.new({})
+            @current_scope = Scope.new({})
+          end
+
+          def visit_template(template)
+            return unless template
+
+            visit(liquid_node(template), global_scope)
+          end
+
+          private
+
+          def visit(node, scope)
+            return if node.type_name == :variable_lookup
+
+            method = :"on_#{node.type_name}"
+            scope = @node_handler.send(method, node, scope) if @node_handler.respond_to?(method)
+
+            @current_scope = scope
+
+            node.children.each { |child| visit(child, scope) }
+          end
+
+          def liquid_node(template)
+            LiquidNode.new(template.root, nil, template)
+          end
+        end
+      end
+    end
+  end
+end