tsrs 0.18.0-x86_64-linux-gnu

data/ext/tsrs/tsrs.c

@@ -0,0 +1,261 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/thread.h>
+#include "include/tsrs.h"
+
+static VALUE rb_mTsrs;
+static VALUE rb_mBackend;
+static VALUE rb_eError;
+static VALUE rb_eOptionError;
+static VALUE rb_eTsrsEncodingError;
+static VALUE rb_eTranspileError;
+static VALUE rb_eInternalError;
+static VALUE rb_ePanicError;
+static VALUE rb_eCheckError;
+static VALUE rb_cSessionHandle;
+
+typedef struct TsrsResult (*tsrs_source_function)(const char *, const char *);
+typedef struct TsrsResult (*tsrs_options_function)(const char *);
+
+struct source_call_arguments {
+  tsrs_source_function function;
+  const char *source;
+  const char *options;
+  struct TsrsResult result;
+};
+
+struct options_call_arguments {
+  tsrs_options_function function;
+  const char *options;
+  struct TsrsResult result;
+};
+
+static VALUE make_utf8_string(const char *cstring) {
+  return rb_enc_str_new_cstr(cstring, rb_utf8_encoding());
+}
+
+static VALUE take_utf8_string(char *cstring) {
+  if (!cstring) return Qnil;
+
+  VALUE string = make_utf8_string(cstring);
+  tsrs_string_free(cstring);
+
+  return string;
+}
+
+static VALUE error_class_for(enum TsrsErrorCode code) {
+  switch (code) {
+    case TSRS_ERROR_CODE_OPTION: return rb_eOptionError;
+    case TSRS_ERROR_CODE_ENCODING: return rb_eTsrsEncodingError;
+    case TSRS_ERROR_CODE_TRANSPILE: return rb_eTranspileError;
+    case TSRS_ERROR_CODE_CHECK: return rb_eCheckError;
+    case TSRS_ERROR_CODE_PANIC: return rb_ePanicError;
+    default: return rb_eInternalError;
+  }
+}
+
+static VALUE unwrap(struct TsrsResult result) {
+  if (result.error) {
+    VALUE message = make_utf8_string(result.error);
+    VALUE error_class = error_class_for(result.code);
+
+    tsrs_result_free(result);
+
+    rb_raise(error_class, "%s", StringValueCStr(message));
+  }
+
+  if (!result.value) {
+    tsrs_result_free(result);
+
+    rb_raise(rb_eInternalError, "tsrs returned no result");
+  }
+
+  VALUE value = rb_enc_str_new(result.value, (long) result.value_len, rb_utf8_encoding());
+
+  tsrs_result_free(result);
+
+  return value;
+}
+
+static void *source_call_without_gvl(void *data) {
+  struct source_call_arguments *arguments = (struct source_call_arguments *) data;
+
+  arguments->result = arguments->function(arguments->source, arguments->options);
+
+  return NULL;
+}
+
+static void *options_call_without_gvl(void *data) {
+  struct options_call_arguments *arguments = (struct options_call_arguments *) data;
+
+  arguments->result = arguments->function(arguments->options);
+
+  return NULL;
+}
+
+static VALUE source_call(tsrs_source_function function, VALUE source, VALUE options) {
+  struct source_call_arguments arguments;
+
+  arguments.function = function;
+  arguments.source = StringValueCStr(source);
+  arguments.options = StringValueCStr(options);
+
+  rb_thread_call_without_gvl(source_call_without_gvl, &arguments, NULL, NULL);
+
+  RB_GC_GUARD(source);
+  RB_GC_GUARD(options);
+
+  return unwrap(arguments.result);
+}
+
+static VALUE options_call(tsrs_options_function function, VALUE options) {
+  struct options_call_arguments arguments;
+
+  arguments.function = function;
+  arguments.options = StringValueCStr(options);
+
+  rb_thread_call_without_gvl(options_call_without_gvl, &arguments, NULL, NULL);
+
+  RB_GC_GUARD(options);
+
+  return unwrap(arguments.result);
+}
+
+struct session_call_arguments {
+  struct TsrsSession *session;
+  const char *options;
+  struct TsrsResult result;
+};
+
+static void session_free(void *data) {
+  tsrs_session_free((struct TsrsSession *) data);
+}
+
+static const rb_data_type_t session_type = {
+  "Tsrs::Backend::SessionHandle",
+  { NULL, session_free, NULL },
+  NULL,
+  NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static struct TsrsSession *session_of(VALUE handle) {
+  struct TsrsSession *session = (struct TsrsSession *) rb_check_typeddata(handle, &session_type);
+
+  if (!session) rb_raise(rb_eInternalError, "the session is gone");
+
+  return session;
+}
+
+static void *session_call_without_gvl(void *data) {
+  struct session_call_arguments *arguments = (struct session_call_arguments *) data;
+
+  arguments->result = tsrs_session_check(arguments->session, arguments->options);
+
+  return NULL;
+}
+
+static VALUE rb_session_new(VALUE self, VALUE cwd) {
+  (void) self;
+
+  struct TsrsSession *session = tsrs_session_new(StringValueCStr(cwd));
+
+  if (!session) rb_raise(rb_eInternalError, "tsrs could not start a session");
+
+  return TypedData_Wrap_Struct(rb_cSessionHandle, &session_type, session);
+}
+
+static VALUE rb_session_check(VALUE self, VALUE handle, VALUE options) {
+  (void) self;
+
+  struct session_call_arguments arguments;
+
+  arguments.options = StringValueCStr(options);
+  arguments.session = tsrs_session_retain(session_of(handle));
+
+  rb_thread_call_without_gvl(session_call_without_gvl, &arguments, NULL, NULL);
+
+  tsrs_session_free(arguments.session);
+
+  RB_GC_GUARD(handle);
+  RB_GC_GUARD(options);
+
+  return unwrap(arguments.result);
+}
+
+static VALUE rb_session_close(VALUE self, VALUE handle) {
+  (void) self;
+
+  tsrs_session_close(session_of(handle));
+
+  return Qnil;
+}
+
+static VALUE rb_transpile(VALUE self, VALUE source, VALUE options) {
+  (void) self;
+
+  return source_call(tsrs_transpile, source, options);
+}
+
+static VALUE rb_transpile_declaration(VALUE self, VALUE source, VALUE options) {
+  (void) self;
+
+  return source_call(tsrs_transpile_declaration, source, options);
+}
+
+static VALUE rb_check(VALUE self, VALUE options) {
+  (void) self;
+
+  return options_call(tsrs_check, options);
+}
+
+static VALUE rb_panic_for_test(VALUE self) {
+  (void) self;
+
+  return unwrap(tsrs_panic_for_test());
+}
+
+static VALUE rb_native_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(tsrs_version());
+}
+
+static VALUE rb_tsrs_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(tsrs_tsrs_version());
+}
+
+static VALUE rb_typescript_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(tsrs_typescript_version());
+}
+
+void Init_tsrs(void) {
+  rb_mTsrs = rb_define_module("Tsrs");
+  rb_mBackend = rb_define_module_under(rb_mTsrs, "Backend");
+
+  rb_eError = rb_define_class_under(rb_mTsrs, "Error", rb_eStandardError);
+  rb_eOptionError = rb_define_class_under(rb_mTsrs, "OptionError", rb_eError);
+  rb_eTsrsEncodingError = rb_define_class_under(rb_mTsrs, "EncodingError", rb_eError);
+  rb_eTranspileError = rb_define_class_under(rb_mTsrs, "TranspileError", rb_eError);
+  rb_eInternalError = rb_define_class_under(rb_mTsrs, "InternalError", rb_eError);
+  rb_ePanicError = rb_define_class_under(rb_mTsrs, "PanicError", rb_eInternalError);
+  rb_eCheckError = rb_define_class_under(rb_mTsrs, "CheckError", rb_eError);
+
+  rb_cSessionHandle = rb_define_class_under(rb_mBackend, "SessionHandle", rb_cObject);
+  rb_undef_alloc_func(rb_cSessionHandle);
+
+  rb_define_singleton_method(rb_mBackend, "transpile", rb_transpile, 2);
+  rb_define_singleton_method(rb_mBackend, "transpile_declaration", rb_transpile_declaration, 2);
+  rb_define_singleton_method(rb_mBackend, "check", rb_check, 1);
+  rb_define_singleton_method(rb_mBackend, "session_new", rb_session_new, 1);
+  rb_define_singleton_method(rb_mBackend, "session_check", rb_session_check, 2);
+  rb_define_singleton_method(rb_mBackend, "session_close", rb_session_close, 1);
+  rb_define_singleton_method(rb_mBackend, "panic_for_test", rb_panic_for_test, 0);
+  rb_define_singleton_method(rb_mBackend, "version", rb_native_version, 0);
+  rb_define_singleton_method(rb_mBackend, "tsrs_version", rb_tsrs_version, 0);
+  rb_define_singleton_method(rb_mBackend, "typescript_version", rb_typescript_version, 0);
+}

data/lib/tsrs/backend.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Tsrs
+  module Backend
+    module Unavailable
+      #: (String, String) -> String
+      def transpile(_source, _options_json)
+        unavailable(__method__)
+      end
+
+      #: (String, String) -> String
+      def transpile_declaration(_source, _options_json)
+        unavailable(__method__)
+      end
+
+      #: (String) -> String
+      def check(_options_json)
+        unavailable(__method__)
+      end
+
+      #: (String) -> untyped
+      def session_new(_cwd)
+        unavailable(__method__)
+      end
+
+      #: (untyped, String) -> String
+      def session_check(_handle, _options_json)
+        unavailable(__method__)
+      end
+
+      #: (untyped) -> nil
+      def session_close(_handle)
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def panic_for_test
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def version
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def tsrs_version
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def typescript_version
+        unavailable(__method__)
+      end
+
+      private
+
+      #: (Symbol?) -> bot
+      def unavailable(name)
+        raise NotImplementedError, "Tsrs::Backend.#{name} is defined by the native extension, which did not load"
+      end
+    end
+
+    extend Unavailable
+  end
+end

data/lib/tsrs/check_result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Tsrs
+  class CheckResult
+    include Diagnosed
+
+    attr_reader :status #: Integer
+    attr_reader :exit_status #: Symbol
+    attr_reader :diagnostics #: Array[Tsrs::Diagnostic]
+    attr_reader :output #: String
+
+    #: (String) -> Tsrs::CheckResult
+    def self.from_json(payload)
+      data = JSON.parse(payload)
+      status = data.fetch("status")
+
+      new(
+        status: status.fetch("code"),
+        exit_status: status.fetch("name").to_sym,
+        output: data.fetch("output", ""),
+        diagnostics: data.fetch("diagnostics").map { |diagnostic| Diagnostic.from_hash(diagnostic) }
+      )
+    end
+
+    #: (status: Integer, exit_status: Symbol, ?output: String, ?diagnostics: Array[Tsrs::Diagnostic]) -> void
+    def initialize(status:, exit_status:, output: "", diagnostics: [])
+      @status = status
+      @exit_status = exit_status
+      @output = output.freeze
+      @diagnostics = diagnostics.freeze
+
+      freeze
+    end
+
+    #: () -> bool
+    def success?
+      status.zero?
+    end
+
+    #: (?strict: bool) -> self
+    def validate!(strict: false)
+      return self if success? && (!strict || diagnostics.empty?)
+
+      raise TypeError, diagnostics unless diagnostics.empty?
+
+      raise Error, (output.empty? ? "tsc exited with status #{status} (#{exit_status})" : output.strip)
+    end
+
+    #: () -> String
+    def to_s
+      diagnostics.join("\n")
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} status=#{status} errors=#{errors.length} diagnostics=#{diagnostics.length}>"
+    end
+  end
+end

data/lib/tsrs/diagnosed.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Tsrs
+  # @rbs module-self _Diagnosed
+  module Diagnosed
+    #: () -> Array[Tsrs::Diagnostic]
+    def errors
+      diagnostics.select(&:error?)
+    end
+
+    #: () -> Array[Tsrs::Diagnostic]
+    def warnings
+      diagnostics.select(&:warning?)
+    end
+
+    #: () -> bool
+    def errors?
+      diagnostics.any?(&:error?)
+    end
+  end
+end

data/lib/tsrs/diagnostic.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Tsrs
+  # Lines and columns are 1-based. `start` and `finish` are offsets in UTF-16 code units, as TypeScript counts.
+  #
+  class Diagnostic
+    CATEGORIES = [:warning, :error, :suggestion, :message].freeze #: Array[Symbol]
+
+    attr_reader :code #: Integer
+    attr_reader :category #: Symbol
+    attr_reader :message #: String
+    attr_reader :file #: String?
+    attr_reader :line #: Integer?
+    attr_reader :column #: Integer?
+    attr_reader :end_line #: Integer?
+    attr_reader :end_column #: Integer?
+    attr_reader :start #: Integer?
+    attr_reader :finish #: Integer?
+    attr_reader :source #: String?
+    attr_reader :message_chain #: Array[Tsrs::Diagnostic]
+    attr_reader :related_information #: Array[Tsrs::Diagnostic]
+
+    #: (Hash[String, untyped]) -> Tsrs::Diagnostic
+    def self.from_hash(hash)
+      start_position = hash["startPosition"]
+      end_position = hash["endPosition"]
+
+      new(
+        code: hash.fetch("code"),
+        category: CATEGORIES.fetch(hash.fetch("category"), :message),
+        message: hash.fetch("text"),
+        file: hash["fileName"],
+        line: start_position && (start_position.fetch("line") + 1),
+        column: start_position && (start_position.fetch("character") + 1),
+        end_line: end_position && (end_position.fetch("line") + 1),
+        end_column: end_position && (end_position.fetch("character") + 1),
+        start: offset(hash["pos"]),
+        finish: offset(hash["end"]),
+        source: hash["source"],
+        message_chain: (hash["messageChain"] || []).map { |link| from_hash(link) },
+        related_information: (hash["relatedInformation"] || []).map { |related| from_hash(related) }
+      )
+    end
+
+    #: (untyped) -> Integer?
+    def self.offset(value)
+      value.is_a?(Integer) && value >= 0 ? value : nil
+    end
+
+    #: (code: Integer, category: Symbol, message: String, ?file: String?, ?line: Integer?, ?column: Integer?, ?end_line: Integer?, ?end_column: Integer?, ?start: Integer?, ?finish: Integer?, ?source: String?, ?message_chain: Array[Tsrs::Diagnostic], ?related_information: Array[Tsrs::Diagnostic]) -> void
+    def initialize(code:, category:, message:, file: nil, line: nil, column: nil, end_line: nil, end_column: nil, start: nil, finish: nil, source: nil, message_chain: [], related_information: [])
+      @code = code
+      @category = category
+      @message = message.freeze
+      @file = file&.freeze
+      @line = line
+      @column = column
+      @end_line = end_line
+      @end_column = end_column
+      @start = start
+      @finish = finish
+      @source = source&.freeze
+      @message_chain = message_chain.freeze
+      @related_information = related_information.freeze
+
+      freeze
+    end
+
+    #: () -> bool
+    def error?
+      category == :error
+    end
+
+    #: () -> bool
+    def warning?
+      category == :warning
+    end
+
+    #: () -> String
+    def location
+      return "" unless file
+
+      line ? "#{file}:#{line}:#{column}" : file.to_s
+    end
+
+    #: () -> String
+    def full_message
+      ([message] + chain_lines(message_chain, 1)).join("\n")
+    end
+
+    #: () -> String
+    def to_s
+      prefix = "#{category} TS#{code}: #{full_message}"
+
+      file ? "#{location} - #{prefix}" : prefix
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{category} TS#{code} #{"#{location} " unless location.empty?}#{message.inspect}>"
+    end
+
+    private
+
+    #: (Array[Tsrs::Diagnostic], Integer) -> Array[String]
+    def chain_lines(chain, depth)
+      chain.flat_map do |link|
+        ["#{"  " * depth}#{link.message}"] + chain_lines(link.message_chain, depth + 1)
+      end
+    end
+  end
+end

data/lib/tsrs/errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Tsrs
+  class Error < StandardError; end
+  class OptionError < Error; end
+  class EncodingError < Error; end
+  class TranspileError < Error; end
+  class InternalError < Error; end
+  class PanicError < InternalError; end
+  class CheckError < Error; end
+
+  class DiagnosticError < Error
+    attr_reader :diagnostics #: Array[Tsrs::Diagnostic]
+
+    #: (Array[Tsrs::Diagnostic]) -> void
+    def initialize(diagnostics)
+      @diagnostics = diagnostics
+
+      super(diagnostics.join("\n"))
+    end
+  end
+
+  class SyntaxError < DiagnosticError; end
+  class TypeError < DiagnosticError; end
+end

data/lib/tsrs/options.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Tsrs
+  module Options
+    REFUSED = {
+      "build" => "build mode is not supported",
+      "watch" => "watch mode is not supported",
+      "init" => "--init is not supported by tsrs",
+      "showConfig" => "--showConfig is not supported by tsrs",
+      "help" => "--help prints to the terminal, it is not an option for a call",
+      "all" => "--all prints to the terminal, it is not an option for a call",
+      "version" => "--version prints to the terminal, use Tsrs.typescript_version instead",
+    }.freeze #: Hash[String, String]
+
+    #: (Hash[Symbol | String, untyped]) -> Array[String]
+    def self.arguments(options)
+      options.each_with_object([]) do |(key, value), arguments|
+        next if value.nil?
+
+        name = option_name(key)
+
+        refuse!(name)
+
+        arguments.push(*flag(name, value))
+      end
+    end
+
+    #: (Symbol | String) -> String
+    def self.option_name(key)
+      name = key.to_s.delete_prefix("--")
+
+      return name unless key.is_a?(Symbol)
+
+      name.gsub(/_([a-z0-9])/) { ::Regexp.last_match(1).to_s.upcase }
+    end
+
+    #: (String) -> void
+    def self.refuse!(name)
+      reason = REFUSED[name]
+
+      raise OptionError, "#{name}: #{reason}" if reason
+    end
+
+    #: (String, untyped) -> Array[String]
+    def self.flag(name, value)
+      case value
+      when true
+        ["--#{name}"]
+      when false
+        ["--#{name}", "false"]
+      when Array
+        ["--#{name}", value.join(",")]
+      when Hash
+        raise OptionError, "#{name} takes a #{value.class}, which tsc's command line has no way to say"
+      else
+        ["--#{name}", value.to_s]
+      end
+    end
+
+    private_class_method :refuse!, :flag
+  end
+end

data/lib/tsrs/session.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Tsrs
+  # Unlike Tsrs.check, a session gives a check's memory back. Compiler options come from the tsconfig.json only.
+  #
+  class Session
+    attr_reader :cwd #: String
+
+    #: [T] (?cwd: String) { (Tsrs::Session) -> T } -> T
+    def self.open(cwd: Dir.pwd)
+      session = new(cwd: cwd)
+
+      begin
+        yield session
+      ensure
+        session.close
+      end
+    end
+
+    #: (?cwd: String) -> void
+    def initialize(cwd: Dir.pwd)
+      @cwd = File.expand_path(cwd.to_s)
+      @handle = Backend.session_new(@cwd)
+      @closed = false
+    end
+
+    #: (?String) -> Tsrs::CheckResult
+    def check(project = "tsconfig.json")
+      raise Error, "the session is closed" if closed?
+
+      request = JSON.generate({ project: File.expand_path(project.to_s, cwd) })
+
+      CheckResult.from_json(Backend.session_check(@handle, request))
+    end
+
+    #: () -> void
+    def close
+      return if closed?
+
+      @closed = true
+
+      Backend.session_close(@handle)
+    end
+
+    #: () -> bool
+    def closed?
+      @closed
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} cwd=#{cwd.inspect}#{" closed" if closed?}>"
+    end
+  end
+end