interscript 2.4.5 → 3.0.0

data/lib/interscript/compiler/javascript.rb

@@ -1,9 +1,9 @@
 begin
-  require 'mini_racer'
+  require "mini_racer"
 rescue LoadError
   # Ignore loading error
 end
-require 'json'
+require "json"
 
 class Interscript::Compiler::Javascript < Interscript::Compiler
   def compile(map, debug: false)
@@ -12,24 +12,23 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
     @parallel_regexps = {}
     @debug = debug
     c = "var map = function(Interscript) {"
-    c << "Interscript.define_map(#{map.name.inspect}, function(Interscript, map) {\n";
+    c << "Interscript.define_map(#{map.name.inspect}, function(Interscript, map) {\n"
     c << "map.dependencies = #{map.dependencies.map(&:full_name).to_json};\n"
-    c
 
     map.aliases.each do |name, value|
       val = compile_item(value.data, map, :str)
       c << "map.aliases.#{name} = #{val};\n"
-      val = '"'+compile_item(value.data, map, :re)+'"'
+      val = '"' + compile_item(value.data, map, :re) + '"'
       c << "map.aliases_re.#{name} = #{val};\n"
     end
 
     map.stages.each do |_, stage|
       c << compile_rule(stage, @map, true)
     end
-    @parallel_trees.each do |k,v|
+    @parallel_trees.each do |k, v|
       c << "map.cache.PTREE_#{k} = #{v.to_json};\n"
     end
-    @parallel_regexps.each do |k,v|
+    @parallel_regexps.each do |k, v|
       v = "[\"#{v[0]}\", #{v[1].to_json}]"
       c << "map.cache.PRE_#{k} = #{v};\n"
     end
@@ -44,10 +43,10 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
 
   def parallel_regexp_compile(subs_hash)
     # puts subs_hash.inspect
-    regexp = subs_hash.each_with_index.map do |p,i|
-      "(?<_%d>%s)" % [i,p[0]]
+    subs_hash.each_with_index.map do |p, i|
+      "(?<_%d>%s)" % [i, p[0]]
     end.join("|")
-    subs_regexp = regexp
+
     # puts subs_regexp.inspect
   end
 
@@ -90,7 +89,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
         a = []
         Interscript::Stdlib.deterministic_sort_by_max_length(r.children).each do |i|
           raise Interscript::SystemConversionError, "Can't parallelize #{i.class}" unless Interscript::Node::Rule::Sub === i
-          
+
           next if i.reverse_run == true
           a << [build_regexp(i, map), compile_item(i.to, map, :parstr)]
         end
@@ -102,13 +101,13 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
         c += "s = Interscript.parallel_regexp_gsub(s, map.cache.PRE_#{ah});\n"
       end
     when Interscript::Node::Rule::Sub
-      from = %{"#{build_regexp(r, map).gsub("/", "\\\\/")}"}
-      if r.to == :upcase
-        to = 'function(a){return a.toUpperCase();}'
+      from = %("#{build_regexp(r, map).gsub("/", "\\\\/")}")
+      to = if r.to == :upcase
+        "function(a){return a.toUpperCase();}"
       elsif r.to == :downcase
-        to = 'function(a){return a.toLowerCase();}'
+        "function(a){return a.toLowerCase();}"
       else
-        to = compile_item(r.to, map, :str)
+        compile_item(r.to, map, :str)
       end
       c += "s = Interscript.gsub(s, #{from}, #{to});\n"
     when Interscript::Node::Rule::Funcall
@@ -127,7 +126,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
     c
   end
 
-  def build_regexp(r, map=@map)
+  def build_regexp(r, map = @map)
     from = compile_item(r.from, map, :re)
     before = compile_item(r.before, map, :re) if r.before
     after = compile_item(r.after, map, :re) if r.after
@@ -144,7 +143,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
     re
   end
 
-  def compile_item i, doc=@map, target=nil
+  def compile_item i, doc = @map, target = nil
     i = i.first_string if %i[str parstr].include? target
     i = Interscript::Node::Item.try_convert(i)
     if target == :parstr
@@ -152,7 +151,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
       target = :par
     end
 
-    out = case i
+    case i
     when Interscript::Node::Item::Alias
       astr = if i.map
         d = doc.dep_aliases[i.map].document
@@ -173,14 +172,14 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
       end
 
       if target == :str
-        astr = astr.sub("_ALIASTYPE(", "(")
+        astr.sub("_ALIASTYPE(", "(")
       elsif target == :re
-        astr = %{"+#{astr.sub("_ALIASTYPE(", "_re(")}+"}
+        %("+#{astr.sub("_ALIASTYPE(", "_re(")}+")
       elsif parstr && stdlib_alias
-        astr = Interscript::Stdlib::ALIASES[i.name]
+        Interscript::Stdlib::ALIASES[i.name]
       elsif target == :par
         # raise NotImplementedError, "Can't use aliases in parallel mode yet"
-        astr = Interscript::Stdlib::ALIASES[i.name]
+        Interscript::Stdlib::ALIASES[i.name]
       end
     when Interscript::Node::Item::String
       if target == :str
@@ -195,7 +194,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
       if target == :par
         i.children.map do |j|
           compile_item(j, doc, target)
-        end.reduce([""]) do |j,k|
+        end.reduce([""]) do |j, k|
           Array(j).product(Array(k)).map(&:join)
         end
       elsif target == :str
@@ -212,9 +211,9 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
          Interscript::Node::Item::MaybeSome,
          Interscript::Node::Item::Some
 
-      resuffix = { Interscript::Node::Item::Maybe     => "?" ,
-                   Interscript::Node::Item::Some      => "+" ,
-                   Interscript::Node::Item::MaybeSome => "*" }[i.class]
+      resuffix = {Interscript::Node::Item::Maybe => "?",
+                  Interscript::Node::Item::Some => "+",
+                  Interscript::Node::Item::MaybeSome => "*"}[i.class]
 
       if target == :par
         raise Interscript::SystemConversionError, "Can't use a MaybeSome in a #{target} context"
@@ -241,7 +240,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
         case i.value
         when Array
           data = i.data.map { |j| compile_item(j, doc, target) }
-          "(?:"+data.join("|")+")"
+          "(?:" + data.join("|") + ")"
         when String
           "[#{Regexp.escape(i.value)}]"
         when Range
@@ -270,28 +269,28 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
       ctx = self.class.ctx
       unless ctx
         ctx = MiniRacer::Context.new
-        ctx.eval File.read(__dir__+"/../../../../js/test-compiler/xregexp.js")
+        ctx.eval File.read(__dir__ + "/../../../../js/test-compiler/xregexp.js")
         # Compatibility with Safari: will come later
-        #ctx.eval File.read(__dir__+"/../../../js/xregexp-oniguruma.js")
-        ctx.eval File.read(__dir__+"/../../../../js/src/stdlib.js")
+        # ctx.eval File.read(__dir__+"/../../../js/xregexp-oniguruma.js")
+        ctx.eval File.read(__dir__ + "/../../../../js/src/stdlib.js")
         self.class.ctx = ctx
       end
-      #puts @code
+      # puts @code
       ctx.eval @code
       self.class.maps_loaded[@map.name] = true
     end
   end
 
-  def call(str, stage=:main)
+  def call(str, stage = :main)
     load
     self.class.ctx.eval "Interscript.transliterate(#{@map.name.to_json}, #{str.to_json}, #{stage.to_json})"
   end
 
   def self.read_debug_data
-    self.ctx.eval "globalThis.map_debug || []"
+    ctx.eval "globalThis.map_debug || []"
   end
 
   def self.reset_debug_data
-    self.ctx.eval "globalThis.map_debug = []"
+    ctx.eval "globalThis.map_debug = []"
   end
 end

data/lib/interscript/compiler/json_ir.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "json"
+
+# JSON IR compiler — emits a data-only intermediate representation consumable
+# by non-Ruby runtimes (e.g. interscript-ts). Unlike Compiler::Javascript,
+# which emits imperative JS that calls into a runtime, this emits a pure-data
+# JSON document describing the AST.
+#
+# The shape is versioned via SCHEMA_VERSION. Runtimes should refuse to load
+# IR with an unknown schema.
+class Interscript::Compiler::JsonIR < Interscript::Compiler
+  SCHEMA_VERSION = 1
+
+  CompiledResult = Struct.new(:code) do
+    # JsonIR output is already JSON. The runtime treats .code as opaque
+    # text; consumers parse via JSON.parse.
+    def to_json(*)
+      code
+    end
+  end
+
+  def compile(map, debug: false)
+    @map = map
+    @c = JSON.pretty_generate(serialise_document(map))
+    self
+  end
+
+  def code
+    @c
+  end
+
+  private
+
+  def serialise_document(doc)
+    # Merge aliases from the document AND from dependency documents so
+    # that consumers (interscript-ts) can resolve every alias reference
+    # without re-implementing the Ruby dep_aliases indirection.
+    all_aliases = {}
+
+    # Only the document's own aliases are serialised. Library and
+    # dependency aliases resolve at runtime via the alias `map:` qualifier,
+    # matching the production corpus shape.
+    doc.aliases.each do |name, defn|
+      all_aliases[name.to_s] = serialise_item(defn.data)
+    end
+
+    {
+      schemaVersion: SCHEMA_VERSION,
+      systemCode: doc.name.to_s,
+      dependencies: doc.dependencies.map(&:full_name),
+      metadata: serialise_metadata(doc.metadata),
+      stages: serialise_stages(doc.stages),
+      aliases: all_aliases,
+      functions: {}
+    }
+  end
+
+  def serialise_metadata(metadata)
+    return {} unless metadata
+    out = {}
+    metadata.data.each do |k, v|
+      out[k.to_s] = case v
+      when Symbol then v.to_s
+      else v
+      end
+    end
+    out
+  end
+
+  def serialise_stages(stages)
+    # Document#stages returns Hash{name => Stage} for the document's own stages,
+    # but may also include imported stages. Iterate values and skip anything
+    # that isn't an Interscript::Node::Stage (e.g. imported Hash entries).
+    stages.values.map { |s| serialise_stage(s) if s.is_a?(Interscript::Node::Stage) }.compact
+  end
+
+  def serialise_stage(stage)
+    {
+      kind: "stage",
+      name: stage.name.to_s,
+      rules: stage.children.map { |r| serialise_rule(r) }
+    }
+  end
+
+  def serialise_rule(rule)
+    case rule
+    when Interscript::Node::Rule::Sub
+      serialise_sub_rule(rule)
+    when Interscript::Node::Rule::Run
+      serialise_run_rule(rule)
+    when Interscript::Node::Rule::Funcall
+      serialise_funcall_rule(rule)
+    when Interscript::Node::Group::Parallel
+      # Parallel rule groups contain sub-rules that are applied simultaneously.
+      # In IR, we emit them as a marker rule so the runtime can decide.
+      {
+        kind: "parallel",
+        rules: rule.children.map { |r| serialise_rule(r) }
+      }
+    when Interscript::Node::Group::Sequential
+      {
+        kind: "sequential",
+        rules: rule.children.map { |r| serialise_rule(r) }
+      }
+    else
+      raise Interscript::MapLogicError, "Cannot serialise rule of type #{rule.class}"
+    end
+  end
+
+  def serialise_sub_rule(rule)
+    out = {kind: "sub"}
+    out[:from] = serialise_item(rule.from) if rule.from
+    out[:to] = serialise_to(rule.to)
+    out[:before] = serialise_item(rule.before) if rule.before
+    out[:after] = serialise_item(rule.after) if rule.after
+    out[:notBefore] = serialise_item(rule.not_before) if rule.not_before
+    out[:notAfter] = serialise_item(rule.not_after) if rule.not_after
+    out[:priority] = rule.priority if rule.priority
+    out
+  end
+
+  def serialise_run_rule(rule)
+    stage = rule.stage
+    doc_name = stage.map
+    if doc_name && @map.respond_to?(:dep_aliases) && @map.dep_aliases[doc_name.to_sym]
+      resolved = @map.dep_aliases[doc_name.to_sym].document
+      doc_name = resolved.name.to_s if resolved.respond_to?(:name)
+    end
+    {
+      kind: "run",
+      stage: stage.name.to_s,
+      docName: doc_name&.to_s
+    }
+  end
+
+  def serialise_funcall_rule(rule)
+    {
+      kind: "funcall",
+      name: rule.name.to_s,
+      kwargs: symbolise_keys(rule.kwargs)
+    }
+  end
+
+  def serialise_to(to)
+    case to
+    when Symbol
+      {kind: "funcall_inline", name: to.to_s}
+    else
+      serialise_item(to)
+    end
+  end
+
+  def serialise_item(item)
+    return {kind: "any", of: item.map { |i| i.is_a?(String) ? {kind: "string", value: i} : serialise_item(i) }} if item.is_a?(::Array)
+    case item
+    when Interscript::Node::Item::String
+      {kind: "string", value: item.data}
+    when Interscript::Node::Item::CaptureGroup
+      {kind: "capture_group", data: serialise_item(item.data)}
+    when Interscript::Node::Item::CaptureRef
+      {kind: "capture_ref", id: item.id}
+    when Interscript::Node::Item::Alias
+      out = {kind: "alias", name: item.name.to_s}
+      out[:map] = item.map if item.map
+      out
+    when Interscript::Node::Item::Any
+      # Any with a String payload becomes a character class in Ruby's
+      # regex compilation. Range payloads become `[first-last]`. Both
+      # must survive IR serialisation as char-class form, NOT expanded
+      # into alternatives — Ruby's String#succ expansion of "a".."ᖵ"
+      # produces nonsense like "zzz" and misses most of the BMP.
+      case item.value
+      when ::Range
+        {kind: "any_char_class", range: [item.value.first, item.value.last]}
+      when ::String
+        {kind: "any_char_class", chars: item.value.chars}
+      else
+        data = item.data || []
+        {kind: "any", of: data.map { |i| serialise_item(i) }}
+      end
+    when Interscript::Node::Item::Group
+      {kind: "group", items: item.children.map { |i| serialise_item(i) }}
+    when Interscript::Node::Item::Repeat
+      {kind: "repeat", item: serialise_item(item.data), min: 0, max: nil}
+    when Interscript::Node::Item::Stage
+      {kind: "stage_ref", name: item.name.to_s}
+    when nil
+      nil
+    else
+      raise Interscript::MapLogicError, "Cannot serialise item of type #{item.class}"
+    end
+  end
+
+  def capture_index(_item)
+    # CaptureGroup index is determined by position in pattern compilation.
+    # Runtimes should treat as a placeholder; the actual index is computed
+    # during pattern compilation based on capture-group ordering.
+    0
+  end
+
+  def serialise_aliases(aliases)
+    out = {}
+    aliases.each do |name, defn|
+      out[name.to_s] = serialise_item(defn.data)
+    end
+    out
+  end
+
+  def symbolise_keys(hash)
+    return {} if hash.nil?
+    hash.transform_keys(&:to_s)
+  end
+end