oxc 0.0.1 → 0.2.0

data/lib/oxc/node.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Node
+    include Enumerable #[Oxc::Node]
+
+    ACRONYM = /([A-Z]+)([A-Z][a-z])/ #: Regexp
+    BOUNDARY = /([a-z\d])([A-Z])/ #: Regexp
+    SPAN = ["type", "start", "end"].freeze #: Array[String]
+
+    attr_reader :parent #: Oxc::Node?
+
+    protected
+
+    attr_reader :attributes #: Hash[String, untyped]
+    attr_reader :text #: String?
+
+    public
+
+    #: (Hash[String, untyped], ?Oxc::Node?, ?String?) -> void
+    def initialize(attributes, parent = nil, text = nil)
+      @attributes = attributes
+      @parent = parent
+      @text = text || parent&.text
+    end
+
+    #: () -> String
+    def type
+      attributes.fetch("type")
+    end
+
+    #: () -> Integer
+    def start
+      attributes.fetch("start")
+    end
+
+    #: () -> Integer
+    def finish
+      attributes.fetch("end")
+    end
+
+    #: () -> String
+    def underscored_type
+      @underscored_type ||= type.gsub(ACRONYM, '\1_\2').gsub(BOUNDARY, '\1_\2').downcase
+    end
+
+    #: (String) -> untyped
+    def [](key)
+      attributes[key]
+    end
+
+    #: (?String?) -> String?
+    def slice(from = text)
+      raise ArgumentError, "this node does not know its source, so #slice needs it" unless from
+
+      from.byteslice(start, finish - start)
+    end
+
+    #: () -> Array[String]
+    def keys
+      attributes.keys
+    end
+
+    #: () -> Hash[String, untyped]
+    def to_h
+      attributes
+    end
+
+    #: (?untyped) -> String
+    def to_json(state = nil)
+      state ? attributes.to_json(state) : attributes.to_json
+    end
+
+    #: (Array[Symbol]?) -> Hash[Symbol, untyped]
+    def deconstruct_keys(keys)
+      found = {} #: Hash[Symbol, untyped]
+
+      if keys
+        keys.each do |name|
+          key = field_for(name.to_s)
+
+          found[name] = wrap(attributes[key]) if key
+        end
+      else
+        attributes.each_key { |key| found[key.to_sym] = wrap(attributes[key]) }
+      end
+
+      found
+    end
+
+    #: () -> Array[Oxc::Node]
+    def child_nodes
+      @child_nodes ||= attributes.each_value
+                                 .flat_map { |value| value.is_a?(Array) ? value : [value] }
+                                 .select { |value| value.is_a?(Hash) && value.key?("type") }
+                                 .map { |value| Node.new(value, self) }
+                                 .freeze
+    end
+
+    #: () { (Oxc::Node) -> void } -> void
+    #: () -> Enumerator[Oxc::Node, void]
+    def each(&)
+      return enum_for(:each) unless block_given?
+
+      yield self
+
+      child_nodes.each { |child| child.each(&) }
+    end
+
+    #: () -> Array[Oxc::Node]
+    def ancestors
+      parent ? [parent, *parent.ancestors] : []
+    end
+
+    #: (Integer) -> Oxc::Node?
+    def at(offset)
+      covering = each.select { |node| offset >= node.start && offset < node.finish }
+
+      covering.min_by { |node| node.finish - node.start }
+    end
+
+    #: (String) -> Array[Oxc::Node]
+    def every(type)
+      each.select { |node| node.type == type }
+    end
+
+    #: () -> Hash[String, untyped]
+    def fields
+      attributes.except(*SPAN)
+    end
+
+    #: () -> String
+    def inspect
+      described = fields.map { |key, value| described_field(key, value) }
+
+      "#<#{self.class.name} #{type} range=[#{start}, #{finish}]#{" #{described.join(" ")}" unless described.empty?}>"
+    end
+
+    #: (Symbol, *untyped) -> untyped
+    def method_missing(name, *arguments)
+      key = field_for(name.to_s)
+
+      return super unless key
+
+      wrap(attributes[key])
+    end
+
+    #: (Symbol, ?bool) -> bool
+    def respond_to_missing?(name, include_private = false)
+      !field_for(name.to_s).nil? || super
+    end
+
+    private
+
+    #: (String, untyped) -> String
+    def described_field(key, value)
+      case value
+      when Array then "#{key}=#{if value.empty?
+                                  "[]"
+                                else
+                                  "[... #{value.length} #{value.length == 1 ? "item" : "items"}]"
+                                end}"
+      when Hash then "#{key}=#<#{self.class.name} #{value["type"]}>"
+      else "#{key}=#{value.inspect}"
+      end
+    end
+
+    #: (String) -> String?
+    def field_for(name)
+      return name if attributes.key?(name)
+
+      camelized = name.gsub(/_([a-z\d])/) { Regexp.last_match(1).to_s.upcase }
+
+      camelized if attributes.key?(camelized)
+    end
+
+    #: (untyped) -> untyped
+    def wrap(value)
+      case value
+      when Hash then value.key?("type") ? Node.new(value, self, text) : value
+      when Array then value.map { |item| wrap(item) }
+      else value
+      end
+    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
+
+    #: (?JSON::options?) -> String
+    def to_json(state = nil)
+      state ? JSON.generate(to_h, state) : JSON.generate(to_h)
+    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,116 @@
+# frozen_string_literal: true
+
+module Oxc
+  class ParseResult
+    include Diagnosed
+
+    attr_reader :source #: String?
+    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, ?String?) -> Oxc::ParseResult
+    def self.from_json(payload, source = nil)
+      parsed = JSON.parse(payload)
+
+      new(
+        source: source,
+        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], ?source: String?, ?program: Hash[String, untyped]?, ?module_record: Hash[String, untyped]?, ?symbols: Hash[String, untyped]?, ?panicked: bool) -> void
+    def initialize(comments:, diagnostics:, source: nil, program: nil, module_record: nil, symbols: nil, panicked: false)
+      @source = source
+      @program = program.freeze
+      @module_record = module_record.freeze
+      @symbols = symbols.freeze
+      @comments = comments.freeze
+      @diagnostics = diagnostics.freeze
+      @panicked = panicked
+
+      freeze
+    end
+
+    #: () -> Oxc::Node?
+    def root
+      program ? Node.new(program, nil, source) : nil
+    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 << "#{root&.type} range=[#{root&.start}, #{root&.finish}]" if program
+      parts << "module_record" if module_record
+      parts << "symbols=#{symbols.fetch("declared").length}" if symbols
+      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: bool?) -> 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

data/lib/oxc/transform_result.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Oxc
+  class TransformResult < Result
+    attr_reader :declaration #: String?
+    attr_reader :declaration_map #: String?
+    attr_reader :helpers_used #: Hash[String, String]
+
+    #: (String) -> Oxc::TransformResult
+    def self.from_json(payload)
+      parsed = JSON.parse(payload)
+
+      new(
+        code: parsed.fetch("code"),
+        map: parsed["map"],
+        declaration: parsed["declaration"],
+        declaration_map: parsed["declaration_map"],
+        legal_comments: parsed.fetch("legal_comments"),
+        helpers_used: parsed.fetch("helpers_used"),
+        diagnostics: parsed.fetch("errors").map { |diagnostic| Diagnostic.from_hash(diagnostic) },
+        panicked: parsed.fetch("panicked")
+      )
+    end
+
+    #: (code: String, diagnostics: Array[Oxc::Diagnostic], ?map: String?, ?declaration: String?, ?declaration_map: String?, ?legal_comments: Array[String], ?helpers_used: Hash[String, String], ?panicked: bool) -> void
+    def initialize(declaration: nil, declaration_map: nil, helpers_used: {}, **)
+      super(**)
+
+      @declaration = declaration
+      @declaration_map = declaration_map
+      @helpers_used = helpers_used.freeze
+
+      freeze
+    end
+
+    private
+
+    #: () -> Array[String]
+    def parts
+      parts = super
+      parts << "declaration=#{declaration.length} bytes" if declaration
+      parts << "helpers_used=#{helpers_used.length}" unless helpers_used.empty?
+
+      parts
+    end
+  end
+end

data/lib/oxc/transformer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Transformer
+    attr_reader :options #: Hash[Symbol, untyped]
+
+    #: (?filename: String?, ?lang: String?, ?source_type: String?, ?cwd: String?, ?target: targets?, ?jsx: jsx?, ?typescript: typescript?, ?assumptions: assumptions?, ?decorator: decorator?, ?helpers: helpers?, ?define: Hash[String, String]?, ?inject: inject?, ?minify: minify?, ?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?, ?cwd: String?, ?target: targets?, ?jsx: jsx?, ?typescript: typescript?, ?assumptions: assumptions?, ?decorator: decorator?, ?helpers: helpers?, ?define: Hash[String, String]?, ?inject: inject?, ?minify: minify?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::TransformResult
+    def transform(source, **overrides)
+      Oxc.transform(source, **options, **overrides)
+    end
+
+    alias call transform
+
+    #: (?filename: String?, ?lang: String?, ?source_type: String?, ?cwd: String?, ?target: targets?, ?jsx: jsx?, ?typescript: typescript?, ?assumptions: assumptions?, ?decorator: decorator?, ?helpers: helpers?, ?define: Hash[String, String]?, ?inject: inject?, ?minify: minify?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::Transformer
+    def with(**overrides)
+      self.class.new(**options, **overrides)
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{options.inspect}>"
+    end
+  end
+end

data/lib/oxc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Oxc
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
 end

data/lib/oxc/visitor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Visitor
+    #: (Oxc::Node | Oxc::ParseResult) -> void
+    def visit(node)
+      node = node.root if node.is_a?(ParseResult)
+
+      return nil unless node
+
+      answer = "visit_#{node.underscored_type}"
+
+      respond_to?(answer) ? public_send(answer, node) : visit_children(node)
+
+      nil
+    end
+
+    #: (Oxc::Node) -> void
+    def visit_children(node)
+      node.child_nodes.each { |child| visit(child) }
+
+      nil
+    end
+  end
+end

data/lib/oxc.rb

@@ -1,6 +1,55 @@
 # frozen_string_literal: true
 
+require "json"
+
 require_relative "oxc/version"
+require_relative "oxc/errors"
+require_relative "oxc/backend"
+
+begin
+  major, minor, = RUBY_VERSION.split(".")
+  require_relative "oxc/#{major}.#{minor}/oxc"
+rescue LoadError
+  require_relative "oxc/oxc"
+end
+
+require_relative "oxc/options"
+require_relative "oxc/diagnostic"
+require_relative "oxc/diagnosed"
+require_relative "oxc/result"
+require_relative "oxc/minify_result"
+require_relative "oxc/transform_result"
+require_relative "oxc/node"
+require_relative "oxc/visitor"
+require_relative "oxc/mutation_visitor"
+require_relative "oxc/parse_result"
+require_relative "oxc/transformer"
+require_relative "oxc/minifier"
 
 module Oxc
+  #: (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::MinifyResult
+  def self.minify(source, **options)
+    serialized = Options.serialize(options, Options::MINIFY, "minify")
+
+    MinifyResult.from_json(Backend.minify(source.to_s, serialized)).validate!(strict: options[:strict] ? true : false)
+  end
+
+  #: (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?cwd: String?, ?target: targets?, ?jsx: jsx?, ?typescript: typescript?, ?assumptions: assumptions?, ?decorator: decorator?, ?helpers: helpers?, ?define: Hash[String, String]?, ?inject: inject?, ?minify: minify?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::TransformResult
+  def self.transform(source, **options)
+    serialized = Options.serialize(options, Options::TRANSFORM, "transform")
+
+    TransformResult.from_json(Backend.transform(source.to_s, serialized)).validate!(strict: options[:strict] ? true : false)
+  end
+
+  #: (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?ast_type: String?, ?ast: bool, ?ranges: bool, ?preserve_parens: bool, ?comments: bool, ?module_record: bool, ?symbols: bool, ?semantic_errors: bool) -> Oxc::ParseResult
+  def self.parse(source, **options)
+    serialized = Options.serialize(options, Options::PARSE, "parse")
+
+    ParseResult.from_json(Backend.parse(source.to_s, serialized), source.to_s)
+  end
+
+  #: () -> String
+  def self.oxc_version
+    Backend.oxc_version
+  end
 end

data/licenses/README.md

@@ -0,0 +1,12 @@
+# Licenses of what this gem builds against
+
+A precompiled gem ships a native extension with [Oxc](https://github.com/oxc-project/oxc) compiled into it, so the terms that cover Oxc cover part of what is being distributed.
+
+They are carried here so that whoever received the gem has them in hand.
+
+| File                  | Covers                                                  | License    |
+|-----------------------|---------------------------------------------------------|------------|
+| `oxc-MIT.txt`         | Oxc itself                                              | MIT        |
+| `oxc-THIRD-PARTY.txt` | the code Oxc carries from TypeScript and from `miette`  | Apache-2.0 |
+
+The gem's own Ruby, C, and Rust code is MIT, in `LICENSE.txt` at the root.

data/licenses/oxc-MIT.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024-present VoidZero Inc. & Contributors
+Copyright (c) 2023 Boshen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.