platformos-check 0.0.1

data/lib/platformos_check/html_node.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module PlatformosCheck
+  class HtmlNode < Node
+    extend Forwardable
+    include RegexHelpers
+    include PositionHelper
+    attr_reader :app_file, :parent
+
+    class << self
+      include RegexHelpers
+
+      def parse(liquid_file)
+        placeholder_values = []
+        parseable_source = +liquid_file.source.clone
+
+        # Replace all non-empty liquid tags with ≬{i}######≬ to prevent the HTML
+        # parser from freaking out. We transparently replace those placeholders in
+        # HtmlNode.
+        #
+        # We're using base36 to prevent index bleeding on 36^3 tags.
+        # `{{x}}` -> `≬#{i}≬` would properly be transformed for 46656 tags in a single file.
+        # Should be enough.
+        #
+        # The base10 alternative would have overflowed at 1000 (`{{x}}` -> `≬1000≬`) which seemed more likely.
+        #
+        # Didn't go with base64 because of the `=` character that would have messed with HTML parsing.
+        #
+        # (Note, we're also maintaining newline characters in there so
+        # that line numbers match the source...)
+        matches(parseable_source, LIQUID_TAG_OR_VARIABLE).each do |m|
+          value = m[0]
+          next unless value.size > 4 # skip empty tags/variables {%%} and {{}}
+
+          placeholder_values.push(value)
+          key = (placeholder_values.size - 1).to_s(36)
+
+          # Doing shenanigans so that line numbers match... Ugh.
+          keyed_placeholder = parseable_source[m.begin(0)...m.end(0)]
+
+          # First and last chars are ≬
+          keyed_placeholder[0] = "≬"
+          keyed_placeholder[-1] = "≬"
+
+          # Non newline characters are #
+          keyed_placeholder.gsub!(/[^\n≬]/, '#')
+
+          # First few # are replaced by the base10 ID of the tag
+          i = -1
+          keyed_placeholder.gsub!('#') do
+            i += 1
+            if i > key.size - 1
+              '#'
+            else
+              key[i]
+            end
+          end
+
+          # Replace source by placeholder
+          parseable_source[m.begin(0)...m.end(0)] = keyed_placeholder
+        end
+
+        new(
+          Nokogiri::HTML5.fragment(parseable_source, max_tree_depth: 400, max_attributes: 400),
+          liquid_file,
+          placeholder_values,
+          parseable_source
+        )
+      end
+    end
+
+    def initialize(value, app_file, placeholder_values, parseable_source, parent = nil)
+      @value = value
+      @app_file = app_file
+      @placeholder_values = placeholder_values
+      @parseable_source = parseable_source
+      @parent = parent
+    end
+
+    # @value is not forwarded because we _need_ to replace the
+    # placeholders for the HtmlNode to make sense.
+    def value
+      if literal?
+        content
+      else
+        markup
+      end
+    end
+
+    def children
+      @children ||= @value
+                    .children
+                    .map { |child| HtmlNode.new(child, app_file, @placeholder_values, @parseable_source, self) }
+    end
+
+    def markup
+      @markup ||= replace_placeholders(parseable_markup)
+    end
+
+    def line_number
+      @value.line
+    end
+
+    def start_index
+      position.start_index
+    end
+
+    def end_index
+      position.end_index
+    end
+
+    def start_row
+      position.start_row
+    end
+
+    def start_column
+      position.start_column
+    end
+
+    def end_row
+      position.end_row
+    end
+
+    def end_column
+      position.end_column
+    end
+
+    def literal?
+      @value.name == "text"
+    end
+
+    def element?
+      @value.element?
+    end
+
+    def attributes
+      @attributes ||= @value.attributes
+                            .map { |k, v| [replace_placeholders(k), replace_placeholders(v.value)] }
+                            .to_h
+    end
+
+    def parseable_markup
+      return @parseable_source if @value.name == "#document-fragment"
+      return @value.to_str if @value.comment?
+      return @value.content if literal?
+
+      start_index = from_row_column_to_index(@parseable_source, line_number - 1, 0)
+      @parseable_source
+        .match(/<\s*#{name}[^>]*>/im, start_index)[0]
+    rescue NoMethodError
+      # Don't know what's up with the following issue. Don't think
+      # null check is correct approach. This should give us more info.
+      # https://github.com/Platform-OS/platformos-lsp/issues/528
+      PlatformosCheck.bug(<<~MSG)
+        Can't find a parseable tag of name #{name} inside the parseable HTML.
+
+        Tag name:
+          #{@value.name.inspect}
+
+        File:
+          #{@app_file.relative_path}
+
+        Line number:
+          #{line_number}
+
+        Excerpt:
+          ```
+          #{@app_file.source.lines[line_number - 1...line_number + 5].join("")}
+          ```
+
+        Parseable Excerpt:
+          ```
+          #{@parseable_source.lines[line_number - 1...line_number + 5].join("")}
+          ```
+      MSG
+    end
+
+    def content
+      @content ||= replace_placeholders(@value.content)
+    end
+
+    def name
+      if @value.name == "#document-fragment"
+        "document"
+      else
+        @value.name
+      end
+    end
+
+    private
+
+    def position
+      @position ||= Position.new(
+        markup,
+        app_file.source,
+        line_number_1_indexed: line_number
+      )
+    end
+
+    def replace_placeholders(string)
+      # Replace all ≬{i}####≬ with the actual content.
+      string.gsub(HTML_LIQUID_PLACEHOLDER) do |match|
+        key = /[0-9a-z]+/.match(match.delete("\n"))[0]
+        @placeholder_values[key.to_i(36)]
+      end
+    end
+  end
+end

data/lib/platformos_check/html_visitor.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "forwardable"
+
+module PlatformosCheck
+  class HtmlVisitor
+    attr_reader :checks
+
+    def initialize(checks)
+      @checks = checks
+    end
+
+    def visit_liquid_file(liquid_file)
+      visit(HtmlNode.parse(liquid_file))
+    rescue ArgumentError => e
+      call_checks(:on_parse_error, e, liquid_file)
+    end
+
+    private
+
+    def visit(node)
+      call_checks(:on_element, node) if node.element?
+      call_checks(:"on_#{node.name}", node)
+      node.children.each { |child| visit(child) }
+      return if node.literal?
+
+      call_checks(:"after_#{node.name}", node)
+      call_checks(:after_element, node) if node.element?
+    end
+
+    def call_checks(method, *)
+      checks.call(method, *)
+    end
+  end
+end

data/lib/platformos_check/in_memory_storage.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# An in-memory storage is not written to disk. The reasons why you'd
+# want to do that are your own. The idea is to not write to disk
+# something that doesn't need to be there. If you have your platformos_app
+# as a big hash already, leave it like that and save yourself some IO.
+module PlatformosCheck
+  class InMemoryStorage < Storage
+    attr_reader :root
+
+    def initialize(files = {}, root = "/dev/null")
+      @files = files # Hash<String, String>
+      @root = Pathname.new(root)
+    end
+
+    def path(relative_path)
+      @root.join(relative_path)
+    end
+
+    def read(relative_path)
+      @files[relative_path]
+    end
+
+    def write(relative_path, content)
+      @files[relative_path] = content
+    end
+
+    def remove(relative_path)
+      @files.delete(relative_path)
+    end
+
+    def mkdir(relative_path)
+      @files[relative_path] = nil
+      reset_memoizers
+    end
+
+    # TODO: Fix corrector
+    # def rename(old_path, new_path)
+    #   old_path += '/' if old_path[-1] != '/'
+    #   new_path += '/' if new_path[-1] != '/'
+    #   @files.transform_keys! { |k| k.sub(/\A#{old_path}/, new_path) }
+    #
+    #   reset_memoizers
+    # end
+
+    def files
+      @files.keys
+    end
+
+    def directories
+      @directories ||= @files
+                       .keys
+                       .flat_map { |relative_path| Pathname.new(relative_path).ascend.to_a }
+                       .map(&:to_s)
+                       .uniq
+    end
+
+    def relative_path(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(@root).to_s
+    end
+
+    private
+
+    def reset_memoizers
+      @directories = nil
+    end
+  end
+end

data/lib/platformos_check/json_file.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+
+module PlatformosCheck
+  class JsonFile < AppFile
+    def initialize(relative_path, storage)
+      super
+      @loaded = false
+      @content = nil
+      @parser_error = nil
+    end
+
+    def content
+      load!
+      @content
+    end
+
+    def parse_error
+      load!
+      @parser_error
+    end
+
+    def update_contents(new_content = {})
+      raise ArgumentError if new_content.is_a?(String)
+
+      @content = new_content
+    end
+
+    def write
+      pretty = JSON.pretty_generate(@content)
+      return unless source.rstrip != pretty.rstrip
+
+      # Most editors add a trailing \n at the end of files. Here we
+      # try to maintain the convention.
+      eof = source.end_with?("\n") ? "\n" : ""
+      @storage.write(@relative_path, pretty.gsub("\n", @eol) + eof)
+      @source = pretty
+    end
+
+    def json?
+      true
+    end
+
+    private
+
+    def load!
+      return if @loaded
+
+      @content = JSON.parse(source)
+    rescue JSON::ParserError => e
+      @parser_error = e
+    ensure
+      @loaded = true
+    end
+  end
+end

data/lib/platformos_check/json_helper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class JsonHelper
+    # Deeply sets a value in a hash. Accepts both arrays and strings for path.
+    def self.set(hash, path, value)
+      path = path.split('.') if path.is_a?(String)
+      path.each_with_index.reduce(hash) do |pointer, (token, index)|
+        if index == path.size - 1
+          pointer[token] = value
+        elsif !pointer.key?(token) || !pointer[token].is_a?(Hash)
+          pointer[token] = {}
+        end
+        pointer[token]
+      end
+      hash
+    end
+
+    # Deeply delete a key from a hash
+    def self.delete(hash, path)
+      path = path.split('.') if path.is_a?(String)
+      path.each_with_index.reduce(hash) do |pointer, (token, index)|
+        break pointer.delete(token) if index == path.size - 1
+
+        pointer[token]
+      end
+    end
+
+    # Deeply add key/values inside a hash.
+    #
+    # Handles arrays by adding the key/value to all hashes inside the array.
+    #
+    # Specially handles objects that have the "id" key like this:
+    #
+    # e.g.
+    #
+    # json = {
+    #   "deep" => [
+    #     { "id" => "hi" },
+    #     { "id" => "oh" },
+    #   ],
+    # }
+    # assert_equal(
+    #   {
+    #     "deep" => [
+    #       { "id" => "hi", "ho" => "ho" },
+    #       { "id" => "oh" },
+    #     ],
+    #   },
+    #   JsonHelper.json_corrector(json, "deep.hi.ho", "ho")
+    # )
+    def self.json_corrector(json, path, value)
+      return json unless json.is_a?(Hash)
+
+      path = path.split('.') if path.is_a?(String)
+      path.each_with_index.reduce(json) do |pointer, (token, index)|
+        case pointer
+        when Array
+          pointer.each do |item|
+            json_corrector(item, path.drop(1), value)
+          end
+
+        when Hash
+          break pointer[token] = value if index == path.size - 1
+
+          pointer[token] = {} unless pointer.key?(token) || pointer.key?("id")
+          pointer[token].nil? && pointer["id"] == token ? pointer : pointer[token]
+        end
+      end
+      json
+    end
+  end
+end

data/lib/platformos_check/json_helpers.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module JsonHelpers
+    def format_json_parse_error(error)
+      message = error.message[/\d+: (.+)$/, 1] || 'Invalid syntax'
+      "#{message} in JSON"
+    end
+
+    def pretty_json(hash, start_level: 1, indent: "  ")
+      start_indent = indent * start_level
+
+      <<~JSON
+
+        #{start_indent}#{JSON.pretty_generate(
+          hash,
+          indent:,
+          array_nl: "\n#{start_indent}",
+          object_nl: "\n#{start_indent}"
+        )}
+      JSON
+    end
+  end
+end

data/lib/platformos_check/json_printer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PlatformosCheck
+  class JsonPrinter
+    def initialize(out_stream = STDOUT)
+      @out = out_stream
+    end
+
+    def print(offenses)
+      json = offenses_by_path(offenses)
+      @out.puts JSON.dump(json)
+    end
+
+    def offenses_by_path(offenses)
+      offenses
+        .map(&:to_h)
+        .group_by { |offense| offense[:path] }
+        .map do |(path, path_offenses)|
+          {
+            path:,
+            offenses: path_offenses.map { |offense| offense.filter { |k, _v| k != :path } },
+            errorCount: path_offenses.count { |offense| offense[:severity] == Check::SEVERITY_VALUES[:error] },
+            suggestionCount: path_offenses.count { |offense| offense[:severity] == Check::SEVERITY_VALUES[:suggestion] },
+            styleCount: path_offenses.count { |offense| offense[:severity] == Check::SEVERITY_VALUES[:style] }
+          }
+        end
+        .sort_by { |o| o[:path] || Pathname.new('') }
+    end
+  end
+end

data/lib/platformos_check/language_server/bridge.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+# This class exists as a bridge (or boundary) between our handlers and the outside world.
+#
+# It is concerned with all the Language Server Protocol constructs. i.e.
+#
+#   - sending Hash messages as JSON
+#   - reading JSON messages as Hashes
+#   - preparing, sending and resolving requests
+#   - preparing and sending responses
+#   - preparing and sending notifications
+#   - preparing and sending progress notifications
+#
+# But it _not_ concerned by _how_ those messages are sent to the
+# outside world. That's the job of the messenger.
+#
+# This enables us to have all the language server protocol logic
+# in here living independently of how we communicate with the
+# client (STDIO or websocket)
+module PlatformosCheck
+  module LanguageServer
+    class Bridge
+      attr_writer :supports_work_done_progress
+
+      def initialize(messenger)
+        # The messenger is responsible for IO.
+        # Could be STDIO or WebSockets or Mock.
+        @messenger = messenger
+
+        # Whether the client supports work done progress notifications
+        @supports_work_done_progress = false
+
+        @work_done_progress_mutex = Mutex.new
+        @work_done_progress_token = 1
+      end
+
+      def log(message)
+        @messenger.log(message)
+      end
+
+      def read_message
+        message_body = @messenger.read_message
+        message_json = JSON.parse(message_body, symbolize_names: true)
+        @messenger.log(JSON.pretty_generate(message_json)) if PlatformosCheck.debug?
+        message_json
+      end
+
+      def send_message(message_hash)
+        message_hash[:jsonrpc] = '2.0'
+        message_body = JSON.dump(message_hash)
+        @messenger.log(JSON.pretty_generate(message_hash)) if PlatformosCheck.debug?
+        @messenger.send_message(message_body)
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#requestMessage
+      def send_request(method, params = nil)
+        channel = Channel.create
+        message = { id: channel.id }
+        message[:method] = method
+        message[:params] = params if params
+        send_message(message)
+        channel.pop
+      ensure
+        channel.close
+      end
+
+      def receive_response(id, result)
+        Channel.by_id(id) << result
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
+      def send_response(id, result = nil, error = nil)
+        message = { id: }
+        if error
+          message[:error] = error
+        else
+          message[:result] = result
+        end
+        send_message(message)
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#responseError
+      def send_internal_error(id, e)
+        # For a reason I can't comprehend, sometimes
+        # e.full_message _hangs_ and brings your CPU to 100%.
+        # It's wrapped in here because it prints anyway...
+        # This shit is weird, yo.
+        Timeout.timeout(1) do
+          warn e.full_message
+        end
+      ensure
+        send_response(id, nil, {
+                        code: ErrorCodes::INTERNAL_ERROR,
+                        message: "A platformos-check-language-server has occured, inspect OUTPUT logs for details."
+                      })
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
+      def send_notification(method, params)
+        message = { method: }
+        message[:params] = params
+        send_message(message)
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#progress
+      def send_progress(token, value)
+        send_notification("$/progress", token:, value:)
+      end
+
+      def supports_work_done_progress?
+        @supports_work_done_progress
+      end
+
+      def send_create_work_done_progress_request
+        # This isn't necessary, but it kind of is to make it obvious
+        # that this variable is not thread safe. Don't try to refactor
+        # this with @work_done_progress_token because you're going to
+        # have a hard time.
+        token = @work_done_progress_mutex.synchronize do
+          @work_done_progress_token += 1
+        end
+
+        return token unless supports_work_done_progress?
+
+        # We're going to wait for a response here...
+        send_request("window/workDoneProgress/create", {
+                       token:
+                     })
+
+        token
+      end
+
+      def send_work_done_progress_begin(token, title)
+        return unless supports_work_done_progress?
+
+        send_progress(token, {
+                        kind: 'begin',
+                        title:,
+                        cancellable: false,
+                        percentage: 0
+                      })
+      end
+
+      def send_work_done_progress_report(token, message, percentage)
+        return unless supports_work_done_progress?
+
+        send_progress(token, {
+                        kind: 'report',
+                        message:,
+                        cancellable: false,
+                        percentage:
+                      })
+      end
+
+      def send_work_done_progress_end(token, message)
+        return unless supports_work_done_progress?
+
+        send_progress(token, {
+                        kind: 'end',
+                        message:
+                      })
+      end
+    end
+  end
+end