oxc 0.1.0-x86_64-linux-gnu

data/ext/oxc/oxc.c

@@ -0,0 +1,136 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/thread.h>
+#include "include/oxc.h"
+
+static VALUE rb_mOxc;
+static VALUE rb_mBackend;
+static VALUE rb_eError;
+static VALUE rb_eOptionError;
+static VALUE rb_eOxcEncodingError;
+static VALUE rb_eTransformError;
+static VALUE rb_eInternalError;
+static VALUE rb_ePanicError;
+
+typedef struct OxcResult (*oxc_function)(const char *, const char *);
+
+struct call_arguments {
+  oxc_function function;
+  const char *source;
+  const char *options;
+  struct OxcResult 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);
+  oxc_string_free(cstring);
+
+  return string;
+}
+
+static VALUE error_class_for(enum OxcErrorCode code) {
+  switch (code) {
+    case OXC_ERROR_CODE_OPTION: return rb_eOptionError;
+    case OXC_ERROR_CODE_ENCODING: return rb_eOxcEncodingError;
+    case OXC_ERROR_CODE_TRANSFORM: return rb_eTransformError;
+    case OXC_ERROR_CODE_PANIC: return rb_ePanicError;
+    default: return rb_eInternalError;
+  }
+}
+
+static VALUE unwrap(struct OxcResult result) {
+  if (result.error) {
+    VALUE message = make_utf8_string(result.error);
+    VALUE error_class = error_class_for(result.code);
+
+    oxc_result_free(result);
+
+    rb_raise(error_class, "%s", StringValueCStr(message));
+  }
+
+  if (!result.value) {
+    oxc_result_free(result);
+
+    rb_raise(rb_eInternalError, "oxc returned no result");
+  }
+
+  VALUE value = rb_enc_str_new(result.value, (long) result.value_len, rb_utf8_encoding());
+
+  oxc_result_free(result);
+
+  return value;
+}
+
+static void *without_gvl(void *data) {
+  struct call_arguments *arguments = (struct call_arguments *) data;
+
+  arguments->result = arguments->function(arguments->source, arguments->options);
+
+  return NULL;
+}
+
+static VALUE call(oxc_function function, VALUE source, VALUE options) {
+  struct call_arguments arguments;
+
+  arguments.function = function;
+  arguments.source = StringValueCStr(source);
+  arguments.options = StringValueCStr(options);
+
+  rb_thread_call_without_gvl(without_gvl, &arguments, NULL, NULL);
+
+  return unwrap(arguments.result);
+}
+
+static VALUE rb_minify(VALUE self, VALUE source, VALUE options) {
+  (void) self;
+
+  return call(oxc_minify, source, options);
+}
+
+static VALUE rb_transform(VALUE self, VALUE source, VALUE options) {
+  (void) self;
+
+  return call(oxc_transform, source, options);
+}
+
+static VALUE rb_parse(VALUE self, VALUE source, VALUE options) {
+  (void) self;
+
+  return call(oxc_parse, source, options);
+}
+
+static VALUE rb_native_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(oxc_version());
+}
+
+static VALUE rb_oxc_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(oxc_oxc_version());
+}
+
+void Init_oxc(void) {
+  rb_mOxc = rb_define_module("Oxc");
+  rb_mBackend = rb_define_module_under(rb_mOxc, "Backend");
+
+  rb_eError = rb_define_class_under(rb_mOxc, "Error", rb_eStandardError);
+  rb_eOptionError = rb_define_class_under(rb_mOxc, "OptionError", rb_eError);
+  rb_eOxcEncodingError = rb_define_class_under(rb_mOxc, "EncodingError", rb_eError);
+  rb_eTransformError = rb_define_class_under(rb_mOxc, "TransformError", rb_eError);
+  rb_eInternalError = rb_define_class_under(rb_mOxc, "InternalError", rb_eError);
+  rb_ePanicError = rb_define_class_under(rb_mOxc, "PanicError", rb_eInternalError);
+
+  rb_define_singleton_method(rb_mBackend, "minify", rb_minify, 2);
+  rb_define_singleton_method(rb_mBackend, "transform", rb_transform, 2);
+  rb_define_singleton_method(rb_mBackend, "parse", rb_parse, 2);
+  rb_define_singleton_method(rb_mBackend, "version", rb_native_version, 0);
+  rb_define_singleton_method(rb_mBackend, "oxc_version", rb_oxc_version, 0);
+}

data/lib/oxc/backend.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Oxc
+  module Backend
+    module Unavailable
+      #: (String, String) -> String
+      def minify(_source, _options_json)
+        unavailable(__method__)
+      end
+
+      #: (String, String) -> String
+      def transform(_source, _options_json)
+        unavailable(__method__)
+      end
+
+      #: (String, String) -> String
+      def parse(_source, _options_json)
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def version
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def oxc_version
+        unavailable(__method__)
+      end
+
+      private
+
+      #: (Symbol?) -> bot
+      def unavailable(name)
+        raise NotImplementedError, "Oxc::Backend.#{name} is defined by the native extension, which did not load"
+      end
+    end
+
+    extend Unavailable
+  end
+end

data/lib/oxc/diagnosed.rb

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

data/lib/oxc/diagnostic.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Diagnostic
+    ERROR = "error" #: String
+    WARNING = "warning" #: String
+
+    attr_reader :severity #: String
+    attr_reader :message #: String
+    attr_reader :labels #: Array[Oxc::Label]
+    attr_reader :help #: String?
+    attr_reader :codeframe #: String?
+
+    #: (Hash[String, untyped]) -> Oxc::Diagnostic
+    def self.from_hash(parsed)
+      new(
+        severity: parsed.fetch("severity"),
+        message: parsed.fetch("message"),
+        labels: parsed.fetch("labels").map { |label| Label.from_hash(label) },
+        help: parsed["help"],
+        codeframe: parsed["codeframe"]
+      )
+    end
+
+    #: (severity: String, message: String, labels: Array[Oxc::Label], ?help: String?, ?codeframe: String?) -> void
+    def initialize(severity:, message:, labels:, help: nil, codeframe: nil)
+      @severity = severity
+      @message = message
+      @labels = labels.freeze
+      @help = help
+      @codeframe = codeframe
+
+      freeze
+    end
+
+    #: () -> bool
+    def error?
+      severity == ERROR
+    end
+
+    #: () -> bool
+    def warning?
+      severity == WARNING
+    end
+
+    #: () -> String
+    def to_s
+      message
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{severity} #{message.inspect}>"
+    end
+  end
+
+  class Label
+    attr_reader :message #: String?
+    attr_reader :start #: Integer
+    attr_reader :finish #: Integer
+
+    #: (Hash[String, untyped]) -> Oxc::Label
+    def self.from_hash(parsed)
+      new(message: parsed["message"], start: parsed.fetch("start"), finish: parsed.fetch("end"))
+    end
+
+    #: (start: Integer, finish: Integer, ?message: String?) -> void
+    def initialize(start:, finish:, message: nil)
+      @start = start
+      @finish = finish
+      @message = message
+
+      freeze
+    end
+
+    #: (String) -> String?
+    def slice(source)
+      source.byteslice(start, finish - start)
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{start}..#{finish}#{" #{message.inspect}" if message}>"
+    end
+  end
+end

data/lib/oxc/errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Error < StandardError; end
+  class OptionError < Error; end
+  class EncodingError < Error; end
+  class TransformError < Error; end
+  class InternalError < Error; end
+  class PanicError < InternalError; end
+
+  class SyntaxError < Error
+    attr_reader :result #: (Oxc::Result | Oxc::ParseResult)?
+
+    #: (String, ?(Oxc::Result | Oxc::ParseResult)?) -> void
+    def initialize(message, result = nil)
+      super(message)
+
+      @result = result
+    end
+
+    #: () -> Array[Oxc::Diagnostic]
+    def diagnostics
+      result ? result.diagnostics : []
+    end
+  end
+end

data/lib/oxc/minifier.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Minifier
+    attr_reader :options #: Hash[Symbol, untyped]
+
+    #: (?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> void
+    def initialize(**options)
+      @options = options.transform_keys(&:to_sym).freeze
+
+      freeze
+    end
+
+    #: (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::MinifyResult
+    def minify(source, **overrides)
+      Oxc.minify(source, **options, **overrides)
+    end
+
+    alias call minify
+
+    #: (?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::Minifier
+    def with(**overrides)
+      self.class.new(**options, **overrides)
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{options.inspect}>"
+    end
+  end
+end

data/lib/oxc/minify_result.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Oxc
+  class MinifyResult < Result
+    #: (String) -> Oxc::MinifyResult
+    def self.from_json(payload)
+      parsed = JSON.parse(payload)
+
+      new(
+        code: parsed.fetch("code"),
+        map: parsed["map"],
+        legal_comments: parsed.fetch("legal_comments"),
+        diagnostics: parsed.fetch("errors").map { |diagnostic| Diagnostic.from_hash(diagnostic) },
+        panicked: parsed.fetch("panicked")
+      )
+    end
+
+    #: (code: String, diagnostics: Array[Oxc::Diagnostic], ?map: String?, ?legal_comments: Array[String], ?panicked: bool) -> void
+    def initialize(...)
+      super
+
+      freeze
+    end
+  end
+end

data/lib/oxc/options.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Options
+    MINIFY = [
+      :filename,
+      :lang,
+      :source_type,
+      :compress,
+      :mangle,
+      :codegen,
+      :sourcemap,
+      :strict
+    ].freeze #: Array[Symbol]
+
+    TRANSFORM = [
+      :filename,
+      :lang,
+      :source_type,
+      :cwd,
+      :target,
+      :jsx,
+      :typescript,
+      :assumptions,
+      :decorator,
+      :helpers,
+      :define,
+      :inject,
+      :minify,
+      :codegen,
+      :sourcemap,
+      :strict
+    ].freeze #: Array[Symbol]
+
+    PARSE = [
+      :filename,
+      :lang,
+      :source_type,
+      :ast_type,
+      :ast,
+      :ranges,
+      :preserve_parens,
+      :comments,
+      :module_record,
+      :symbols,
+      :semantic_errors
+    ].freeze #: Array[Symbol]
+
+    KNOWN = (MINIFY | TRANSFORM | PARSE).freeze #: Array[Symbol]
+    RUBY_ONLY = [:strict].freeze #: Array[Symbol]
+
+    # TODO: support mangle_props. It needs `lazy-regex` and `rustc-hash` as direct dependencies of the
+    # Rust crate, because `oxc_minifier::ManglePropertiesOptions` types `include` and `exclude` as
+    # `lazy_regex::Regex` and `reserved` as `FxHashSet<CompactStr>`.
+    UNSUPPORTED = [:mangle_props].freeze #: Array[Symbol]
+
+    attr_reader :to_h #: Hash[Symbol, untyped]
+
+    #: (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> String
+    def self.serialize(options, allowed = KNOWN, subject = "a call")
+      new(options, allowed, subject).to_json
+    end
+
+    #: (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> void
+    def initialize(options, allowed = KNOWN, subject = "a call")
+      given = options.transform_keys(&:to_sym)
+
+      validate!(given.keys, allowed, subject)
+
+      @to_h = normalize(given).freeze
+
+      freeze
+    end
+
+    #: (?untyped) -> String
+    def to_json(state = nil)
+      JSON.generate(to_h, state)
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{to_h.inspect}>"
+    end
+
+    private
+
+    #: (Array[Symbol], Array[Symbol], String) -> void
+    def validate!(names, allowed, subject)
+      unsupported = names & UNSUPPORTED
+
+      raise OptionError, "#{unsupported.join(", ")} is not supported yet" if unsupported.any?
+
+      unknown = names - KNOWN
+
+      raise OptionError, "Unknown option#{"s" if unknown.length > 1}: #{unknown.join(", ")}" if unknown.any?
+
+      unsupported = names - allowed
+
+      return if unsupported.empty?
+
+      raise OptionError, "#{unsupported.join(", ")} #{unsupported.one? ? "is not an option" : "are not options"} for #{subject}"
+    end
+
+    #: (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+    def normalize(options)
+      normalized = options.dup
+
+      RUBY_ONLY.each { |name| normalized.delete(name) }
+
+      normalized.compact
+    end
+  end
+end

data/lib/oxc/parse_result.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Oxc
+  class ParseResult
+    include Diagnosed
+
+    attr_reader :program #: Hash[String, untyped]?
+    attr_reader :module_record #: Hash[String, untyped]?
+    attr_reader :symbols #: Hash[String, untyped]?
+    attr_reader :comments #: Array[Oxc::Comment]
+    attr_reader :diagnostics #: Array[Oxc::Diagnostic]
+
+    #: (String) -> Oxc::ParseResult
+    def self.from_json(payload)
+      parsed = JSON.parse(payload)
+
+      new(
+        program: parsed["program"],
+        module_record: parsed["module_record"],
+        symbols: parsed["symbols"],
+        comments: parsed.fetch("comments").map { |comment| Comment.from_hash(comment) },
+        diagnostics: parsed.fetch("errors").map { |diagnostic| Diagnostic.from_hash(diagnostic) },
+        panicked: parsed.fetch("panicked")
+      )
+    end
+
+    #: (comments: Array[Oxc::Comment], diagnostics: Array[Oxc::Diagnostic], ?program: Hash[String, untyped]?, ?module_record: Hash[String, untyped]?, ?symbols: Hash[String, untyped]?, ?panicked: bool) -> void
+    def initialize(comments:, diagnostics:, program: nil, module_record: nil, symbols: nil, panicked: false)
+      @program = program.freeze
+      @module_record = module_record.freeze
+      @symbols = symbols.freeze
+      @comments = comments.freeze
+      @diagnostics = diagnostics.freeze
+      @panicked = panicked
+
+      freeze
+    end
+
+    #: () -> Oxc::ParseResult
+    def validate!
+      return self unless errors? || panicked?
+
+      raise SyntaxError.new(errors.first&.message || "oxc could not read the source", self)
+    end
+
+    #: () -> String
+    def inspect
+      parts = [] #: Array[String]
+      parts << "program=#{program["type"]}" if program
+      parts << "comments=#{comments.length}" unless comments.empty?
+      parts << "diagnostics=#{diagnostics.length}" unless diagnostics.empty?
+
+      "#<#{self.class.name}#{" #{parts.join(" ")}" unless parts.empty?}>"
+    end
+  end
+
+  class Comment
+    LINE = "Line" #: String
+    BLOCK = "Block" #: String
+
+    attr_reader :type #: String
+    attr_reader :value #: String
+    attr_reader :start #: Integer
+    attr_reader :finish #: Integer
+
+    #: (Hash[String, untyped]) -> Oxc::Comment
+    def self.from_hash(parsed)
+      new(
+        type: parsed.fetch("type"),
+        value: parsed.fetch("value"),
+        start: parsed.fetch("start"),
+        finish: parsed.fetch("end")
+      )
+    end
+
+    #: (type: String, value: String, start: Integer, finish: Integer) -> void
+    def initialize(type:, value:, start:, finish:)
+      @type = type
+      @value = value
+      @start = start
+      @finish = finish
+
+      freeze
+    end
+
+    #: () -> bool
+    def line?
+      type == LINE
+    end
+
+    #: () -> bool
+    def block?
+      type == BLOCK
+    end
+
+    #: (String) -> String?
+    def slice(source)
+      source.byteslice(start, finish - start)
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{type} #{value.inspect}>"
+    end
+  end
+end

data/lib/oxc/result.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Result
+    include Diagnosed
+
+    attr_reader :code #: String
+    attr_reader :map #: String?
+    attr_reader :legal_comments #: Array[String]
+    attr_reader :diagnostics #: Array[Oxc::Diagnostic]
+
+    #: (code: String, diagnostics: Array[Oxc::Diagnostic], ?map: String?, ?legal_comments: Array[String], ?panicked: bool) -> void
+    def initialize(code:, diagnostics:, map: nil, legal_comments: [], panicked: false)
+      @code = code
+      @map = map
+      @legal_comments = legal_comments.freeze
+      @diagnostics = diagnostics.freeze
+      @panicked = panicked
+    end
+
+    #: (?strict: untyped) -> self
+    def validate!(strict: false)
+      return self unless errors? || panicked?
+      return self unless strict || panicked? || code.empty?
+
+      raise SyntaxError.new(errors.first&.message || "oxc could not read the source", self)
+    end
+
+    #: () -> String
+    def to_s
+      code
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{parts.join(" ")}>"
+    end
+
+    private
+
+    #: () -> Array[String]
+    def parts
+      parts = ["code=#{code.inspect}"] #: Array[String]
+      parts << "map=#{map.length} bytes" if map
+      parts << "legal_comments=#{legal_comments.inspect}" unless legal_comments.empty?
+      parts << "diagnostics=#{diagnostics.length}" unless diagnostics.empty?
+
+      parts
+    end
+  end
+end