platformos-check 0.0.1

data/lib/platformos_check/language_server/document_change_corrector.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class DocumentChangeCorrector
+      include URIHelper
+      include JsonHelpers
+
+      def initialize
+        @json_edits = {}
+        @json_file_edits = {}
+        @text_document_edits = {}
+        @create_files = []
+        @rename_files = []
+        @delete_files = []
+      end
+
+      def document_changes
+        apply_json_edits
+        apply_json_file_edits
+        @create_files + @rename_files + @text_document_edits.values + @delete_files
+      end
+
+      # @param node [Node]
+      def insert_before(node, content, character_range = nil)
+        position = character_range_position(node, character_range) if character_range
+        edits(node) << {
+          range: {
+            start: start_location(position || node),
+            end: start_location(position || node)
+          },
+          newText: content
+        }
+      end
+
+      # @param node [Node]
+      def insert_after(node, content, character_range = nil)
+        position = character_range_position(node, character_range) if character_range
+        edits(node) << {
+          range: {
+            start: end_location(position || node),
+            end: end_location(position || node)
+          },
+          newText: content
+        }
+      end
+
+      def replace(node, content, character_range = nil)
+        position = character_range_position(node, character_range) if character_range
+        edits(node) << {
+          range: range(position || node),
+          newText: content
+        }
+      end
+
+      # @param node [LiquidNode]
+      def remove(node)
+        edits(node) << {
+          range: {
+            start: { line: node.outer_markup_start_row, character: node.outer_markup_start_column },
+            end: { line: node.outer_markup_end_row, character: node.outer_markup_end_column }
+          },
+          newText: ''
+        }
+      end
+
+      def replace_inner_markup(node, content)
+        edits(node) << {
+          range: {
+            start: {
+              line: node.inner_markup_start_row,
+              character: node.inner_markup_start_column
+            },
+            end: {
+              line: node.inner_markup_end_row,
+              character: node.inner_markup_end_column
+            }
+          },
+          newText: content
+        }
+      end
+
+      def replace_inner_json(node, json, **pretty_json_opts)
+        # Kind of brittle alert: We're assuming that modifications are
+        # made directly on the same json hash (e.g. schema). As such,
+        # if this assumption is true, then it follows that the
+        # "correct" JSON is the _last_ one that we defined.
+        #
+        # We're going to append those changes to the text edit when
+        # we're done.
+        #
+        # We're doing this because no language client will accept
+        # text modifications that occur on the same range. So we need
+        # to dedup our JSON edits for the client to accept our change.
+        #
+        # What we're doing here is overwriting the json edit for a
+        # node to the latest one that is called. If all the edits
+        # occur on the same hash, this final hash will have all the
+        # edits in it.
+        @json_edits[node] = [json, pretty_json_opts]
+      end
+
+      def wrap(node, insert_before, insert_after)
+        edits(node) << {
+          range: range(node),
+          newText: insert_before + node.markup + insert_after
+        }
+      end
+
+      def create_file(storage, relative_path, contents = nil, overwrite: false)
+        uri = file_uri(storage.path(relative_path))
+        @create_files << create_file_change(uri, overwrite)
+        return if contents.nil?
+
+        text_document = { uri:, version: nil }
+        @text_document_edits[text_document] = {
+          textDocument: text_document,
+          edits: [{
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 0 }
+            },
+            newText: contents
+          }]
+        }
+      end
+
+      def remove_file(storage, relative_path)
+        uri = file_uri(storage.path(relative_path))
+        @delete_files << delete_file_change(uri)
+      end
+
+      def mkdir(storage, relative_path)
+        path = Pathname.new(relative_path).join("tmp").to_s
+        # The LSP doesn't have a concept for directories, so what we
+        # do is create a file and then delete it.
+        #
+        # It does the job :upside_down_smile:.
+        create_file(storage, path)
+        remove_file(storage, path)
+      end
+
+      def add_translation(file, path, value)
+        raise ArgumentError unless file.is_a?(JsonFile)
+
+        hash = file.content
+        JsonHelper.set(hash, path, value)
+        @json_file_edits[file] = hash
+      end
+
+      def remove_translation(file, path)
+        raise ArgumentError unless file.is_a?(JsonFile)
+
+        hash = file.content
+        JsonHelper.delete(hash, path)
+        @json_file_edits[file] = hash
+      end
+
+      private
+
+      def apply_json_edits
+        @json_edits.each do |node, (json, pretty_json_opts)|
+          replace_inner_markup(node, pretty_json(json, **pretty_json_opts))
+        end
+      end
+
+      def apply_json_file_edits
+        @json_file_edits.each do |file, hash|
+          replace_entire_file(file, JSON.pretty_generate(hash))
+        end
+      end
+
+      def replace_entire_file(file, contents)
+        text_document = to_text_document(file)
+        position = PlatformosCheck::StrictPosition.new(file.source, file.source, 0)
+        @text_document_edits[text_document] = {
+          textDocument: text_document,
+          edits: [{
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: position.end_row, character: position.end_column }
+            },
+            newText: contents
+          }]
+        }
+      end
+
+      # @param node [Node]
+      def text_document_edit(node)
+        text_document = to_text_document(node)
+        @text_document_edits[text_document] ||= {
+          textDocument: text_document,
+          edits: []
+        }
+      end
+
+      def create_file_change(uri, overwrite = false)
+        change = {}
+        change[:kind] = 'create'
+        change[:uri] = uri
+        change[:options] = { overwrite: } if overwrite
+        change
+      end
+
+      def delete_file_change(uri)
+        {
+          kind: 'delete',
+          uri:
+        }
+      end
+
+      def edits(node)
+        text_document_edit(node)[:edits]
+      end
+
+      def to_text_document(thing)
+        case thing
+        when Node
+          {
+            uri: file_uri(thing.app_file&.path),
+            version: thing.app_file&.version
+          }
+        when AppFile
+          {
+            uri: file_uri(thing.path),
+            version: thing.version
+          }
+        else
+          raise ArgumentError
+        end
+      end
+
+      def absolute_path(node)
+        node.app_file&.path
+      end
+
+      def character_range_position(node, character_range)
+        return unless character_range
+
+        source = node.app_file.source
+        StrictPosition.new(
+          source[character_range],
+          source,
+          character_range.begin
+        )
+      end
+
+      # @param node [PlatformosCheck::Node]
+      def range(node)
+        {
+          start: start_location(node),
+          end: end_location(node)
+        }
+      end
+
+      def start_location(node)
+        {
+          line: node.start_row,
+          character: node.start_column
+        }
+      end
+
+      def end_location(node)
+        {
+          line: node.end_row,
+          character: node.end_column
+        }
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/document_link_engine.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class DocumentLinkEngine
+      def initialize(storage)
+        @storage = storage
+        @providers = DocumentLinkProvider.all.map { |x| x.new(storage) }
+      end
+
+      def document_links(relative_path)
+        buffer = @storage.read(relative_path)
+        return [] unless buffer
+
+        @providers.flat_map do |p|
+          p.document_links(buffer)
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/document_link_provider.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class DocumentLinkProvider
+      include RegexHelpers
+      include PositionHelper
+      include URIHelper
+
+      class << self
+        attr_accessor :partial_regexp, :destination_directory, :destination_postfix
+
+        def all
+          @all ||= []
+        end
+
+        def inherited(subclass)
+          all << subclass
+        end
+      end
+
+      def initialize(storage = InMemoryStorage.new)
+        @storage = storage
+      end
+
+      def partial_regexp
+        self.class.partial_regexp
+      end
+
+      def destination_directory
+        self.class.destination_directory
+      end
+
+      def destination_postfix
+        self.class.destination_postfix
+      end
+
+      def document_links(buffer)
+        matches(buffer, partial_regexp).map do |match|
+          start_row, start_column = from_index_to_row_column(
+            buffer,
+            match.begin(:partial)
+          )
+
+          end_row, end_column = from_index_to_row_column(
+            buffer,
+            match.end(:partial)
+          )
+
+          {
+            target: file_link(match[:partial]),
+            range: {
+              start: {
+                line: start_row,
+                character: start_column
+              },
+              end: {
+                line: end_row,
+                character: end_column
+              }
+            }
+          }
+        end
+      end
+
+      def file_link(partial)
+        file_uri(@storage.path(destination_directory + '/' + partial + destination_postfix))
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/document_link_providers/asset_document_link_provider.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class AssetDocumentLinkProvider < DocumentLinkProvider
+      @partial_regexp = ASSET_INCLUDE
+      @destination_directory = "assets"
+      @destination_postfix = ""
+    end
+  end
+end

data/lib/platformos_check/language_server/document_link_providers/include_document_link_provider.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class IncludeDocumentLinkProvider < DocumentLinkProvider
+      @partial_regexp = PARTIAL_INCLUDE
+      @destination_directory = "snippets"
+      @destination_postfix = ".liquid"
+    end
+  end
+end

data/lib/platformos_check/language_server/document_link_providers/render_document_link_provider.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class RenderDocumentLinkProvider < DocumentLinkProvider
+      @partial_regexp = PARTIAL_RENDER
+      @destination_directory = "snippets"
+      @destination_postfix = ".liquid"
+    end
+  end
+end

data/lib/platformos_check/language_server/document_link_providers/section_document_link_provider.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class SectionDocumentLinkProvider < DocumentLinkProvider
+      @partial_regexp = PARTIAL_SECTION
+      @destination_directory = "sections"
+      @destination_postfix = ".liquid"
+    end
+  end
+end

data/lib/platformos_check/language_server/execute_command_engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class ExecuteCommandEngine
+      def initialize
+        @providers = {}
+      end
+
+      def <<(provider)
+        @providers[provider.command] = provider
+      end
+
+      def execute(command, arguments)
+        @providers[command].execute(arguments)
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/execute_command_provider.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class ExecuteCommandProvider
+      class << self
+        def all
+          @all ||= []
+        end
+
+        def inherited(subclass)
+          all << subclass
+        end
+
+        def command(cmd = nil)
+          @command = cmd unless cmd.nil?
+          @command
+        end
+      end
+
+      def execute(arguments)
+        raise NotImplementedError
+      end
+
+      def command
+        self.class.command
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/execute_command_providers/correction_execute_command_provider.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class CorrectionExecuteCommandProvider < ExecuteCommandProvider
+      include URIHelper
+
+      command "correction"
+
+      attr_reader :storage, :bridge, :diagnostics_manager
+
+      def initialize(storage, bridge, diagnostics_manager)
+        @storage = storage
+        @bridge = bridge
+        @diagnostics_manager = diagnostics_manager
+      end
+
+      # The arguments passed to this method are the ones forwarded
+      # from the selected CodeAction by the client.
+      #
+      # @param diagnostic_hashes [Array] - of diagnostics
+      def execute(diagnostic_hashes)
+        # attempt to apply the document changes
+        workspace_edit = diagnostics_manager.workspace_edit(diagnostic_hashes)
+        result = bridge.send_request('workspace/applyEdit', {
+                                       label: 'PlatformOS Check correction',
+                                       edit: workspace_edit
+                                     })
+
+        # Bail if unable to apply changes
+        return unless result[:applied]
+
+        # Clean up internal representation of fixed diagnostics
+        diagnostics_update = diagnostics_manager.delete_applied(diagnostic_hashes)
+
+        # Send updated diagnostics to client
+        diagnostics_update
+          .map do |relative_path, diagnostics|
+            bridge.send_notification('textDocument/publishDiagnostics', {
+                                       uri: file_uri(storage.path(relative_path)),
+                                       diagnostics: diagnostics.map(&:to_h)
+                                     })
+            storage.path(relative_path)
+          end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/execute_command_providers/run_checks_execute_command_provider.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class RunChecksExecuteCommandProvider < ExecuteCommandProvider
+      include URIHelper
+
+      command "runChecks"
+
+      def initialize(diagnostics_engine, storage, linter_config, language_server_config)
+        @diagnostics_engine = diagnostics_engine
+        @storage = storage
+        @linter_config = linter_config
+        @language_server_config = language_server_config
+      end
+
+      def execute(_args)
+        @diagnostics_engine.analyze_and_send_offenses(
+          @storage.opened_files.map { |relative_path| @storage.path(relative_path) },
+          @linter_config,
+          only_single_file: @language_server_config.only_single_file?,
+          force: true
+        )
+        nil
+      end
+    end
+  end
+end