platformos-check 0.0.1

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class RenderSnippetCompletionProvider < CompletionProvider
+      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
+          .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/platformos_check/language_server/completion_providers/tag_completion_provider.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class TagCompletionProvider < CompletionProvider
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
+        return [] unless can_complete?(content, cursor)
+
+        partial = first_word(content) || ''
+        labels = PlatformosLiquid::Tag.labels
+        labels += PlatformosLiquid::Tag.end_labels
+        labels
+          .select { |w| w.start_with?(partial) }
+          .map { |tag| tag_to_completion(tag) }
+      end
+
+      def can_complete?(content, cursor)
+        content.start_with?(Liquid::TagStart) && (
+          cursor_on_first_word?(content, cursor) ||
+          cursor_on_start_content?(content, cursor, Liquid::TagStart)
+        )
+      end
+
+      private
+
+      def tag_to_completion(tag)
+        content = PlatformosLiquid::Documentation.tag_doc(tag)
+
+        {
+          label: tag,
+          kind: CompletionItemKinds::KEYWORD,
+          **doc_hash(content)
+        }
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/configuration.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class Configuration
+      CHECK_ON_OPEN = :'platformosCheck.checkOnOpen'
+      CHECK_ON_SAVE = :'platformosCheck.checkOnSave'
+      CHECK_ON_CHANGE = :'platformosCheck.checkOnChange'
+      ONLY_SINGLE_FILE = :'platformosCheck.onlySingleFileChecks'
+
+      def initialize(bridge, capabilities)
+        @bridge = bridge
+        @capabilities = capabilities
+        @mutex = Mutex.new
+        @initialized = false
+        @config = {
+          CHECK_ON_OPEN => null_coalesce(@capabilities.initialization_option(CHECK_ON_OPEN), true),
+          CHECK_ON_SAVE => null_coalesce(@capabilities.initialization_option(CHECK_ON_SAVE), true),
+          CHECK_ON_CHANGE => null_coalesce(@capabilities.initialization_option(CHECK_ON_CHANGE), true),
+          ONLY_SINGLE_FILE => null_coalesce(@capabilities.initialization_option(ONLY_SINGLE_FILE), false)
+        }
+      end
+
+      def fetch(force: nil)
+        @mutex.synchronize do
+          return unless @capabilities.supports_workspace_configuration?
+          return if initialized? && !force
+
+          keys = [
+            CHECK_ON_OPEN,
+            CHECK_ON_SAVE,
+            CHECK_ON_CHANGE,
+            ONLY_SINGLE_FILE
+          ]
+
+          configs = @bridge.send_request(
+            "workspace/configuration",
+            items: keys.map do |key|
+              { section: key }
+            end
+          )
+
+          keys.each.with_index do |key, i|
+            @config[key] = configs[i] unless configs[i].nil?
+          end
+
+          @initialized = true
+        end
+      end
+
+      def register_did_change_capability
+        return unless @capabilities.supports_workspace_did_change_configuration_dynamic_registration?
+
+        @bridge.send_request('client/registerCapability', registrations: [{
+                               id: "workspace/didChangeConfiguration",
+                               method: "workspace/didChangeConfiguration"
+                             }])
+      end
+
+      def initialized?
+        @initialized
+      end
+
+      def check_on_open?
+        fetch # making sure we have an initialized value
+        @config[CHECK_ON_OPEN]
+      end
+
+      def check_on_save?
+        fetch # making sure we have for an initialized value
+        @config[CHECK_ON_SAVE]
+      end
+
+      def check_on_change?
+        fetch # making sure we have for an initialized value
+        @config[CHECK_ON_CHANGE]
+      end
+
+      def only_single_file?
+        fetch # making sure we have for an initialized value
+        @config[ONLY_SINGLE_FILE]
+      end
+
+      def null_coalesce(value, default)
+        value.nil? ? default : value
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/constants.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    def self.partial_tag(tag)
+      /
+        \{%-?\s*#{tag}\s+'(?<partial>[^']*)'|
+        \{%-?\s*#{tag}\s+"(?<partial>[^"]*)"|
+
+        # in liquid tags the whole line is white space until the tag
+        ^\s*#{tag}\s+'(?<partial>[^']*)'|
+        ^\s*#{tag}\s+"(?<partial>[^"]*)"
+      /mix
+    end
+
+    PARTIAL_RENDER = partial_tag('render')
+    PARTIAL_INCLUDE = partial_tag('include')
+    PARTIAL_SECTION = partial_tag('section')
+
+    ASSET_INCLUDE = /
+      \{\{-?\s*'(?<partial>[^']*)'\s*\|\s*asset_url|
+      \{\{-?\s*"(?<partial>[^"]*)"\s*\|\s*asset_url|
+
+      # in liquid tags the whole line is white space until the asset partial
+      ^\s*(?:echo|assign[^=]*=)\s*'(?<partial>[^']*)'\s*\|\s*asset_url|
+      ^\s*(?:echo|assign[^=]*=)\s*"(?<partial>[^"]*)"\s*\|\s*asset_url
+    /mix
+  end
+end

data/lib/platformos_check/language_server/diagnostic.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class Diagnostic
+      include URIHelper
+
+      attr_reader :offense
+
+      def initialize(offense)
+        @offense = offense
+        @diagnostic = nil
+      end
+
+      def ==(other)
+        case other
+        when Hash, Diagnostic
+          to_h == other.to_h
+        else
+          raise ArgumentError
+        end
+      end
+
+      def to_h
+        return @diagnostic unless @diagnostic.nil?
+
+        @diagnostic = {
+          source: "platformos-check",
+          code:,
+          message:,
+          range:,
+          severity:,
+          data:
+        }
+        @diagnostic[:codeDescription] = code_description unless offense.doc.nil?
+        @diagnostic
+      end
+
+      def to_s
+        to_h.to_s
+      end
+
+      def single_file?
+        offense.single_file?
+      end
+
+      def whole_platformos_app?
+        offense.whole_platformos_app?
+      end
+
+      def correctable?
+        offense.correctable?
+      end
+
+      def code
+        offense.code_name
+      end
+
+      def message
+        offense.message
+      end
+
+      def code_description
+        {
+          href: offense.doc
+        }
+      end
+
+      def severity
+        case offense.severity
+        when :error
+          1
+        when :suggestion
+          2
+        when :style
+          3
+        else
+          4
+        end
+      end
+
+      def range
+        {
+          start: {
+            line: offense.start_row,
+            character: offense.start_column
+          },
+          end: {
+            line: offense.end_row,
+            character: offense.end_column
+          }
+        }
+      end
+
+      def start_index
+        offense.start_index
+      end
+
+      def end_index
+        offense.end_index
+      end
+
+      def absolute_path
+        @absolute_path ||= offense&.app_file&.path
+      end
+
+      def relative_path
+        @relative_path ||= offense&.app_file&.relative_path
+      end
+
+      def uri
+        @uri ||= absolute_path && file_uri(absolute_path)
+      end
+
+      def file_version
+        @version ||= offense&.version
+      end
+
+      def data
+        {
+          absolute_path: absolute_path.to_s,
+          relative_path: relative_path.to_s,
+          uri:,
+          version: file_version
+        }
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/diagnostics_engine.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class DiagnosticsEngine
+      include URIHelper
+
+      attr_reader :storage
+
+      def initialize(storage, bridge, diagnostics_manager = DiagnosticsManager.new)
+        @diagnostics_lock = Mutex.new
+        @diagnostics_manager = diagnostics_manager
+        @storage = storage
+        @bridge = bridge
+      end
+
+      def first_run?
+        @diagnostics_manager.first_run?
+      end
+
+      def analyze_and_send_offenses(absolute_path_or_paths, config, force: false, only_single_file: false)
+        return unless @diagnostics_lock.try_lock
+
+        platformos_app = PlatformosCheck::App.new(storage)
+        analyzer = PlatformosCheck::Analyzer.new(platformos_app, config.enabled_checks)
+
+        if !only_single_file && (@diagnostics_manager.first_run? || force)
+          run_full_platformos_check(analyzer)
+        else
+          run_partial_platformos_check(absolute_path_or_paths, platformos_app, analyzer, only_single_file)
+        end
+
+        @diagnostics_lock.unlock
+      end
+
+      def clear_diagnostics(relative_paths)
+        return unless @diagnostics_lock.try_lock
+
+        as_array(relative_paths).each do |relative_path|
+          send_clearing_diagnostics(relative_path)
+        end
+
+        @diagnostics_lock.unlock
+      end
+
+      private
+
+      def run_full_platformos_check(analyzer)
+        raise 'Unsafe operation' unless @diagnostics_lock.owned?
+
+        token = @bridge.send_create_work_done_progress_request
+        @bridge.send_work_done_progress_begin(token, "Full platformos_app check")
+        @bridge.log("Checking #{storage.root}")
+        offenses = nil
+        time = Benchmark.measure do
+          offenses = analyzer.analyze_platformos_app do |path, i, total|
+            @bridge.send_work_done_progress_report(token, "#{i}/#{total} #{path}", (i.to_f / total * 100.0).to_i)
+          end
+        end
+        end_message = "Found #{offenses.size} offenses in #{format("%0.2f", time.real)}s"
+        @bridge.send_work_done_progress_end(token, end_message)
+        @bridge.log(end_message)
+        send_diagnostics(offenses)
+      end
+
+      def run_partial_platformos_check(absolute_path_or_paths, platformos_app, analyzer, only_single_file)
+        raise 'Unsafe operation' unless @diagnostics_lock.owned?
+
+        relative_paths = as_array(absolute_path_or_paths).map do |absolute_path|
+          Pathname.new(storage.relative_path(absolute_path))
+        end
+
+        app_files = relative_paths
+                    .map { |relative_path| platformos_app[relative_path] }
+                    .reject(&:nil?)
+
+        deleted_relative_paths = relative_paths - app_files.map(&:relative_path)
+        deleted_relative_paths
+          .each { |p| send_clearing_diagnostics(p) }
+
+        token = @bridge.send_create_work_done_progress_request
+        @bridge.send_work_done_progress_begin(token, "Partial platformos_app check")
+        offenses = nil
+        time = Benchmark.measure do
+          offenses = analyzer.analyze_files(app_files, only_single_file:) do |path, i, total|
+            @bridge.send_work_done_progress_report(token, "#{i}/#{total} #{path}", (i.to_f / total * 100.0).to_i)
+          end
+        end
+        end_message = "Found #{offenses.size} new offenses in #{format("%0.2f", time.real)}s"
+        @bridge.send_work_done_progress_end(token, end_message)
+        @bridge.log(end_message)
+        send_diagnostics(offenses, app_files.map(&:relative_path), only_single_file:)
+      end
+
+      def send_clearing_diagnostics(relative_path)
+        raise 'Unsafe operation' unless @diagnostics_lock.owned?
+
+        relative_path = Pathname.new(relative_path) unless relative_path.is_a?(Pathname)
+        @diagnostics_manager.clear_diagnostics(relative_path)
+        send_diagnostic(relative_path, DiagnosticsManager::NO_DIAGNOSTICS)
+      end
+
+      def as_array(maybe_array)
+        case maybe_array
+        when Array
+          maybe_array
+        else
+          [maybe_array]
+        end
+      end
+
+      def send_diagnostics(offenses, analyzed_files = nil, only_single_file: false)
+        @diagnostics_manager.build_diagnostics(
+          offenses,
+          analyzed_files:,
+          only_single_file:
+        ).each do |relative_path, diagnostics|
+          send_diagnostic(relative_path, diagnostics)
+        end
+      end
+
+      def send_diagnostic(relative_path, diagnostics)
+        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
+        @bridge.send_notification('textDocument/publishDiagnostics', {
+                                    uri: file_uri(storage.path(relative_path)),
+                                    diagnostics: diagnostics.map(&:to_h)
+                                  })
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/diagnostics_manager.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module PlatformosCheck
+  module LanguageServer
+    class DiagnosticsManager
+      # The empty array is used in the protocol to mean that no
+      # diagnostics exist for this file. It's not always evident when
+      # reading code.
+      NO_DIAGNOSTICS = [].freeze
+
+      # This class exists to facilitate LanguageServer diagnostics tracking.
+      #
+      # Motivations:
+      #   1. The first time we lint, we want all the errors from all the files.
+      #   2. If we fix all the errors in a file, we have to send an empty array for that file.
+      #   3. If we do a partial check, we should consider the whole platformos_app diagnostics as valid, and return cached results
+      #   4. We should be able to create WorkspaceEdits from diagnostics, so that the ExecuteCommandEngine can do its job
+      #   5. We should clean up diagnostics that were applied by the client
+      def initialize
+        @latest_diagnostics = {} # { [Pathname(relative_path)] => Diagnostic[] }
+        @mutex = Mutex.new
+        @first_run = true
+      end
+
+      def first_run?
+        @first_run
+      end
+
+      def diagnostics(relative_path)
+        relative_path = Pathname.new(relative_path) if relative_path.is_a?(String)
+        @mutex.synchronize { @latest_diagnostics[relative_path] || [] }
+      end
+
+      def build_diagnostics(offenses, analyzed_files: nil, only_single_file: false)
+        @mutex.synchronize do
+          full_check = analyzed_files.nil?
+          analyzed_paths = analyzed_files.map { |path| Pathname.new(path) } unless full_check
+
+          # When analyzed_files is nil, contains all offenses.
+          # When analyzed_files is !nil, contains all whole platformos_app offenses and single file offenses of the analyzed_files.
+          current_diagnostics = offenses
+                                .select(&:app_file)
+                                .group_by(&:app_file)
+                                .transform_keys { |app_file| Pathname.new(app_file.relative_path) }
+                                .transform_values do |app_file_offenses|
+            app_file_offenses.map { |o| Diagnostic.new(o) }
+          end
+
+          previous_paths = paths(@latest_diagnostics)
+          current_paths = paths(current_diagnostics)
+
+          diagnostics_update = (current_paths + previous_paths).map do |path|
+            # When doing single file checks, we keep the whole platformos_app old
+            # ones and accept the new single ones
+            if only_single_file && analyzed_paths.include?(path)
+              single_file_diagnostics = current_diagnostics[path] || NO_DIAGNOSTICS
+              whole_platformos_app_diagnostics = whole_platformos_app_diagnostics(path) || NO_DIAGNOSTICS
+              [path, single_file_diagnostics + whole_platformos_app_diagnostics]
+
+            # If doing single file checks that are not in the
+            # analyzed_paths array then we just keep the old
+            # diagnostics
+            elsif only_single_file
+              [path, previous_diagnostics(path) || NO_DIAGNOSTICS]
+
+            # When doing a full_check, we either send the current
+            # diagnostics or an empty array to clear the diagnostics
+            # for that file.
+            elsif full_check
+              [path, current_diagnostics[path] || NO_DIAGNOSTICS]
+
+            # When doing a partial check, the single file diagnostics
+            # from the previous runs should be sent. Otherwise the
+            # latest results are the good ones.
+            else
+              new_diagnostics = current_diagnostics[path] || NO_DIAGNOSTICS
+              should_use_cached_results = !analyzed_paths.include?(path)
+              old_diagnostics = should_use_cached_results ? single_file_diagnostics(path) : []
+              [path, new_diagnostics + old_diagnostics]
+            end
+          end.to_h
+
+          @latest_diagnostics = diagnostics_update
+                                .reject { |_, v| v.empty? }
+
+          @first_run = false
+
+          # Only send updates for the current file when running with only_single_file
+          diagnostics_update
+            .reject { |p, _| only_single_file && !analyzed_paths.include?(p) }
+        end
+      end
+
+      def workspace_edit(diagnostics)
+        diagnostics = sanitize(diagnostics)
+                      .select(&:correctable?)
+
+        {
+          documentChanges: document_changes(diagnostics)
+        }
+      end
+
+      def delete_applied(diagnostics)
+        diagnostics = sanitize(diagnostics)
+                      .select(&:correctable?)
+
+        previous_paths = paths(@latest_diagnostics)
+
+        diagnostics.each do |diagnostic|
+          delete(diagnostic.relative_path, diagnostic)
+        end
+
+        current_paths = paths(@latest_diagnostics)
+
+        (current_paths + previous_paths).map do |path|
+          [path, @latest_diagnostics[path] || []]
+        end.to_h
+      end
+
+      # For when you know there shouldn't be anything on that file
+      # anymore. (e.g. file delete or file rename)
+      def clear_diagnostics(relative_path)
+        relative_path = sanitize_path(relative_path)
+        @latest_diagnostics.delete(relative_path)
+      end
+
+      private
+
+      def sanitize(diagnostics)
+        diagnostics = diagnostics.map { |hash| find(hash) }.reject(&:nil?) if diagnostics[0].is_a?(Hash)
+        diagnostics
+      end
+
+      def sanitize_path(relative_path)
+        case relative_path
+        when String
+          Pathname.new(relative_path)
+        else
+          relative_path
+        end
+      end
+
+      def delete(relative_path, diagnostic)
+        relative_path = sanitize_path(relative_path)
+        @mutex.synchronize do
+          @latest_diagnostics[relative_path]&.delete(diagnostic)
+          @latest_diagnostics.delete(relative_path) if @latest_diagnostics[relative_path] && @latest_diagnostics[relative_path].empty?
+        end
+      end
+
+      def find(diagnostic_hash)
+        diagnostics(diagnostic_hash.dig(:data, :relative_path))
+          .find { |d| d == diagnostic_hash }
+      end
+
+      def document_changes(diagnostics)
+        corrector = DocumentChangeCorrector.new
+        diagnostics.each do |diagnostic|
+          offense = diagnostic.offense
+          offense.correct(corrector)
+        end
+        corrector.document_changes
+      end
+
+      def paths(diagnostics)
+        (diagnostics || {}).keys.map { |path| Pathname.new(path) }.to_set
+      end
+
+      def single_file_diagnostics(relative_path)
+        @latest_diagnostics[relative_path]&.select(&:single_file?) || []
+      end
+
+      def whole_platformos_app_diagnostics(relative_path)
+        @latest_diagnostics[relative_path]&.select(&:whole_platformos_app?) || []
+      end
+
+      def previous_diagnostics(relative_path)
+        @latest_diagnostics[relative_path]
+      end
+    end
+  end
+end