platformos-check 0.0.1

data/lib/platformos_check/language_server/handler.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "benchmark"
+
+module PlatformosCheck
+  module LanguageServer
+    class Handler
+      include URIHelper
+
+      SERVER_INFO = {
+        name: $PROGRAM_NAME,
+        version: PlatformosCheck::VERSION
+      }
+
+      # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#fileOperationFilter
+      FILE_OPERATION_FILTER = {
+        filters: [{
+          scheme: 'file',
+          pattern: {
+            glob: '**/*'
+          }
+        }]
+      }
+
+      CAPABILITIES = {
+        completionProvider: {
+          triggerCharacters: ['.', '{{ ', '{% '],
+          context: true
+        },
+        codeActionProvider: {
+          codeActionKinds: CodeActionProvider.all.map(&:kind),
+          resolveProvider: false,
+          workDoneProgress: false
+        },
+        documentLinkProvider: true,
+        hoverProvider: true,
+        executeCommandProvider: {
+          workDoneProgress: false,
+          commands: ExecuteCommandProvider.all.map(&:command)
+        },
+        textDocumentSync: {
+          openClose: true,
+          change: TextDocumentSyncKind::FULL,
+          willSave: false,
+          save: true
+        },
+        workspace: {
+          fileOperations: {
+            didCreate: FILE_OPERATION_FILTER,
+            didDelete: FILE_OPERATION_FILTER,
+            willRename: FILE_OPERATION_FILTER
+          }
+        }
+      }
+
+      def initialize(bridge)
+        @bridge = bridge
+      end
+
+      def on_initialize(id, params)
+        @root_path = root_path_from_params(params)
+
+        # Tell the client we don't support anything if there's no rootPath
+        return @bridge.send_response(id, { capabilities: {} }) if @root_path.nil?
+
+        @client_capabilities = ClientCapabilities.new(params.dig(:capabilities) || {})
+        @configuration = Configuration.new(@bridge, @client_capabilities)
+        @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, @bridge)
+        @hover_engine = HoverEngine.new(@storage, @bridge)
+        @document_link_engine = DocumentLinkEngine.new(@storage)
+        @diagnostics_engine = DiagnosticsEngine.new(@storage, @bridge, @diagnostics_manager)
+        @execute_command_engine = ExecuteCommandEngine.new
+        @execute_command_engine << CorrectionExecuteCommandProvider.new(@storage, @bridge, @diagnostics_manager)
+        @execute_command_engine << RunChecksExecuteCommandProvider.new(
+          @diagnostics_engine,
+          @storage,
+          config_for_path(@root_path),
+          @configuration
+        )
+        @code_action_engine = CodeActionEngine.new(@storage, @diagnostics_manager)
+        @bridge.send_response(id, {
+                                capabilities: CAPABILITIES,
+                                serverInfo: SERVER_INFO
+                              })
+      end
+
+      def on_initialized(_id, _params)
+        return unless @configuration
+
+        @configuration.fetch
+        @configuration.register_did_change_capability
+
+        PlatformosLiquid::SourceManager.download_or_refresh_files
+      end
+
+      def on_shutdown(id, _params)
+        @bridge.send_response(id, nil)
+      end
+
+      def on_exit(_id, _params)
+        close!
+      end
+
+      def on_text_document_did_open(_id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        @storage.write(relative_path, text_document_text(params), text_document_version(params))
+        analyze_and_send_offenses(text_document_uri(params)) if @configuration.check_on_open?
+      end
+
+      def on_text_document_did_change(_id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        @storage.write(relative_path, content_changes_text(params), text_document_version(params))
+        analyze_and_send_offenses(text_document_uri(params), only_single_file: true) if @configuration.check_on_change?
+      end
+
+      def on_text_document_did_close(_id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        begin
+          file_system_content = Pathname.new(text_document_uri(params)).read(mode: 'rb', encoding: 'UTF-8')
+          # On close, the file system becomes the source of truth
+          @storage.write(relative_path, file_system_content, nil)
+
+        # the file no longer exists because either the user deleted it, or the user renamed it.
+        rescue Errno::ENOENT
+          @storage.remove(relative_path)
+        ensure
+          @diagnostics_engine.clear_diagnostics(relative_path) if @configuration.only_single_file?
+        end
+      end
+
+      def on_text_document_did_save(_id, params)
+        analyze_and_send_offenses(text_document_uri(params)) if @configuration.check_on_save?
+      end
+
+      def on_text_document_document_link(id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        @bridge.send_response(id, @document_link_engine.document_links(relative_path))
+      end
+
+      def on_text_document_hover(id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        line = params.dig(:position, :line)
+        col = params.dig(:position, :character)
+        @bridge.send_response(id, @hover_engine.completions(relative_path, line, col)[0])
+      end
+
+      def on_text_document_completion(id, params)
+        relative_path = relative_path_from_text_document_uri(params)
+        line = params.dig(:position, :line)
+        col = params.dig(:position, :character)
+        @bridge.send_response(id, @completion_engine.completions(relative_path, line, col))
+      end
+
+      def on_text_document_code_action(id, params)
+        absolute_path = text_document_uri(params)
+        start_position = range_element(params, :start)
+        end_position = range_element(params, :end)
+        only_code_action_kinds = params.dig(:context, :only) || []
+        @bridge.send_response(id, @code_action_engine.code_actions(
+                                    absolute_path,
+                                    start_position,
+                                    end_position,
+                                    only_code_action_kinds
+                                  ))
+      end
+
+      def on_workspace_did_create_files(_id, params)
+        paths = params[:files]
+          &.map { |file| file[:uri] }
+          &.map { |uri| file_path(uri) }
+        return unless paths
+
+        paths.each do |path|
+          relative_path = @storage.relative_path(path)
+          file_system_content = Pathname.new(path).read(mode: 'rb', encoding: 'UTF-8')
+          @storage.write(relative_path, file_system_content, nil)
+        end
+      end
+
+      def on_workspace_did_delete_files(_id, params)
+        absolute_paths = params[:files]
+          &.map { |file| file[:uri] }
+          &.map { |uri| file_path(uri) }
+        return unless absolute_paths
+
+        absolute_paths.each do |path|
+          relative_path = @storage.relative_path(path)
+          @storage.remove(relative_path)
+        end
+
+        analyze_and_send_offenses(absolute_paths)
+      end
+
+      # We're using workspace/willRenameFiles here because we want this to run
+      # before textDocument/didOpen and textDocumetn/didClose of the files
+      # (which might trigger another platformos_app analysis).
+      def on_workspace_will_rename_files(id, params)
+        relative_paths = params[:files]
+          &.map { |file| [file[:oldUri], file[:newUri]] }
+          &.map { |(old_uri, new_uri)| [relative_path_from_uri(old_uri), relative_path_from_uri(new_uri)] }
+        return @bridge.send_response(id, nil) unless relative_paths
+
+        relative_paths.each do |(old_path, new_path)|
+          @storage.write(new_path, @storage.read(old_path), nil)
+          @storage.remove(old_path)
+        end
+        @bridge.send_response(id, nil)
+
+        absolute_paths = relative_paths.flatten(2).map { |p| @storage.path(p) }
+        analyze_and_send_offenses(absolute_paths)
+      end
+
+      def on_workspace_execute_command(id, params)
+        @bridge.send_response(id, @execute_command_engine.execute(
+                                    params[:command],
+                                    params[:arguments]
+                                  ))
+      end
+
+      def on_workspace_did_change_configuration(_id, _params)
+        @configuration.fetch(force: true)
+      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 = PlatformosCheck::FileSystemStorage.new(
+          config.root,
+          ignored_patterns: config.ignored_patterns
+        )
+
+        # Turn that into a hash of buffers
+        files = fs.files
+                  .map { |fn| [fn, fs.read(fn)] }
+                  .to_h
+
+        VersionedInMemoryStorage.new(files, config.root)
+      end
+
+      def text_document_uri(params)
+        file_path(params.dig(:textDocument, :uri))
+      end
+
+      def relative_path_from_uri(uri)
+        @storage.relative_path(file_path(uri))
+      end
+
+      def relative_path_from_text_document_uri(params)
+        @storage.relative_path(text_document_uri(params))
+      end
+
+      def root_path_from_params(params)
+        root_uri = params[:rootUri]
+        root_path = params[:rootPath]
+        if root_uri
+          file_path(root_uri)
+        elsif root_path
+          root_path
+        end
+      end
+
+      def text_document_text(params)
+        params.dig(:textDocument, :text)
+      end
+
+      def text_document_version(params)
+        params.dig(:textDocument, :version)
+      end
+
+      def content_changes_text(params)
+        params.dig(:contentChanges, 0, :text)
+      end
+
+      def config_for_path(path_or_paths)
+        path = path_or_paths.is_a?(Array) ? path_or_paths[0] : path_or_paths
+        root = PlatformosCheck::Config.find(path) || @root_path
+        PlatformosCheck::Config.from_path(root)
+      end
+
+      def analyze_and_send_offenses(absolute_path_or_paths, only_single_file: nil)
+        @diagnostics_engine.analyze_and_send_offenses(
+          absolute_path_or_paths,
+          config_for_path(absolute_path_or_paths),
+          only_single_file: only_single_file.nil? ? @configuration.only_single_file? : only_single_file
+        )
+      end
+
+      def range_element(params, start_or_end)
+        [
+          params.dig(:range, start_or_end, :line),
+          params.dig(:range, start_or_end, :character)
+        ]
+      end
+
+      def log(message)
+        @bridge.log(message)
+      end
+
+      def close!
+        raise DoneStreaming
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/hover_engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class HoverEngine
+      def initialize(storage, bridge = nil)
+        @storage = storage
+        @bridge = bridge
+        @providers = HoverProvider.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/hover_provider.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class HoverProvider
+      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/hover_providers/filter_hover_provider.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class FilterHoverProvider < HoverProvider
+      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 == partial(content, cursor)) && denied_filters.none?(filter.name) }
+          .map { |filter| filter_to_completion(filter) }
+          .first
+      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 param_to_doc(param)
+        "#{param.name}:#{param.return_type.downcase}"
+      end
+
+      def filter_to_completion(filter)
+        content = PlatformosLiquid::Documentation.render_doc(filter)
+        first_param, *other_params = filter.parameters
+        other_params = other_params.map { |param| param_to_doc(param) }
+        other_params = other_params.any? ? ": #{other_params.join(', ')}" : ""
+        content = "#{param_to_doc(first_param)} | #{filter.name}#{other_params} => #{filter.return_type}"
+
+        {
+          contents: content,
+
+          # label: filter.name,
+          # kind: CompletionItemKinds::FUNCTION,
+          # **format_hash(filter),
+          # **doc_hash(content)
+        }
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/io_messenger.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class IOMessenger < Messenger
+      def self.err_stream
+        if PlatformosCheck.debug_log_file
+          File.open(PlatformosCheck.debug_log_file, "w")
+        else
+          STDERR
+        end
+      end
+
+      def initialize(
+        in_stream: STDIN,
+        out_stream: STDOUT,
+        err_stream: IOMessenger.err_stream
+      )
+        validate!([in_stream, out_stream, err_stream])
+
+        @in = in_stream
+        @out = out_stream
+        @err = err_stream
+
+        # Because programming is fun,
+        #
+        # Ruby on Windows turns \n into \r\n. Which means that \r\n
+        # gets turned into \r\r\n. Which means that the protocol
+        # breaks on windows unless we turn STDOUT into binary mode.
+        #
+        # Hours wasted: 9.
+        @out.binmode
+
+        @out.sync = true # do not buffer
+        @err.sync = true # do not buffer
+
+        # Lock for writing, otherwise messages might be interspersed.
+        @writer = Mutex.new
+      end
+
+      def read_message
+        length = initial_line.match(/Content-Length: (\d+)/)[1].to_i
+        content = ''
+        length_to_read = 2 + length # 2 is the empty line length (\r\n)
+        while content.length < length_to_read
+          chunk = @in.read(length_to_read - content.length)
+          raise DoneStreaming if chunk.nil?
+
+          content += chunk
+        end
+        content.lstrip!
+      rescue IOError
+        raise DoneStreaming
+      end
+
+      def send_message(message_body)
+        @writer.synchronize do
+          @out.write("Content-Length: #{message_body.bytesize}\r\n")
+          @out.write("\r\n")
+          @out.write(message_body)
+          @out.flush
+        end
+      end
+
+      def log(message)
+        @err.puts(message)
+        @err.flush
+      end
+
+      def close_input
+        @in.close unless @in.closed?
+      end
+
+      def close_output
+        @err.close
+        @out.close
+      end
+
+      private
+
+      def initial_line
+        # Scanning for lines that fit the protocol.
+        while true
+          initial_line = @in.gets
+          # gets returning nil means the stream was closed.
+          raise DoneStreaming if initial_line.nil?
+
+          break if /Content-Length: (\d+)/.match?(initial_line)
+        end
+        initial_line
+      end
+
+      def supported_io_classes
+        [IO, StringIO]
+      end
+
+      def validate!(streams = [])
+        streams.each do |stream|
+          raise IncompatibleStream, incompatible_stream_message unless supported_io_classes.find { |klass| stream.is_a?(klass) }
+        end
+      end
+
+      def incompatible_stream_message
+        'if provided, in_stream, out_stream, and err_stream must be a kind of ' \
+          "one of the following: #{supported_io_classes.join(', ')}"
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/messenger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class Messenger
+      def send_message
+        raise NotImplementedError
+      end
+
+      def read_message
+        raise NotImplementedError
+      end
+
+      def log
+        raise NotImplementedError
+      end
+
+      def close_input
+        raise NotImplementedError
+      end
+
+      def close_output
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/protocol.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Here we define the Language Server Protocol Constants we're using.
+# For complete docs, see the following:
+# https://microsoft.github.io/language-server-protocol/specifications/specification-current
+module PlatformosCheck
+  module LanguageServer
+    module CompletionItemKinds
+      TEXT = 1
+      METHOD = 2
+      FUNCTION = 3
+      CONSTRUCTOR = 4
+      FIELD = 5
+      VARIABLE = 6
+      CLASS = 7
+      INTERFACE = 8
+      MODULE = 9
+      PROPERTY = 10
+      UNIT = 11
+      VALUE = 12
+      ENUM = 13
+      KEYWORD = 14
+      SNIPPET = 15
+      COLOR = 16
+      FILE = 17
+      REFERENCE = 18
+      FOLDER = 19
+      ENUM_MEMBER = 20
+      CONSTANT = 21
+      STRUCT = 22
+      EVENT = 23
+      OPERATOR = 24
+      TYPE_PARAMETER = 25
+    end
+
+    module TextDocumentSyncKind
+      NONE = 0
+      FULL = 1
+      INCREMENTAL = 2
+    end
+
+    module ErrorCodes
+      INTERNAL_ERROR = -32_603
+    end
+
+    module MarkupKinds
+      PLAIN_TEXT = 'plaintext'
+      MARKDOWN = 'markdown'
+    end
+
+    module CompletionItemTag
+      DEPRECATED = 1
+    end
+  end
+end