theme-check 0.1.0

data/lib/theme_check/json_check.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class JsonCheck < Check
+    extend ChecksTracking
+
+    def add_offense(message, markup: nil, line_number: nil, template: nil)
+      offenses << Offense.new(check: self, message: message, markup: markup, line_number: line_number, template: template)
+    end
+  end
+end

data/lib/theme_check/json_file.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require "json"
+require "pathname"
+
+module ThemeCheck
+  class JsonFile
+    attr_reader :path
+
+    def initialize(path, root)
+      @path = Pathname(path)
+      @root = Pathname(root)
+      @loaded = false
+      @content = nil
+      @parser_error = nil
+    end
+
+    def relative_path
+      @path.relative_path_from(@root)
+    end
+
+    def name
+      relative_path.sub_ext('').to_s
+    end
+
+    def content
+      load!
+      @content
+    end
+
+    def parse_error
+      load!
+      @parser_error
+    end
+
+    private
+
+    def load!
+      return if @loaded
+
+      @content = JSON.parse(File.read(@path))
+    rescue JSON::ParserError => e
+      @parser_error = e
+    ensure
+      @loaded = true
+    end
+  end
+end

data/lib/theme_check/json_helpers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module ThemeCheck
+  module JsonHelpers
+    def format_json_parse_error(error)
+      message = error.message[/\d+: (.+)$/, 1] || 'Invalid syntax'
+      "#{message} in JSON"
+    end
+  end
+end

data/lib/theme_check/language_server.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require_relative "language_server/handler"
+require_relative "language_server/server"
+
+module ThemeCheck
+  module LanguageServer
+    def self.start
+      Server.new.listen
+    end
+  end
+end

data/lib/theme_check/language_server/handler.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class Handler
+      CAPABILITIES = {
+        textDocumentSync: {
+          openClose: true,
+          change: false,
+          willSave: false,
+          save: true,
+        },
+      }
+
+      def initialize(server)
+        @server = server
+      end
+
+      def on_initialize(id, params)
+        @root_path = params["rootPath"]
+        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
+        send_response(
+          id: id,
+          result: {
+            capabilities: CAPABILITIES,
+          }
+        )
+      end
+
+      def on_exit(_id, _params)
+        close!
+      end
+
+      def on_text_document_did_open(_id, params)
+        analyze_and_send_offenses(params.dig('textDocument', 'uri').sub('file://', ''))
+      end
+      alias_method :on_text_document_did_save, :on_text_document_did_open
+
+      private
+
+      def analyze_and_send_offenses(file_path)
+        root = ThemeCheck::Config.find(file_path) || @root_path
+        config = ThemeCheck::Config.from_path(root)
+        theme = ThemeCheck::Theme.new(config.root)
+        analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
+
+        log("Checking #{config.root}")
+        analyzer.analyze_theme
+        log("Found #{theme.all.size} templates, and #{analyzer.offenses.size} offenses")
+        send_offenses(analyzer.offenses)
+      end
+
+      def send_offenses(offenses)
+        offenses.group_by(&:template).each do |template, template_offenses|
+          next unless template
+          # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
+          send_response(
+            method: 'textDocument/publishDiagnostics',
+            params: {
+              uri: "file:#{template.path}",
+              diagnostics: template_offenses.map { |offense| offense_to_diagnostic(offense) },
+            },
+          )
+        end
+      end
+
+      def offense_to_diagnostic(offense)
+        {
+          range: range(offense),
+          severity: severity(offense),
+          code: offense.code_name,
+          source: "theme-check",
+          message: offense.message,
+        }
+      end
+
+      def severity(offense)
+        case offense.severity
+        when :error
+          1
+        when :suggestion
+          2
+        when :style
+          3
+        else
+          4
+        end
+      end
+
+      def range(offense)
+        {
+          start: {
+            line: offense.start_line,
+            character: offense.start_column,
+          },
+          end: {
+            line: offense.end_line,
+            character: offense.end_column,
+          },
+        }
+      end
+
+      def send_response(message)
+        message[:jsonrpc] = '2.0'
+        @server.send_response(message)
+      end
+
+      def log(message)
+        @server.log(message)
+      end
+
+      def close!
+        raise DoneStreaming
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/server.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+require 'json'
+require 'stringio'
+require 'active_support/core_ext/string/inflections'
+
+module ThemeCheck
+  module LanguageServer
+    class DoneStreaming < StandardError; end
+    class IncompatibleStream < StandardError; end
+
+    class Server
+      def initialize(
+        in_stream: STDIN,
+        out_stream: STDOUT,
+        err_stream: $DEBUG ? File.open('/tmp/lsp.log', 'a') : STDERR
+      )
+        validate!([in_stream, out_stream, err_stream])
+
+        @handler = Handler.new(self)
+        @in = in_stream
+        @out = out_stream
+        @err = err_stream
+
+        @out.sync = true # do not buffer
+        @err.sync = true # do not buffer
+      end
+
+      def listen
+        loop do
+          process_request
+
+        # support ctrl+c and stuff
+        rescue SignalException, DoneStreaming
+          cleanup
+          return 0
+
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          log(e)
+          log(e.backtrace)
+          return 1
+        end
+      end
+
+      def send_response(response)
+        response_body = JSON.dump(response)
+        log(response_body) if $DEBUG
+
+        @out.write("Content-Length: #{response_body.size}\r\n")
+        @out.write("\r\n")
+        @out.write(response_body)
+        @out.flush
+      end
+
+      def log(message)
+        @err.puts(message)
+        @err.flush
+      end
+
+      private
+
+      def supported_io_classes
+        [IO, StringIO]
+      end
+
+      def validate!(streams = [])
+        streams.each do |stream|
+          unless supported_io_classes.find { |klass| stream.is_a?(klass) }
+            raise IncompatibleStream, incompatible_stream_message
+          end
+        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
+
+      def process_request
+        request_body = read_new_content
+        request_json = JSON.parse(request_body)
+        log(JSON.pretty_generate(request_json)) if $DEBUG
+
+        id = request_json['id']
+        method_name = request_json['method']
+        params = request_json['params']
+        method_name = "on_#{to_snake_case(method_name)}"
+
+        if @handler.respond_to?(method_name)
+          @handler.send(method_name, id, params)
+        else
+          log("Handler does not respond to #{method_name}")
+        end
+      end
+
+      def to_snake_case(method_name)
+        method_name.gsub(/[^\w]/, '_').underscore
+      end
+
+      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?
+
+          if initial_line.match(/Content-Length: (\d+)/)
+            break
+          end
+        end
+        initial_line
+      end
+
+      def read_new_content
+        length = initial_line.match(/Content-Length: (\d+)/)[1].to_i
+        content = ''
+        while content.length < length + 2
+          begin
+            # Why + 2? Because \r\n
+            content += @in.read(length + 2)
+          rescue => e
+            log(e)
+            log(e.backtrace)
+            # We have almost certainly been disconnected from the server
+            cleanup
+            raise DoneStreaming
+          end
+        end
+
+        content
+      end
+
+      def cleanup
+        @err.close
+        @out.close
+      rescue
+        # I did my best
+      end
+    end
+  end
+end

data/lib/theme_check/liquid_check.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require_relative "parsing_helpers"
+
+module ThemeCheck
+  class LiquidCheck < Check
+    extend ChecksTracking
+    include ParsingHelpers
+
+    def add_offense(message, node: nil, template: node&.template, markup: nil, line_number: nil)
+      offenses << Offense.new(check: self, message: message, template: template, node: node, markup: markup, line_number: line_number)
+    end
+  end
+end

data/lib/theme_check/locale_diff.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class LocaleDiff
+    PLURALIZATION_KEYS = Set.new(["zero", "one", "two", "few", "many", "other"])
+
+    attr_reader :extra_keys, :missing_keys
+
+    def initialize(default, other)
+      @default = default
+      @other = other
+      @extra_keys = []
+      @missing_keys = []
+
+      visit_object(@default, @other, [])
+    end
+
+    def add_as_offenses(check, key_prefix: [], node: nil, template: nil)
+      if extra_keys.any?
+        add_keys_offense(check, "Extra translation keys", extra_keys,
+          key_prefix: key_prefix, node: node, template: template)
+      end
+
+      if missing_keys.any?
+        add_keys_offense(check, "Missing translation keys", missing_keys,
+          key_prefix: key_prefix, node: node, template: template)
+      end
+    end
+
+    private
+
+    def add_keys_offense(check, cause, keys, key_prefix:, node: nil, template: nil)
+      message = "#{cause}: #{format_keys(key_prefix, keys)}"
+      if node
+        check.add_offense(message, node: node)
+      else
+        check.add_offense(message, template: template)
+      end
+    end
+
+    def format_keys(key_prefix, keys)
+      keys.map { |path| (key_prefix + path).join(".") }.join(", ")
+    end
+
+    def visit_object(default, other, path)
+      default = {} unless default.is_a?(Hash)
+      other = {} unless other.is_a?(Hash)
+      return if pluralization?(default) && pluralization?(other)
+
+      @extra_keys += (other.keys - default.keys).map { |key| path + [key] }
+
+      default.each do |key, default_value|
+        translated_value = other[key]
+        new_path = path + [key]
+
+        if translated_value.nil?
+          @missing_keys << new_path
+        else
+          visit_object(default_value, translated_value, new_path)
+        end
+      end
+    end
+
+    def pluralization?(hash)
+      hash.all? do |key, value|
+        PLURALIZATION_KEYS.include?(key) && !value.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/theme_check/node.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/string/inflections'
+
+module ThemeCheck
+  # A node from the Liquid AST, the result of parsing a template.
+  class Node
+    attr_reader :value, :parent, :template
+
+    def initialize(value, parent, template)
+      raise ArgumentError, "Expected a Liquid AST Node" if value.is_a?(Node)
+      @value = value
+      @parent = parent
+      @template = template
+    end
+
+    # The original source code of the node. Doesn't contain wrapping braces.
+    def markup
+      if tag?
+        @value.raw
+      elsif @value.instance_variable_defined?(:@markup)
+        @value.instance_variable_get(:@markup)
+      end
+    end
+
+    # Array of children nodes.
+    def children
+      @children ||= begin
+        nodes =
+          if comment?
+            []
+          elsif defined?(@value.class::ParseTreeVisitor)
+            @value.class::ParseTreeVisitor.new(@value, {}).children
+          elsif @value.respond_to?(:nodelist)
+            Array(@value.nodelist)
+          else
+            []
+          end
+        # Work around a bug in Liquid::Variable::ParseTreeVisitor that doesn't return
+        # the args in a hash as children nodes.
+        nodes = nodes.flat_map do |node|
+          case node
+          when Hash
+            node.values
+          else
+            node
+          end
+        end
+        nodes.map { |node| Node.new(node, self, @template) }
+      end
+    end
+
+    # Literals are hard-coded values in the template.
+    def literal?
+      @value.is_a?(String) || @value.is_a?(Integer)
+    end
+
+    # A {% tag %} node?
+    def tag?
+      @value.is_a?(Liquid::Tag)
+    end
+
+    # A {% comment %} block node?
+    def comment?
+      @value.is_a?(Liquid::Comment)
+    end
+
+    # Top level node of every template.
+    def document?
+      @value.is_a?(Liquid::Document)
+    end
+    alias_method :root?, :document?
+
+    # A {% tag %}...{% endtag %} node?
+    def block_tag?
+      @value.is_a?(Liquid::Block)
+    end
+
+    # The body of blocks
+    def block_body?
+      @value.is_a?(Liquid::BlockBody)
+    end
+
+    # A block of type of node?
+    def block?
+      block_tag? || block_body? || document?
+    end
+
+    # Most nodes have a line number, but it's not guaranteed.
+    def line_number
+      @value.line_number if @value.respond_to?(:line_number)
+    end
+
+    # The `:under_score_name` of this type of node. Used to dispatch to the `on_<type_name>`
+    # and `after_<type_name>` check methods.
+    def type_name
+      @type_name ||= @value.class.name.demodulize.underscore.to_sym
+    end
+
+    # Is this node inside a `{% liquid ... %}` block?
+    def inside_liquid_tag?
+      if line_number
+        template.excerpt(line_number).start_with?("{%")
+      else
+        false
+      end
+    end
+
+    # Is this node inside a `{%- ... -%}`
+    def whitespace_trimmed?
+      if line_number
+        template.excerpt(line_number).start_with?("{%-")
+      else
+        false
+      end
+    end
+  end
+end