interscript 2.4.5 → 3.0.0

data/lib/interscript/compiler/python.rb

@@ -0,0 +1,354 @@
+require "pycall"
+
+class Interscript::Compiler::Python < Interscript::Compiler
+  def escape(val)
+    case val
+    when String, Integer
+      val.inspect
+    when Symbol
+      val.to_s.inspect
+    when Hash
+      "{" +
+        val.map { |k, v| "#{escape k}:#{escape v}" }.join(",") +
+        "}"
+    when Array
+      "[" + val.map { |i| escape i }.join(",") + "]"
+    when nil
+      "None"
+    else
+      pp [:error, val]
+      exit!
+    end
+  end
+
+  def re_escape(val)
+    @pycall_regex ||= PyCall.import_module("regex")
+    @pycall_regex.escape(val).gsub("\\", "\\\\\\\\").gsub('"', "\\\\\"")
+  end
+
+  def new_regexp(str)
+    "re.compile(\"#{str}\", re.MULTILINE)"
+  end
+
+  def indent
+    @indent += 4
+    yield
+    @indent -= 4
+  end
+
+  def emit(code)
+    @code << (" " * @indent) << code << "\n"
+    code
+  end
+
+  def compile(map, debug: false)
+    @indent = 0
+    @map = map
+    @debug = debug
+    @parallel_trees = {}
+    @parallel_regexps = {}
+    @code = ""
+    emit "import interscript"
+    emit "import regex as re"
+    map.dependencies.map(&:full_name).each do |dep|
+      emit "interscript.load_map(#{escape dep})"
+    end
+
+    emit "interscript.stdlib.define_map(#{escape map.name})"
+
+    map.aliases.each do |name, value|
+      val = compile_item(value.data, map, :str)
+      emit "interscript.stdlib.add_map_alias(#{escape map.name}, #{escape name}, #{val})"
+      val = "\"" + compile_item(value.data, map, :re) + "\""
+      emit "interscript.stdlib.add_map_alias_re(#{escape map.name}, #{escape name}, #{val})"
+    end
+
+    map.stages.each do |_, stage|
+      compile_rule(stage, @map, true)
+    end
+    @parallel_trees.each do |k, v|
+      emit "_PTREE_#{k} = #{escape v}"
+    end
+    @parallel_regexps.each do |k, v|
+      v = %(["#{v[0]}", #{escape v[1]}])
+      emit "_PRE_#{k} = #{v}"
+    end
+  end
+
+  def parallel_regexp_compile(subs_hash)
+    # puts subs_hash.inspect
+    subs_hash.each_with_index.map do |p, i|
+      "(?P<_%d>%s)" % [i, p[0]]
+    end.join("|")
+
+    # puts subs_regexp.inspect
+  end
+
+  def compile_rule(r, map = @map, wrapper = false)
+    return if r.reverse_run == true
+    case r
+    when Interscript::Node::Stage
+      if @debug
+        emit "if not hasattr(interscript, 'map_debug'):"
+        indent { emit "interscript.map_debug = []" }
+      end
+      emit "def _stage_#{r.name}(s):"
+      indent do
+        r.children.each do |t|
+          comp = compile_rule(t, map)
+          emit %{interscript.map_debug.append([s, #{escape @map.name.to_s}, #{escape r.name.to_s}, #{escape t.inspect}, #{escape comp}])} if @debug
+        end
+        emit "return s\n"
+      end
+      emit "interscript.stdlib.add_map_stage(#{escape @map.name}, #{escape r.name}, _stage_#{r.name})"
+    when Interscript::Node::Group::Parallel
+      begin
+        # Try to build a tree
+        a = []
+        r.children.each do |i|
+          raise Interscript::SystemConversionError, "Can't parallelize #{i.class}" unless Interscript::Node::Rule::Sub === i
+          raise Interscript::SystemConversionError, "Can't parallelize rules with :before" if i.before
+          raise Interscript::SystemConversionError, "Can't parallelize rules with :after" if i.after
+          raise Interscript::SystemConversionError, "Can't parallelize rules with :not_before" if i.not_before
+          raise Interscript::SystemConversionError, "Can't parallelize rules with :not_after" if i.not_after
+
+          next if i.reverse_run == true
+          a << [compile_item(i.from, map, :par), compile_item(i.to, map, :parstr)]
+        end
+        ah = a.hash.abs
+        unless @parallel_trees.include? ah
+          tree = Interscript::Stdlib.parallel_replace_compile_tree(a)
+          @parallel_trees[ah] = tree
+        end
+        emit "s = interscript.stdlib.parallel_replace_tree(s, _PTREE_#{ah})"
+      rescue
+        # Otherwise let's build a megaregexp
+        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
+        ah = a.hash.abs
+        unless @parallel_regexps.include? ah
+          re = parallel_regexp_compile(a)
+          @parallel_regexps[ah] = [re, a.map(&:last)]
+        end
+        emit "s = interscript.stdlib.parallel_regexp_gsub(s, *_PRE_#{ah})"
+      end
+    when Interscript::Node::Rule::Sub
+      from = new_regexp build_regexp(r, map)
+      to = if r.to == :upcase
+        "interscript.stdlib.upper"
+      elsif r.to == :downcase
+        "interscript.stdlib.lower"
+      else
+        compile_item(r.to, map, :str)
+      end
+      emit "s = #{from}.sub(#{to}, s)"
+    when Interscript::Node::Rule::Funcall
+      emit "s = interscript.functions.#{r.name}(s, #{escape r.kwargs})"
+    when Interscript::Node::Rule::Run
+      if r.stage.map
+        doc = map.dep_aliases[r.stage.map].document
+        stage = doc.imported_stages[r.stage.name]
+      else
+        stage = map.imported_stages[r.stage.name]
+      end
+      emit "s = interscript.transliterate(#{escape stage.doc_name}, s, #{escape stage.name})"
+    else
+      raise Interscript::SystemConversionError, "Can't compile unhandled #{r.class}"
+    end
+  end
+
+  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
+    not_before = compile_item(r.not_before, map, :re) if r.not_before
+    not_after = compile_item(r.not_after, map, :re) if r.not_after
+
+    re = ""
+    re += "(?<=#{before})" if before
+    re += "(?<!#{not_before})" if not_before
+    re += from
+    re += "(?!#{not_after})" if not_after
+    re += "(?=#{after})" if after
+    re
+  end
+
+  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
+      parstr = true
+      target = :par
+    end
+
+    case i
+    when Interscript::Node::Item::Alias
+      astr = if i.map
+        d = doc.dep_aliases[i.map].document
+        a = d.imported_aliases[i.name]
+        raise Interscript::SystemConversionError, "Alias #{i.name} of #{i.stage.map} not found" unless a
+        "interscript.stdlib.get_alias_ALIASTYPE(#{escape a.doc_name}, #{escape a.name})"
+      elsif Interscript::Stdlib::ALIASES.include?(i.name)
+        if target != :re && Interscript::Stdlib.re_only_alias?(i.name)
+          raise Interscript::SystemConversionError, "Can't use #{i.name} in a #{target} context"
+        end
+        stdlib_alias = true
+        "interscript.stdlib.aliases[#{escape i.name}]"
+      else
+        a = doc.imported_aliases[i.name]
+        raise Interscript::SystemConversionError, "Alias #{i.name} not found" unless a
+
+        "interscript.stdlib.get_alias_ALIASTYPE(#{escape a.doc_name}, #{escape a.name})"
+      end
+
+      if target == :str
+        astr.sub("_ALIASTYPE(", "(")
+      elsif target == :re
+        "\"+#{astr.sub("_ALIASTYPE(", "_re(")}+\""
+      elsif parstr && stdlib_alias
+        Interscript::Stdlib::ALIASES[i.name]
+      elsif target == :par
+        # raise NotImplementedError, "Can't use aliases in parallel mode yet"
+        Interscript::Stdlib::ALIASES[i.name]
+      end
+    when Interscript::Node::Item::String
+      if target == :str
+        # Replace \1 with \\1, this is weird, but it works!
+        i.data.gsub("\\", "\\\\\\\\").inspect
+      elsif target == :par
+        i.data
+      elsif target == :re
+        re_escape(i.data)
+      end
+    when Interscript::Node::Item::Group
+      if target == :par
+        i.children.map do |j|
+          compile_item(j, doc, target)
+        end.reduce([""]) do |j, k|
+          Array(j).product(Array(k)).map(&:join)
+        end
+      elsif target == :str
+        i.children.map { |j| compile_item(j, doc, target) }.join("+")
+      elsif target == :re
+        i.children.map { |j| compile_item(j, doc, target) }.join
+      end
+    when Interscript::Node::Item::CaptureGroup
+      if target != :re
+        raise Interscript::SystemConversionError, "Can't use a CaptureGroup in a #{target} context"
+      end
+      "(" + compile_item(i.data, doc, target) + ")"
+    when Interscript::Node::Item::Maybe,
+         Interscript::Node::Item::MaybeSome,
+         Interscript::Node::Item::Some
+
+      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 Maybe in a #{target} context"
+      end
+      if Interscript::Node::Item::String === i.data && i.data.data.length != 1
+        "(?:" + compile_item(i.data, doc, target) + ")" + resuffix
+      else
+        compile_item(i.data, doc, target) + resuffix
+      end
+    when Interscript::Node::Item::CaptureRef
+      if target == :par
+        raise Interscript::SystemConversionError, "Can't use CaptureRef in parallel mode"
+      elsif target == :re
+        "\\\\#{i.id}"
+      elsif target == :str
+        "\"\\\\#{i.id}\""
+      end
+    when Interscript::Node::Item::Any
+      if target == :str
+        raise Interscript::SystemConversionError, "Can't use Any in a string context" # A linter could find this!
+      elsif target == :par
+        i.data.map(&:data)
+      elsif target == :re
+        case i.value
+        when Array
+          data = i.data.map { |j| compile_item(j, doc, target) }
+          "(?:" + data.join("|") + ")"
+        when String
+          "[#{re_escape(i.value)}]"
+        when Range
+          "[#{re_escape(i.value.first)}-#{re_escape(i.value.last)}]"
+        end
+      end
+    end
+  end
+
+  @maps_loaded = {}
+  @ctx = nil
+  class << self
+    attr_accessor :maps_loaded
+    attr_accessor :ctx
+    attr_accessor :maps_dir
+  end
+
+  def load
+    # Keyed by document identity: synthetic spec documents reuse names
+    # (example-1, example-2, ...), and a stale engine under a reused
+    # name would silently serve the previous document.
+    if self.class.maps_loaded[@map.name] != @map.object_id
+      @map.dependencies.each do |dep|
+        dep = dep.full_name
+        if !self.class.maps_loaded[dep]
+          Interscript.load(dep, compiler: self.class).load
+        end
+      end
+
+      ctx = self.class.ctx
+      python_src_path = ENV["INTERSCRIPT_PYTHON_SRC"] ||
+        File.join(__dir__, "..", "..", "..", "..", "python", "src")
+      unless ctx
+        # Insert at 0: an editable install of interscript-python may
+        # shadow the monorepo checkout on sys.path.
+        PyCall.sys.path.insert(0, python_src_path)
+        self.class.ctx = PyCall.import_module("interscript")
+        ctx = self.class.ctx
+      end
+      # The rewritten python runtime executes ISC sources from its load
+      # paths, so in-memory documents cross the boundary as generated
+      # ISC text in a per-process temp dir — never inside the python
+      # package tree.
+      unless self.class.maps_dir
+        require "tmpdir" unless defined?(Dir.mktmpdir)
+        self.class.maps_dir = Dir.mktmpdir("interscript-python")
+        ctx.add_load_path(self.class.maps_dir)
+      end
+      File.write(File.join(self.class.maps_dir, "#{@map.name}.isc"),
+        Interscript::Isc::Generator.generate(@map))
+      self.class.ctx.load_map(@map.name)
+
+      if self.class.maps_loaded.key?(@map.name)
+        self.class.ctx.unload_map(@map.name)
+      end
+      self.class.maps_loaded[@map.name] = @map.object_id
+    end
+  end
+
+  def call(str, stage = :main)
+    load
+    unless stage.to_s == "main"
+      raise Interscript::MapLogicError,
+        "the python runtime transliterates the whole map; stage #{stage} can't be selected"
+    end
+    self.class.ctx.transliterate(@map.name, str)
+  end
+
+  def self.read_debug_data
+    (ctx["map_debug"] || []).map(&:to_a).to_a
+  end
+
+  def self.reset_debug_data
+    ctx["map_debug"].clear
+  end
+end

data/lib/interscript/compiler/ruby.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Style/GlobalVars, Security/Eval -- map-evaluation context globals; eval runs generated map code
 $main_binding = binding
 
 class Interscript::Compiler::Ruby < Interscript::Compiler
@@ -19,22 +20,21 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
     c << "def self.get_alias_re(map,name);             @maps[map].aliases_re[name]; end\n"
     c << "def self.transliterate(map,string,stage=:main); @maps[map].stages[stage].(string); end\n"
     c << "end; end; end\n"
-    c
 
     map.aliases.each do |name, value|
       val = compile_item(value.data, map, :str)
       c << "Interscript::Maps.add_map_alias(#{map.name.inspect}, #{name.inspect}, #{val})\n"
-      val = '/'+compile_item(value.data, map, :re).gsub('/', '\\\\/')+'/'
+      val = "/" + compile_item(value.data, map, :re).gsub("/", '\\\\/') + "/"
       c << "Interscript::Maps.add_map_alias_re(#{map.name.inspect}, #{name.inspect}, #{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 << "Interscript::Maps::Cache::PTREE_#{k} ||= #{v.inspect}\n"
     end
-    @parallel_regexps.each do |k,v|
+    @parallel_regexps.each do |k, v|
       c << "Interscript::Maps::Cache::PRE_#{k} ||= #{v.inspect}\n"
     end
     @code = c
@@ -51,7 +51,7 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
       r.children.each do |t|
         comp = compile_rule(t, map)
         c += comp
-        c += %{$map_debug << [s.dup, #{@map.name.to_s.inspect}, #{r.name.to_s.inspect}, #{t.inspect.inspect}, #{comp.inspect}]\n} if @debug
+        c += %($map_debug << [s.dup, #{@map.name.to_s.inspect}, #{r.name.to_s.inspect}, #{t.inspect.inspect}, #{comp.inspect}]\n) if @debug
       end
       c += "s\n"
       c += "end\n"
@@ -93,12 +93,12 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
       end
     when Interscript::Node::Rule::Sub
       from = "/#{build_regexp(r, map).gsub("/", "\\\\/")}/"
-      if r.to == :upcase
-        to = '&:upcase'
+      to = if r.to == :upcase
+        "&:upcase"
       elsif r.to == :downcase
-        to = '&:downcase'
+        "&:downcase"
       else
-        to = compile_item(r.to, map, :str)
+        compile_item(r.to, map, :str)
       end
       c += "s.gsub!(#{from}, #{to})\n"
     when Interscript::Node::Rule::Funcall
@@ -117,7 +117,7 @@ class Interscript::Compiler::Ruby < 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
@@ -133,7 +133,7 @@ class Interscript::Compiler::Ruby < 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
@@ -141,7 +141,7 @@ class Interscript::Compiler::Ruby < 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
@@ -162,14 +162,14 @@ class Interscript::Compiler::Ruby < 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
@@ -184,7 +184,7 @@ class Interscript::Compiler::Ruby < 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
@@ -201,9 +201,9 @@ class Interscript::Compiler::Ruby < 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 Maybe in a #{target} context"
@@ -230,7 +230,7 @@ class Interscript::Compiler::Ruby < 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
@@ -252,7 +252,7 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
     end
   end
 
-  def call(str, stage=:main)
+  def call(str, stage = :main)
     load
     Interscript::Maps.transliterate(@map.name, str, stage)
   end
@@ -265,3 +265,4 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
     $map_debug = []
   end
 end
+# rubocop:enable Style/GlobalVars, Security/Eval

data/lib/interscript/compiler.rb

@@ -1,16 +1,33 @@
 # An Interscript compiler interface
 class Interscript::Compiler
+  # Autoload all compiler variants (OCP: new compiler = one autoload).
+  autoload :Javascript, "interscript/compiler/javascript"
+  autoload :Python, "interscript/compiler/python"
+  autoload :Ruby, "interscript/compiler/ruby"
+  autoload :JsonIR, "interscript/compiler/json_ir"
+
   attr_accessor :code
 
   def self.call(map, **kwargs)
-    if String === map
-      map = Interscript::DSL.parse(map)
-    end
+    # DSL.parse locates, dispatches .isc and caches the parsed document —
+    # calling parse_isc here re-ran a full grammar parse on every
+    # compiler instantiation.
+    map = Interscript::DSL.parse(map) if String === map
     compiler = new
     compiler.compile(map, **kwargs)
     compiler
   end
 
+  # Parse an ISC source file into an Interscript::Node::Document.
+  # This bridges the new ISC format to the existing runtime.
+  def self.parse_isc(path)
+    source = File.read(path, encoding: "UTF-8")
+    filename = File.basename(path)
+    tree = Interscript::Isc::Parser.parse(source, filename: filename)
+    doc = Interscript::Isc::DocumentBuilder.build(tree, filename: filename)
+    Interscript::Isc::NodeAdapter.to_interscript_node(doc)
+  end
+
   def compile(map)
     raise NotImplementedError, "Compile method on #{self.class} is not implemented"
   end

data/lib/interscript/detector.rb

@@ -26,8 +26,8 @@ class Interscript::Detector
   end
 
   def set_from_kwargs(**kwargs)
-    kwargs.each do |k,v|
-      self.public_send(:"#{k}=", v)
+    kwargs.each do |k, v|
+      public_send(:"#{k}=", v)
     end
   end
 
@@ -36,13 +36,20 @@ class Interscript::Detector
     maps = Interscript.exclude_maps(maps, compiler: self.class)
     maps = Interscript.exclude_maps(maps, compiler: @compiler)
 
-    summary = maps.map do |map|
-      try_dest = Interscript.transliterate(map, source, compiler: @compiler)
+    summary = maps.filter_map do |map|
+      # A map that fails to load or execute (unsupported constructs,
+      # missing dependencies) is skipped, mirroring the TypeScript
+      # detector — one bad map must not kill the whole ranking.
+      begin
+        try_dest = Interscript.transliterate(map, source, compiler: @compiler)
+      rescue
+        next nil
+      end
 
       [map, try_dest]
     end.map do |map, try_dest|
-      dist = @distance_computer.(try_dest, destination)
-      
+      dist = @distance_computer.call(try_dest, destination)
+
       [map, dist]
     end.sort_by(&:last).to_h
 
@@ -59,4 +66,4 @@ class Interscript::Detector
   module DistanceComputer
     Levenshtein = Text::Levenshtein.method(:distance)
   end
-end
+end

data/lib/interscript/dsl/aliases.rb

@@ -5,7 +5,7 @@ class Interscript::DSL::Aliases
 
   def initialize(&block)
     @node = {}
-    self.instance_exec(&block)
+    instance_exec(&block)
   end
 
   def def_alias(name, value)

data/lib/interscript/dsl/document.rb

@@ -6,7 +6,7 @@ class Interscript::DSL::Document
   def initialize(name = nil, &block)
     @node = Interscript::Node::Document.new
     @node.name = name if name
-    self.instance_exec &block if block_given?
+    instance_exec(&block) if block_given?
   end
 
   def metadata(&block)
@@ -22,7 +22,10 @@ class Interscript::DSL::Document
   def aliases(&block)
     aliases = Interscript::DSL::Aliases.new(&block)
     @node.aliases = aliases.node
-    @node.aliases.transform_values { |v| v.doc_name = @node.name; v }
+    @node.aliases.transform_values { |v|
+      v.doc_name = @node.name
+      v
+    }
   end
 
   def dependency(full_name, **kargs)
@@ -38,7 +41,7 @@ class Interscript::DSL::Document
   end
 
   def stage(name = :main, dont_reverse: false, &block)
-    puts "stage(#{name}) from #{self.inspect}" if $DEBUG
+    puts "stage(#{name}) from #{inspect}" if $DEBUG
     stage = Interscript::DSL::Stage.new(name, &block)
     stage.node.doc_name = @node.name
     stage.node.dont_reverse = dont_reverse

data/lib/interscript/dsl/group/parallel.rb

@@ -1,6 +1,6 @@
 class Interscript::DSL::Group::Parallel < Interscript::DSL::Group
   def initialize(reverse_run: nil, &block)
     @node = Interscript::Node::Group::Parallel.new(reverse_run: reverse_run)
-    self.instance_exec(&block)
+    instance_exec(&block)
   end
 end

data/lib/interscript/dsl/group.rb

@@ -5,7 +5,7 @@ class Interscript::DSL::Group
 
   def initialize(&block)
     @node = Interscript::Node::Group.new
-    self.instance_exec(&block)
+    instance_exec(&block)
   end
 
   def run(stage, **kwargs)
@@ -16,20 +16,27 @@ class Interscript::DSL::Group
   end
 
   def sub(from, to, **kwargs, &block)
-    puts "sub(#{from.inspect},#{to}, kwargs = #{
-      kwargs.inspect
-    }) from #{self.inspect}" if $DEBUG
+    if $DEBUG
+      puts "sub(#{from.inspect},#{to}, kwargs = #{
+        kwargs.inspect
+      }) from #{inspect}"
+    end
 
     rule = Interscript::Node::Rule::Sub.new(from, to, **kwargs)
     @node.children << rule
   end
 
-  def upcase; :upcase; end
-  def downcase; :downcase; end
+  def upcase
+    :upcase
+  end
+
+  def downcase
+    :downcase
+  end
 
   Interscript::Stdlib.available_functions.each do |fun|
     define_method fun do |**kwargs|
-      puts "funcall(#{fun}, #{kwargs.inspect}) from #{self.inspect}" if $DEBUG
+      puts "funcall(#{fun}, #{kwargs.inspect}) from #{inspect}" if $DEBUG
 
       rule = Interscript::Node::Rule::Funcall.new(fun, **kwargs)
       @node.children << rule
@@ -37,10 +44,12 @@ class Interscript::DSL::Group
   end
 
   def parallel(**kwargs, &block)
-    puts "parallel(#{chars.inspect}) from #{self.inspect}" if $DEBUG
+    puts "parallel(#{chars.inspect}) from #{inspect}" if $DEBUG
     group = Interscript::DSL::Group::Parallel.new(**kwargs, &block)
     @node.children << group.node
   end
 end
 
-require 'interscript/dsl/group/parallel'
+class Interscript::DSL::Group
+  autoload :Parallel, "interscript/dsl/group/parallel"
+end