platformos-check 0.0.1

data/lib/platformos_check/language_server/channel.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    # How you'd use this class:
+    #
+    # In thread #1:
+    #   def foo
+    #     chan = Channel.create
+    #     send_request(chan.id, ...)
+    #     result = chan.pop
+    #     do_stuff_with_result(result)
+    #   ensure
+    #     chan.close
+    #   end
+    #
+    # In thread #2:
+    #   Channel.by_id(id) << result
+    class Channel
+      MUTEX = Mutex.new
+      CHANNELS = {}
+
+      class << self
+        def create
+          id = new_id
+          CHANNELS[id] = new(id)
+          CHANNELS[id]
+        end
+
+        def by_id(id)
+          CHANNELS[id]
+        end
+
+        def close(id)
+          CHANNELS.delete(id)
+        end
+
+        private
+
+        def new_id
+          MUTEX.synchronize do
+            @id ||= 0
+            @id += 1
+          end
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+        @response = SizedQueue.new(1)
+      end
+
+      def pop
+        @response.pop
+      end
+
+      def <<(value)
+        @response << value
+      end
+
+      def close
+        @response.close
+        Channel.close(id)
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/client_capabilities.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class ClientCapabilities
+      def initialize(capabilities)
+        @capabilities = capabilities
+      end
+
+      def supports_work_done_progress?
+        @capabilities.dig(:window, :workDoneProgress) || false
+      end
+
+      def supports_workspace_configuration?
+        @capabilities.dig(:workspace, :configuration) || false
+      end
+
+      def supports_workspace_did_change_configuration_dynamic_registration?
+        @capabilities.dig(:workspace, :didChangeConfiguration, :dynamicRegistration) || false
+      end
+
+      def initialization_option(key)
+        @capabilities.dig(:initializationOptions, key)
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/code_action_engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class CodeActionEngine
+      include PositionHelper
+
+      def initialize(storage, diagnostics_manager)
+        @storage = storage
+        @providers = CodeActionProvider.all.map { |c| c.new(storage, diagnostics_manager) }
+      end
+
+      def code_actions(absolute_path, start_position, end_position, only_kinds = [])
+        relative_path = @storage.relative_path(absolute_path)
+        buffer = @storage.read(relative_path)
+        start_index = from_row_column_to_index(buffer, start_position[0], start_position[1])
+        end_index = from_row_column_to_index(buffer, end_position[0], end_position[1])
+        range = (start_index...end_index)
+
+        @providers
+          .filter do |provider|
+            only_kinds.empty? ||
+              only_kinds.include?(provider.kind) ||
+              only_kinds.include?(provider.base_kind)
+          end
+          .flat_map do |provider|
+            provider.code_actions(relative_path, range)
+          end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/code_action_provider.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class CodeActionProvider
+      class << self
+        def all
+          @all ||= []
+        end
+
+        def inherited(subclass)
+          all << subclass
+        end
+
+        def kind(k = nil)
+          @kind = k unless k.nil?
+          @kind
+        end
+      end
+
+      attr_reader :storage, :diagnostics_manager
+
+      def initialize(storage, diagnostics_manager)
+        @storage = storage
+        @diagnostics_manager = diagnostics_manager
+      end
+
+      def kind
+        self.class.kind
+      end
+
+      def base_kind
+        kind.split('.')[0]
+      end
+
+      def code_actions(relative_path, range)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/code_action_providers/quickfix_code_action_provider.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class QuickfixCodeActionProvider < CodeActionProvider
+      kind "quickfix"
+
+      def code_actions(relative_path, range)
+        correctable_diagnostics = diagnostics_manager
+                                  .diagnostics(relative_path)
+                                  .filter(&:correctable?)
+                                  .reject do |diagnostic|
+          # We cannot quickfix if the buffer was modified. This means
+          # our diagnostics and InMemoryStorage are out of sync.
+          diagnostic.file_version != storage.version(diagnostic.relative_path)
+        end
+
+        diagnostics_under_cursor = correctable_diagnostics
+                                   .filter { |diagnostic| diagnostic.offense.in_range?(range) }
+
+        return [] if diagnostics_under_cursor.empty?
+
+        (
+          quickfix_cursor_code_actions(diagnostics_under_cursor) +
+          quickfix_all_of_type_code_actions(diagnostics_under_cursor, correctable_diagnostics) +
+          quickfix_all_code_action(correctable_diagnostics)
+        )
+      end
+
+      private
+
+      def quickfix_cursor_code_actions(diagnostics)
+        diagnostics.map do |diagnostic|
+          {
+            title: "Fix this #{diagnostic.code} problem: #{diagnostic.message}",
+            kind:,
+            diagnostics: [diagnostic.to_h],
+            isPreferred: true,
+            command: {
+              title: 'quickfix',
+              command: CorrectionExecuteCommandProvider.command,
+              arguments: [diagnostic.to_h]
+            }
+          }
+        end
+      end
+
+      def quickfix_all_of_type_code_actions(cursor_diagnostics, correctable_diagnostics)
+        codes = Set.new(cursor_diagnostics.map(&:code))
+        correctable_diagnostics_by_code = correctable_diagnostics.group_by(&:code)
+        codes.flat_map do |code|
+          diagnostics = correctable_diagnostics_by_code[code].map(&:to_h)
+          return [] unless diagnostics.size > 1
+
+          {
+            title: "Fix all #{code} problems",
+            kind:,
+            diagnostics:,
+            command: {
+              title: 'quickfix',
+              command: CorrectionExecuteCommandProvider.command,
+              arguments: diagnostics
+            }
+          }
+        end
+      end
+
+      def quickfix_all_code_action(diagnostics)
+        return [] unless diagnostics.size > 1
+
+        diagnostics = diagnostics.map(&:to_h)
+        [{
+          title: "Fix all auto-fixable problems",
+          kind:,
+          diagnostics:,
+          command: {
+            title: 'quickfix',
+            command: CorrectionExecuteCommandProvider.command,
+            arguments: diagnostics
+          }
+        }]
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/code_action_providers/source_fix_all_code_action_provider.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class SourceFixAllCodeActionProvider < CodeActionProvider
+      kind "source.fixAll"
+
+      def code_actions(relative_path, _)
+        diagnostics = diagnostics_manager
+                      .diagnostics(relative_path)
+                      .filter(&:correctable?)
+                      .reject do |diagnostic|
+          # We cannot quickfix if the buffer was modified. This means
+          # our diagnostics and InMemoryStorage are out of sync.
+          diagnostic.file_version != storage.version(diagnostic.relative_path)
+        end
+                      .map(&:to_h)
+        diagnostics_to_code_action(diagnostics)
+      end
+
+      private
+
+      def diagnostics_to_code_action(diagnostics)
+        return [] if diagnostics.empty?
+
+        [
+          {
+            title: "Fix all PlatformOS Check auto-fixable problems",
+            kind:,
+            diagnostics:,
+            command: {
+              title: 'fixAll.file',
+              command: LanguageServer::CorrectionExecuteCommandProvider.command,
+              arguments: diagnostics
+            }
+          }
+        ]
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/completion_context.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  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/platformos_check/language_server/completion_engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class CompletionEngine
+      def initialize(storage, bridge = nil)
+        @storage = storage
+        @bridge = bridge
+        @providers = CompletionProvider.all.map { |x| x.new(storage) }
+      end
+
+      def completions(relative_path, line, col)
+        context = context(relative_path, line, col)
+
+        @providers
+          .flat_map { |provider| provider.completions(context) }
+          .uniq { |completion_item| completion_item[:label] }
+      rescue StandardError => e
+        @bridge || raise(e)
+
+        message = e.message
+        backtrace = e.backtrace.join("\n")
+
+        @bridge.log("[completion error] error: #{message}\n#{backtrace}")
+      end
+
+      def context(relative_path, line, col)
+        CompletionContext.new(@storage, relative_path, line, col)
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/completion_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  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)
+        content.match(WORD)[0] if content.match?(WORD)
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/completion_provider.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class CompletionProvider
+      include CompletionHelper
+      include RegexHelpers
+
+      attr_reader :storage
+
+      CurrentToken = Struct.new(:content, :cursor, :absolute_cursor, :buffer)
+
+      class << self
+        def all
+          @all ||= []
+        end
+
+        def inherited(subclass)
+          all << subclass
+        end
+      end
+
+      def initialize(storage = InMemoryStorage.new)
+        @storage = storage
+      end
+
+      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
+
+      def format_hash(entry)
+        return {} unless entry
+        return { sortText: entry.name } unless entry.deprecated?
+
+        {
+          tags: [CompletionItemTag::DEPRECATED],
+          sortText: "~#{entry.name}"
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  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 { |label, potential_lookup| object_to_completion(label, object_name(potential_lookup)) }
+          .compact
+      end
+
+      private
+
+      def object_to_completion(label, object)
+        content = PlatformosLiquid::Documentation.object_doc(object)
+
+        {
+          label:,
+          kind: CompletionItemKinds::VARIABLE,
+          **doc_hash(content)
+        }
+      end
+
+      def object_name(potential_lookup)
+        object, _property = VariableLookupTraverser.lookup_object_and_property(potential_lookup)
+        object&.name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  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(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
+        return [] unless can_complete?(content, cursor)
+
+        context = context_with_cursor_before_potential_filter_separator(context)
+        variable_lookup = VariableLookupFinder.lookup(context)
+        denied_filters = denied_filters_for(variable_lookup)
+        available_filters_for(determine_input_type(variable_lookup))
+          .select { |filter| filter.name.start_with?(partial(content, cursor)) && denied_filters.none?(filter.name) }
+          .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 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(variable_lookup)
+        return if variable_lookup.nil?
+
+        object, property = VariableLookupTraverser.lookup_object_and_property(variable_lookup)
+        return property.return_type if property
+
+        object&.name
+      end
+
+      def denied_filters_for(variable_lookup)
+        return [] if variable_lookup.nil?
+
+        VariableLookupTraverser.find_object(variable_lookup.name)&.denied_filters || []
+      end
+
+      def available_filters_for(input_type)
+        filters = PlatformosLiquid::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
+      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
+        return '' if partial_match.nil?
+
+        partial_match[1]
+      end
+
+      def filter_to_completion(filter)
+        content = PlatformosLiquid::Documentation.render_doc(filter)
+
+        {
+          label: filter.name,
+          kind: CompletionItemKinds::FUNCTION,
+          **format_hash(filter),
+          **doc_hash(content)
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  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 = PlatformosLiquid::Documentation.render_doc(prop)
+
+        {
+          label: prop.name,
+          kind: CompletionItemKinds::PROPERTY,
+          **format_hash(prop),
+          **doc_hash(content)
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class ObjectCompletionProvider < CompletionProvider
+      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[context.cursor - 1] == "."
+
+        PlatformosLiquid::SourceIndex
+          .objects
+          .select { |object| object.name.start_with?(partial(variable_lookup)) }
+          .map { |object| object_to_completion(object) }
+      end
+
+      def partial(variable_lookup)
+        variable_lookup.name || ''
+      end
+
+      private
+
+      def object_to_completion(object)
+        content = PlatformosLiquid::Documentation.render_doc(object)
+
+        {
+          label: object.name,
+          kind: CompletionItemKinds::VARIABLE,
+          **format_hash(object),
+          **doc_hash(content)
+        }
+      end
+    end
+  end
+end