interscript 2.1.0b6 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67fee0bf4248e98e2e9921ed44c95d053587e3e7568d7bfd5c200f3dd8046950
-  data.tar.gz: 84e0fa3cde05cf8e99cf810a9d0a16cdcab4d9fdcf9a366b405fef52cfce27eb
+  metadata.gz: 2088a63470d6a75261e2a774c73cf30b33e06e69b91d679b0eef5d7431197ef0
+  data.tar.gz: fafd8fa34f47f600c1dc0f7d8da2628a264aec9c5387b21bbcf483e9606c915f
 SHA512:
-  metadata.gz: 4c5db8e05372a3039a0523a9d45057ede863bc50df44f0dccdc7a1200aef4310e8ae61fa105bc2e728acd2e92b9d9a1ddab283c3782a42052b18d6d339e3fff9
-  data.tar.gz: 4fd36499b7ce58cc92ad4eca65113ce716c9b7a5f70a6cb5486bc44b42374537c57b90cb64b727ffc572e818fcd6c046ee1f77ad6d452768c0ff840dfe1a7761
+  metadata.gz: b9e25faac07f4c517c291a7fd61ab435b70c84e0e9404b6cc4da8196e044e603ed6475d66d20f36d48fb75b8117d454dd1fce61244dafd99f588298fcbd96844
+  data.tar.gz: 95c6a784bcca66f9b05f39260c2dd5a6a4a945f044c955d518d661381eb8de0610be7f7ec029fe923273f6624933f5affd7f825d94b80b838866f35fd7797d15

data/Gemfile

@@ -26,4 +26,6 @@ unless ENV["SKIP_JS"]
   end
 end
 
+gem 'pry'
+
 gem 'simplecov', require: false, group: :test

data/bin/console

@@ -3,12 +3,8 @@
 require "bundler/setup"
 require "interscript"
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
+require "interscript/utils/helpers"
+include Interscript::Utils::Helpers
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)
+require "pry"
+Pry.start

data/interscript.gemspec

@@ -27,5 +27,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor"
-  spec.add_dependency "interscript-maps"
+  spec.add_dependency "interscript-maps", "~> #{Interscript::VERSION.split('.')[0,2].join(".")}.0"
+  spec.add_dependency "text"
 end

data/lib/interscript.rb

@@ -53,6 +53,16 @@ module Interscript
       output_file
     end
 
+    # Detects the transliteration that gives the most close approximation
+    # of transliterating source into destination.
+    #
+    # Set multiple: true to get a full report.
+    def detect(source, destination, **kwargs)
+      detector = Detector.new
+      detector.set_from_kwargs(**kwargs)
+      detector.(source, destination)
+    end
+
     def map_gems
       @map_gems ||= Gem.find_latest_files('interscript-maps.yaml').map do |i|
         [i, YAML.load_file(i)]
@@ -109,3 +119,5 @@ require "interscript/interpreter"
 
 require 'interscript/dsl'
 require 'interscript/node'
+
+require 'interscript/detector'

data/lib/interscript/compiler/javascript.rb

@@ -53,6 +53,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
 
   def compile_rule(r, map = @map, wrapper = false)
     c = ""
+    return c if r.reverse_run == true
     case r
     when Interscript::Node::Stage
       c += "map.stages.#{r.name} = function(s) {\n"
@@ -75,6 +76,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
           raise ArgumentError, "Can't parallelize rules with :not_before" if i.not_before
           raise ArgumentError, "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
@@ -88,7 +90,8 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
         a = []
         Interscript::Stdlib.deterministic_sort_by_max_length(r.children).each do |i|
           raise ArgumentError, "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
@@ -102,6 +105,8 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
       from = %{"#{build_regexp(r, map).gsub("/", "\\\\/")}"}
       if r.to == :upcase
         to = 'function(a){return a.toUpperCase();}'
+      elsif r.to == :downcase
+        to = 'function(a){return a.toLowerCase();}'
       else
         to = compile_item(r.to, map, :str)
       end

data/lib/interscript/compiler/ruby.rb

@@ -42,6 +42,7 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
 
   def compile_rule(r, map = @map, wrapper = false)
     c = ""
+    return c if r.reverse_run == true
     case r
     when Interscript::Node::Stage
       c += "Interscript::Maps.add_map_stage \"#{@map.name}\", #{r.name.inspect} do |s|\n"
@@ -65,6 +66,7 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
           raise ArgumentError, "Can't parallelize rules with :not_before" if i.not_before
           raise ArgumentError, "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
@@ -79,6 +81,7 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
         Interscript::Stdlib.deterministic_sort_by_max_length(r.children).each do |i|
           raise ArgumentError, "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
@@ -92,6 +95,8 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
       from = "/#{build_regexp(r, map).gsub("/", "\\\\/")}/"
       if r.to == :upcase
         to = '&:upcase'
+      elsif r.to == :downcase
+        to = '&:downcase'
       else
         to = compile_item(r.to, map, :str)
       end

data/lib/interscript/detector.rb

@@ -0,0 +1,60 @@
+require "text"
+
+class Interscript::Detector
+  attr_accessor :compiler
+  attr_accessor :distance_computer
+  attr_accessor :map_pattern
+
+  # TODO: use transliterate_each
+  attr_accessor :each
+
+  attr_accessor :load_path
+  attr_accessor :cache
+
+  # Returns a summary of all detected transliterations
+  attr_accessor :multiple
+
+  def initialize
+    @compiler = Interscript::Interpreter
+    @distance_computer = DistanceComputer::Levenshtein
+    @map_pattern = "*"
+
+    @each = false
+
+    @load_path = false
+    @cache = CACHE
+  end
+
+  def set_from_kwargs(**kwargs)
+    kwargs.each do |k,v|
+      self.public_send(:"#{k}=", v)
+    end
+  end
+
+  def call(source, destination)
+    maps = Interscript.maps(select: @map_pattern, load_path: @load_path)
+
+    summary = maps.map do |map|
+      try_dest = Interscript.transliterate(map, source, compiler: @compiler)
+
+      [map, try_dest]
+    end.map do |map, try_dest|
+      dist = @distance_computer.(try_dest, destination)
+      
+      [map, dist]
+    end.sort_by(&:last).to_h
+
+    if @multiple
+      summary.to_h
+    else
+      summary.first.first
+    end
+  end
+
+  CACHE = {}
+
+  # A DistanceComputer needs to respond to #call(source, destination)
+  module DistanceComputer
+    Levenshtein = Text::Levenshtein.method(:distance)
+  end
+end

data/lib/interscript/dsl.rb

@@ -2,12 +2,45 @@ require "yaml"
 
 module Interscript::DSL
   @cache = {}
-  def self.parse(map_name)
+  def self.parse(map_name, reverse: true)
     # map name aliases? here may be a place to wrap it
 
     return @cache[map_name] if @cache[map_name]
-    path = Interscript.locate(map_name)
+
+    # This is a composition, so let's make a new virtual map
+    # that calls all maps in a sequence.
+    if map_name.include? "|"
+      map_parts = map_name.split("|").map(&:strip)
+
+      doc = Interscript::DSL::Document.new(map_name) do
+        map_parts.each_with_index do |i, idx|
+          dependency i, as: :"part#{idx}"
+        end
+
+        stage {
+          map_parts.each_with_index do |i, idx|
+            run map[:"part#{idx}"].stage.main
+          end
+        }
+      end.node
+
+      return @cache[map_name] = doc
+    end
+
+    path = begin
+      Interscript.locate(map_name)
+    rescue Interscript::MapNotFoundError => e
+      # But maybe we called the map in a reversed fashion?
+      begin
+        raise e if reverse == false # Protect from an infinite loop
+        reverse_name = Interscript::Node::Document.reverse_name(map_name)
+        return @cache[map_name] = parse(reverse_name, reverse: false).reverse
+      rescue Interscript::MapNotFoundError
+        raise e
+      end
+    end
     library = path.end_with?(".iml")
+
     map_name = File.basename(path, ".imp")
     map_name = File.basename(map_name, ".iml")
 

data/lib/interscript/dsl/group.rb

@@ -8,16 +8,16 @@ class Interscript::DSL::Group
     self.instance_exec(&block)
   end
 
-  def run(stage)
+  def run(stage, **kwargs)
     if stage.class != Interscript::Node::Item::Stage
       raise TypeError, "I::Node::Item::Stage expected, got #{stage.class}"
     end
-    @node.children << Interscript::Node::Rule::Run.new(stage)
+    @node.children << Interscript::Node::Rule::Run.new(stage, **kwargs)
   end
 
   def sub(from, to, **kwargs, &block)
-    puts "sub(#{from.inspect},#{to}, kargs = #{
-      kargs.inspect
+    puts "sub(#{from.inspect},#{to}, kwargs = #{
+      kwargs.inspect
     }) from #{self.inspect}" if $DEBUG
 
     rule = Interscript::Node::Rule::Sub.new(from, to, **kwargs)
@@ -25,6 +25,7 @@ class Interscript::DSL::Group
   end
 
   def upcase; :upcase; end
+  def downcase; :downcase; end
 
   Interscript::Stdlib.available_functions.each do |fun|
     define_method fun do |**kwargs|
@@ -35,9 +36,9 @@ class Interscript::DSL::Group
     end
   end
 
-  def parallel(&block)
+  def parallel(**kwargs, &block)
     puts "parallel(#{chars.inspect}) from #{self.inspect}" if $DEBUG
-    group = Interscript::DSL::Group::Parallel.new(&block)
+    group = Interscript::DSL::Group::Parallel.new(**kwargs, &block)
     @node.children << group.node
   end
 end

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

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

data/lib/interscript/interpreter.rb

@@ -76,6 +76,7 @@ class Interscript::Interpreter < Interscript::Compiler
     end
 
     def execute_rule r
+      return if r.reverse_run == true
       case r
       when Interscript::Node::Group::Parallel
         if r.cached_tree
@@ -96,6 +97,7 @@ class Interscript::Interpreter < Interscript::Compiler
               raise ArgumentError, "Can't parallelize rules with :after" if i.after
               raise ArgumentError, "Can't parallelize rules with :not_before" if i.not_before
               raise ArgumentError, "Can't parallelize rules with :not_after" if i.not_after
+              next if i.reverse_run == true
               subs_array << [build_item(i.from, :par), build_item(i.to, :parstr)]
             end
             tree = Interscript::Stdlib.parallel_replace_compile_tree(subs_array) #.sort_by{|k,v| -k.length})
@@ -108,7 +110,7 @@ class Interscript::Interpreter < Interscript::Compiler
             subs_array = []
             Interscript::Stdlib.deterministic_sort_by_max_length(r.children).each do |i|  # rule.from.max_length gives somewhat better test results, why is that
               raise ArgumentError, "Can't parallelize #{i.class}" unless Interscript::Node::Rule::Sub === i
-
+              next if i.reverse_run == true
               subs_array << [build_regexp(i), build_item(i.to, :parstr)]
             end
             r.subs_regexp = Interscript::Stdlib.parallel_regexp_compile(subs_array)
@@ -129,6 +131,8 @@ class Interscript::Interpreter < Interscript::Compiler
       when Interscript::Node::Rule::Sub
         if r.to == :upcase
           @str = @str.gsub(Regexp.new(build_regexp(r)), &:upcase)
+        elsif r.to == :downcase
+          @str = @str.gsub(Regexp.new(build_regexp(r)), &:downcase)
         else
           @str = @str.gsub(Regexp.new(build_regexp(r)), build_item(r.to, :str))
         end

data/lib/interscript/node.rb

@@ -4,6 +4,10 @@ class Interscript::Node
     raise NotImplementedError, "You can't construct a Node directly"
   end
 
+  def ==(other)
+    self.class == other.class
+  end
+
   def to_hash
     { :class => self.class.to_s,
       :question => "is something missing?"

data/lib/interscript/node/alias_def.rb

@@ -7,6 +7,12 @@ class Interscript::Node::AliasDef < Interscript::Node
     @data = data
   end
 
+  def ==(other)
+    super &&
+    self.name == other.name &&
+    self.data == other.data
+  end
+
   def to_hash
     { :class => self.class.to_s,
       :name => @name,

data/lib/interscript/node/dependency.rb

@@ -4,6 +4,22 @@ class Interscript::Node::Dependency < Interscript::Node
   def initialize
   end
 
+  def reverse
+    rdep = self.class.new
+    rdep.name = name
+    rdep.full_name = Interscript::Node::Document.reverse_name(full_name)
+    rdep.import = import
+    rdep.document = document&.reverse
+    rdep
+  end
+
+  def ==(other)
+    super &&
+    self.full_name == other.full_name &&
+    self.import == other.import &&
+    self.name == other.name
+  end
+
   def to_hash
     { :class => self.class.to_s,
       :name => @name,

data/lib/interscript/node/document.rb

@@ -34,6 +34,39 @@ class Interscript::Node::Document
     end
   end
 
+  def reverse
+    @reverse ||= self.class.new.tap do |rdoc|
+      rdoc.name = self.class.reverse_name(name)
+      rdoc.metadata = metadata&.reverse
+      rdoc.tests = tests&.reverse
+      rdoc.dependencies = dependencies.map(&:reverse)
+      rdoc.stages = stages.transform_values(&:reverse)
+      rdoc.dep_aliases = dep_aliases.transform_values(&:reverse)
+      rdoc.aliases = aliases
+    end
+  end
+
+  def self.reverse_name(name)
+    newname = (name || "noname").split("-")
+    newname[2], newname[3] = newname[3], newname[2] if newname.length >= 4
+    newname = newname.join("-")
+    if newname == name
+      newname.gsub!("-reverse", "")
+    end
+    if newname == name
+      newname += "-reverse"
+    end
+    newname
+  end
+
+  def ==(other)
+    self.class == other.class &&
+    self.metadata == other.metadata &&
+    self.tests == other.tests &&
+    self.stages == other.stages &&
+    self.aliases == other.aliases
+  end
+
   def to_hash
     { :class => self.class.to_s, :metadata => @metadata&.to_hash,
       :tests => @tests&.to_hash,

data/lib/interscript/node/group.rb

@@ -1,7 +1,8 @@
 class Interscript::Node::Group < Interscript::Node
-  attr_accessor :children
+  attr_accessor :children, :reverse_run
 
-  def initialize
+  def initialize(reverse_run: nil)
+    @reverse_run = reverse_run
     @children = []
   end
 
@@ -20,11 +21,21 @@ class Interscript::Node::Group < Interscript::Node
     self
   end
 
+  def reverse
+    self.class.new(reverse_run: reverse_run.nil? ? nil : !reverse_run).tap do |r|
+      r.children = self.children.reverse.map(&:reverse)
+    end
+  end
+
   def to_hash
     { :class => self.class.to_s,
       :children => @children.map{|x| x.to_hash} }
   end
 
+  def ==(other)
+    super && self.children == other.children && self.reverse_run == other.reverse_run
+  end
+
   def inspect
     @children.map(&:inspect).join("\n").gsub(/^/, "  ")
   end

data/lib/interscript/node/item.rb

@@ -36,6 +36,10 @@ class Interscript::Node::Item < Interscript::Node
       :item => self.item }
   end
 
+  def ==(other)
+    super
+  end
+
   def self.try_convert(i)
     i = Interscript::Node::Item::String.new(i) if i.class == ::String
     raise TypeError, "Wrong type #{i.class}, expected I::Node::Item" unless Interscript::Node::Item === i

data/lib/interscript/node/item/alias.rb

@@ -10,6 +10,10 @@ class Interscript::Node::Item::Alias < Interscript::Node::Item
     !map && Interscript::Stdlib::ALIASES.has_key?(name)
   end
 
+  def boundary_like?
+    Interscript::Stdlib.boundary_like_alias?(name)
+  end
+
   def max_length
     if stdlib?
       ([:none].include? name) ? 0 : 1
@@ -19,6 +23,10 @@ class Interscript::Node::Item::Alias < Interscript::Node::Item
     end
   end
 
+  # Not implemented properly
+  def downcase; self; end
+  def upcase; self; end
+
   def first_string
     self
   end
@@ -32,6 +40,10 @@ class Interscript::Node::Item::Alias < Interscript::Node::Item
     }
   end
 
+  def ==(other)
+    super && self.name == other.name && self.map == other.map
+  end
+
   def inspect
     if map
       "map.#{map}.#{name}"

data/lib/interscript/node/item/any.rb

@@ -25,6 +25,9 @@ class Interscript::Node::Item::Any < Interscript::Node::Item
     end
   end
 
+  def downcase; self.class.new(self.data.map(&:downcase)); end
+  def upcase; self.class.new(self.data.map(&:upcase)); end
+
   def first_string
     case @value
     when Array
@@ -70,6 +73,10 @@ class Interscript::Node::Item::Any < Interscript::Node::Item
     hash
   end
 
+  def ==(other)
+    super && self.data == other.data
+  end
+
   def inspect
     "any(#{value.inspect})"
   end

data/lib/interscript/node/item/capture.rb

@@ -15,11 +15,18 @@ class Interscript::Node::Item::CaptureGroup < Interscript::Node::Item
     data.nth_string
   end
 
+  def downcase; self.dup.tap { |i| i.data = i.data.downcase }; end
+  def upcase; self.dup.tap { |i| i.data = i.data.upcase }; end
+
   def to_hash
     { :class => self.class.to_s,
       :data => self.data.to_hash }
   end
 
+  def ==(other)
+    super && self.data == other.data
+  end
+
   def inspect
     "capture(#{@data.inspect})"
   end
@@ -44,6 +51,10 @@ class Interscript::Node::Item::CaptureRef < Interscript::Node::Item
       :id => self.id }
   end
 
+  def ==(other)
+    super && self.id == other.id
+  end
+
   def inspect
     "ref(#{@id.inspect})"
   end

data/lib/interscript/node/item/group.rb

@@ -10,11 +10,35 @@ class Interscript::Node::Item::Group < Interscript::Node::Item
   def +(item)
     item = Interscript::Node::Item.try_convert(item)
     out = self.dup
-    out.children << item
+    if Interscript::Node::Item::Group === item
+      out.children += item.children
+    else
+      out.children << item
+    end
     out.verify!
     out
   end
 
+  def compact
+    out = self.dup do |n|
+      n.children = n.children.reject do |i|
+        (Interscript::Node::Alias === i && i.name == :none) ||
+        (Interscript::Node::String === i && i.data == "")
+      end
+    end
+
+    if out.children.count == 0
+      Interscript::Node::Alias.new(:none)
+    elsif out.children.count == 1
+      out.children.first
+    else
+      out
+    end
+  end
+
+  def downcase; self.dup.tap { |i| i.children = i.children.map(&:downcase) }; end
+  def upcase; self.dup.tap { |i| i.children = i.children.map(&:upcase) }; end
+
   # Verify if a group is valid
   def verify!
     wrong = @children.find do |i|
@@ -45,6 +69,10 @@ class Interscript::Node::Item::Group < Interscript::Node::Item
       :children => self.children.map{|x| x.to_hash} }
   end
 
+  def ==(other)
+    super && self.children == other.children
+  end
+
   def inspect
     @children.map(&:inspect).join("+")
   end

data/lib/interscript/node/item/repeat.rb

@@ -22,6 +22,10 @@ class Interscript::Node::Item::Repeat < Interscript::Node::Item
       :data => self.data.to_hash }
   end
 
+  def ==(other)
+    super && self.data == other.data
+  end
+
   def inspect
     str = case self
     when Interscript::Node::Item::Maybe

data/lib/interscript/node/item/stage.rb

@@ -13,6 +13,10 @@ class Interscript::Node::Item::Stage < Interscript::Node::Item
     }
   end
 
+  def ==(other)
+    super && self.name == other.name && self.map == other.map
+  end
+
   def inspect
     if map
       "map.#{@map}.stage.#{@name}"

data/lib/interscript/node/item/string.rb

@@ -17,6 +17,9 @@ class Interscript::Node::Item::String < Interscript::Node::Item
     self.data
   end
 
+  def downcase; self.dup.tap { |i| i.data = i.data.downcase }; end
+  def upcase; self.dup.tap { |i| i.data = i.data.upcase }; end
+
   alias nth_string first_string
 
   def + other
@@ -33,6 +36,10 @@ class Interscript::Node::Item::String < Interscript::Node::Item
     end
   end
 
+  def ==(other)
+    super && self.data == other.data
+  end
+
   def inspect
     @data.inspect
   end

data/lib/interscript/node/metadata.rb

@@ -11,6 +11,16 @@ class Interscript::Node::MetaData < Interscript::Node
     @data[k]
   end
 
+  def reverse
+    self.class.new(data.dup, **{}).tap do |rmd|
+      rmd[:source_script], rmd[:destination_script] = rmd[:destination_script], rmd[:source_script]
+    end
+  end
+
+  def ==(other)
+    super && self.data == other.data
+  end
+
   def to_hash
     {:class => self.class.to_s,
       :data => @data}

data/lib/interscript/node/rule.rb

@@ -1,4 +1,7 @@
 class Interscript::Node::Rule < Interscript::Node
+  def ==(other)
+    super && self.reverse_run == other.reverse_run
+  end
 end
 
 require "interscript/node/rule/sub"

data/lib/interscript/node/rule/funcall.rb

@@ -1,7 +1,8 @@
 class Interscript::Node::Rule::Funcall < Interscript::Node::Rule
-  attr_accessor :name, :kwargs
-  def initialize name, **kwargs
+  attr_accessor :name, :kwargs, :reverse_run
+  def initialize name, reverse_run: nil, **kwargs
     @name = name
+    @reverse_run = reverse_run
     @kwargs = kwargs
   end
 
@@ -12,6 +13,15 @@ class Interscript::Node::Rule::Funcall < Interscript::Node::Rule
     }
   end
 
+  def reverse
+    self.class.new(Interscript::Stdlib.reverse_function[@name.to_sym],
+      reverse_run: reverse_run.nil? ? nil : !reverse_run, **kwargs)
+  end
+
+  def ==
+    super && self.name == other.name && self.kwargs == other.kwargs
+  end
+
   def inspect
     "#{@name} #{kwargs.inspect[1..-2]}"
   end

data/lib/interscript/node/rule/run.rb

@@ -1,7 +1,8 @@
 class Interscript::Node::Rule::Run < Interscript::Node::Rule
-  attr_accessor :stage
-  def initialize stage
+  attr_accessor :stage, :reverse_run
+  def initialize stage, reverse_run: nil
     @stage = stage
+    @reverse_run = reverse_run
   end
 
   def to_hash
@@ -9,7 +10,19 @@ class Interscript::Node::Rule::Run < Interscript::Node::Rule
       :stage => self.stage.to_hash }
   end
 
+  def reverse
+    Interscript::Node::Rule::Run.new(stage,
+      reverse_run: reverse_run.nil? ? nil : !reverse_run
+    )
+  end
+
+  def ==(other)
+    super && self.stage == other.stage
+  end
+
   def inspect
-    "run #{@stage.inspect}"
+    out = "run #{@stage.inspect}"
+    out += ", reverse_run: #{@reverse_run.inspect}" unless reverse_run.nil?
+    out
   end
 end

data/lib/interscript/node/rule/sub.rb

@@ -1,12 +1,19 @@
 class Interscript::Node::Rule::Sub < Interscript::Node::Rule
   attr_accessor :from, :to
   attr_accessor :before, :not_before, :after, :not_after
+  attr_accessor :reverse_before, :reverse_not_before, :reverse_after, :reverse_not_after
+  attr_accessor :reverse_run
   attr_accessor :priority
 
-  def initialize from, to, before: nil, not_before: nil, after: nil, not_after: nil, priority: nil
+  def initialize (from, to,
+                  before: nil, not_before: nil,
+                  after: nil, not_after: nil,
+                  priority: nil, reverse_run: nil)
     self.from = Interscript::Node::Item.try_convert from
     if to == :upcase
       self.to = :upcase
+    elsif to == :downcase
+      self.to = :downcase
     else
       self.to = Interscript::Node::Item.try_convert to
     end
@@ -16,6 +23,8 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     #raise TypeError, "Can't supply both before and not_before" if before && not_before
     #raise TypeError, "Can't supply both after and not_after" if after && not_after
 
+    self.reverse_run = reverse_run
+
     self.before = Interscript::Node::Item.try_convert(before) if before
     self.after = Interscript::Node::Item.try_convert(after) if after
     self.not_before = Interscript::Node::Item.try_convert(not_before) if not_before
@@ -37,7 +46,13 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     puts params.inspect if $DEBUG
     hash = { :class => self.class.to_s,
       :from => self.from.to_hash,
-      :to => Symbol === self.to ? self.to : self.to.to_hash
+      :to => Symbol === self.to ? self.to : self.to.to_hash,
+      :reverse_run => self.reverse_run,
+      :before => self.before&.to_hash,
+      :not_before => self.not_before&.to_hash,
+      :after => self.after&.to_hash,
+      :not_after => self.not_after&.to_hash,
+      :priority => self.priority
     }
 
     hash[:before] = self.before&.to_hash if self.before
@@ -49,19 +64,165 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     hash
   end
 
+  def reverse
+    if to == :upcase
+      xfrom = from.downcase
+      xto = :downcase
+    elsif to == :downcase
+      xfrom = from.upcase
+      xto = :upcase
+    else
+      xto, xfrom = reverse_transfer(from, to)
+    end
+
+    # A special case: sub "a", "" shouldn't be present in a reverse map
+    rrun = self.reverse_run.nil? ? nil : !self.reverse_run
+    if rrun.nil? && !has_assertions? &&
+      (xfrom == "" ||
+        (Interscript::Node::Item::String === xfrom && xfrom.data == '') ||
+        (Interscript::Node::Item::Alias === xfrom && xfrom.name == :none)
+      )
+
+      rrun = true
+    end
+
+    Interscript::Node::Rule::Sub.new(xfrom, xto,
+      before: before, after: after,
+      not_before: not_before, not_after: not_after,
+
+      reverse_run: rrun,
+
+      priority: priority ? -priority : nil
+    )
+  end
+  
+  def has_assertions?
+    !!(before || not_before || not_after || after)
+  end
+
+  # Attempt to transfer some references to boundary/line_begin around.
+  # Those in general should go into before/after clauses, but for now
+  # let's try to get the best compatibility possible. Also, CaptureGroup,
+  # CaptureRef need to be shifted around
+  def reverse_transfer from, to
+    # This part is about moving initial and final boundary like aliases
+    case from
+    when Interscript::Node::Item::Group
+      first = from.children.first
+      last = from.children.last
+
+      if Interscript::Node::Item::Alias === first && first.boundary_like?
+        out = Interscript::Node::Item::Group.new + first + to
+        to = out.compact
+
+        from = from.dup.tap do |i|
+          i.children = i.children[1..-1]
+        end.compact
+      end
+
+      if Interscript::Node::Item::Alias === last && last.boundary_like?
+        out = Interscript::Node::Item::Group.new + to + last
+        to = out.compact
+
+        from = from.dup.tap do |i|
+          i.children = i.children[0..-2]
+        end.compact
+      end
+    when Interscript::Node::Item::Alias
+      if from.boundary_like?
+        to = if from.name.to_s.end_with? "_end"
+          Interscript::Node::Item::Group.new + to + from
+        else
+          Interscript::Node::Item::Group.new + from + to
+        end
+        from = Interscript::Node::Item::Alias.new(:none)
+      end
+    end
+
+    # This part is about moving backreferences
+    state = {left:[], right:[]}
+
+    from  = reverse_transfer_visit(from, :from, state)
+    to    = reverse_transfer_visit(to,   :to,   state)
+
+    [from, to]
+  end
+
+  private def reverse_transfer_visit(node, type, state)
+    node = Interscript::Node::Item.try_convert(node)
+
+    case node
+    when Interscript::Node::Item::Alias
+      if node.name == :kor_maybedash
+        state[:left] << node
+        Interscript::Node::Item::CaptureRef.new(state[:left].length)
+      else
+        node
+      end
+    when Interscript::Node::Item::String
+      node
+    when Interscript::Node::Item::Any
+      if Array === node.value
+        node.dup.tap do |i|
+          i.value = i.value.map { |c| reverse_transfer_visit(c, type, state) }
+        end
+      else
+        node
+      end
+    when Interscript::Node::Item::Group
+      node.dup.tap do |i|
+        i.children = i.children.map { |c| reverse_transfer_visit(c, type, state) }
+      end
+    when Interscript::Node::Item::Repeat
+      node.dup.tap do |i|
+        i.data = reverse_transfer_visit(i.data, type, state)
+      end
+    when Interscript::Node::Item::CaptureRef
+      if type == :from
+        node
+      elsif state[:right][node.id]
+        node
+      else
+        state[:right][node.id] = true
+        state[:left][node.id - 1] or raise "Capture count doesn't match"
+      end
+    when Interscript::Node::Item::CaptureGroup
+      state[:left] << node
+      out = Interscript::Node::Item::CaptureRef.new(state[:left].length)
+      reverse_transfer_visit(node.data, type, state) # Visit but don't care
+      out
+    else
+      raise "Type #{node.class} unhandled!"
+    end
+  end
+
+  def ==(other)
+    super &&
+    self.from == other.from &&
+    self.to == other.to &&
+    self.before == other.before &&
+    self.after == other.after &&
+    self.not_before == other.not_before &&
+    self.not_after == other.not_after &&
+    self.priority == other.priority
+  end
+
   def inspect
     out = "sub "
     params = []
     params << @from.inspect
-    if @to == :upcase
-      params << "upcase"
+    if Symbol === @to
+      params << @to.to_s
     else
       params << @to.inspect
     end
+    params << "reverse_run: #{@reverse_run.inspect}" unless @reverse_run.nil?
+
     params << "before: #{@before.inspect}" if @before
     params << "after: #{@after.inspect}" if @after
     params << "not_before: #{@not_before.inspect}" if @not_before
     params << "not_after: #{@not_after.inspect}" if @not_after
+
     params << "priority: #{@priority.inspect}" if @priority
     out << params.join(", ")
   end

data/lib/interscript/node/stage.rb

@@ -1,9 +1,10 @@
 class Interscript::Node::Stage < Interscript::Node::Group::Sequential
   attr_accessor :name, :doc_name
 
-  def initialize name = :main
+  def initialize(name = :main, reverse_run: nil, doc_name: nil)
     @name = name
-    super()
+    @doc_name = doc_name
+    super(reverse_run: reverse_run)
   end
 
   def to_hash
@@ -12,6 +13,23 @@ class Interscript::Node::Stage < Interscript::Node::Group::Sequential
       :children => @children.map{|x| x.to_hash} }
   end
 
+  def reverse
+    @reverse ||= begin
+      self.class.new(name,
+        doc_name: Interscript::Node::Document.reverse_name(doc_name),
+        reverse_run: reverse_run.nil? ? nil : !reverse_run
+      ).tap do |r|
+        r.children = self.children.reverse.map(&:reverse)
+      end
+    end
+  end
+
+  def ==(other)
+    super &&
+    self.name == other.name &&
+    self.reverse_run == other.reverse_run
+  end
+
   def inspect
     name = "(#{@name})" if @name != :main
     "stage#{name} {\n#{super}\n}"

data/lib/interscript/node/tests.rb

@@ -8,6 +8,14 @@ class Interscript::Node::Tests < Interscript::Node
     @data << pair
   end
 
+  def reverse
+    self.class.new(data.map(&:reverse))
+  end
+
+  def ==(other)
+    super && self.data == other.data
+  end
+
   def to_hash
     { :class => self.class.to_s,
       :data => @data }

data/lib/interscript/stdlib.rb

@@ -22,6 +22,10 @@ class Interscript::Stdlib
     ! %i[none space].include?(a)
   end
 
+  def self.boundary_like_alias?(a)
+    %i[line_start line_end string_start string_end boundary non_word_boundary].include?(a)
+  end
+
   @treecache = {}
 
   def self.parallel_regexp_compile(subs_hash)
@@ -167,7 +171,20 @@ class Interscript::Stdlib
   end
 
   def self.available_functions
-    %i[title_case downcase compose decompose separate secryst]
+    %i[title_case downcase compose decompose separate unseparate secryst]
+  end
+
+  def self.reverse_function
+    {
+      title_case: :downcase, # Those two are best-effort,
+      downcase: :title_case, # but probably wrong.
+
+      compose: :decompose,
+      decompose: :compose,
+
+      separate: :unseparate,
+      unseparate: :separate
+    }
   end
 
   module Functions
@@ -177,8 +194,13 @@ class Interscript::Stdlib
       output
     end
 
-    def self.downcase(output, _:nil)
-      output.downcase
+    def self.downcase(output, word_separator: nil)
+      if word_separator
+        output = output.gsub(/^(.)/, &:downcase)
+        output = output.gsub(/#{word_separator}(.)/, &:downcase) unless word_separator == ''
+      else
+        output.downcase
+      end
     end
 
     def self.compose(output, _:nil)
@@ -193,6 +215,10 @@ class Interscript::Stdlib
       output.split("").join(separator)
     end
 
+    def self.unseparate(output, separator: " ")
+      output.split(separator).join("")
+    end
+
     @secryst_models = {}
     def self.secryst(output, model:)
       require "secryst" rescue nil # Try to load secryst, but don't fail hard if not possible.

data/lib/interscript/utils/helpers.rb

@@ -0,0 +1,39 @@
+module Interscript::Utils
+  module Helpers
+    def document name=nil, &block
+      $example_id ||= 0
+      $example_id += 1
+      name ||= "example-#{$example_id}"
+
+      Interscript::DSL::Document.new(name, &block).node.tap do |i|
+        $documents ||= {}
+        $documents[name] = i
+      end
+    end
+
+    def stage &block
+      document {
+        stage(&block)
+      }
+    end
+  end
+end
+
+class Interscript::Node::Document
+  def call(str, stage=:main, compiler=$compiler || Interscript::Interpreter, **kwargs)
+    compiler.(self).(str, stage, **kwargs)
+  end
+end
+
+module Interscript::DSL
+  class << self
+    alias original_parse parse
+    def parse(map_name, **kwargs)
+      if $documents && $documents[map_name]
+        $documents[map_name]
+      else
+        original_parse(map_name, **kwargs)
+      end
+    end
+  end
+end

data/lib/interscript/version.rb

@@ -1,3 +1,3 @@
 module Interscript
-  VERSION = "2.1.0b6"
+  VERSION = "2.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interscript
 version: !ruby/object:Gem::Version
-  version: 2.1.0b6
+  version: 2.2.1
 platform: ruby
 authors:
 - Ribose Inc.
@@ -26,6 +26,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: interscript-maps
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: text
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -70,6 +84,7 @@ files:
 - lib/interscript/compiler.rb
 - lib/interscript/compiler/javascript.rb
 - lib/interscript/compiler/ruby.rb
+- lib/interscript/detector.rb
 - lib/interscript/dsl.rb
 - lib/interscript/dsl/aliases.rb
 - lib/interscript/dsl/document.rb
@@ -104,6 +119,7 @@ files:
 - lib/interscript/node/stage.rb
 - lib/interscript/node/tests.rb
 - lib/interscript/stdlib.rb
+- lib/interscript/utils/helpers.rb
 - lib/interscript/utils/regexp_converter.rb
 - lib/interscript/version.rb
 - lib/interscript/visualize.rb
@@ -129,9 +145,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.6
 signing_key: