Add composability, ref: #465

Author: webdev778

README.adoc

@@ -108,6 +108,27 @@ It is then easy to see the exact differences in rendering between the systems.
 diff bgnpcgn-rus-Latn.txt bas-rus-Latn.txt
 ----
 
+You can also run some maps in reverse (warning: not all maps are made to be reversed),
+either by changing an order of character sets in a name (for bas-rus-`Cyrl-Latn`-2017-bss
+it would be bas-rus-`Latn-Cyrl`-2017-bss) or appending `-reverse` to their name:
+
+[source,sh]
+----
+interscript my_jamos.txt \
+  --system=var-kor-Hang-Hang-jamo-reverse \
+  --output=my_hangul.txt
+----
+
+You can also compose some maps, by joining their names with `|` (similar to how bash
+pipe works). For instance:
+
+[source,sh]
+----
+interscript my_file.txt \
+  --system='var-map1-Xxxx-Xxxx|var-map2-Xxxx-Xxxx' \
+  --output=my_output.txt
+----
+
 If you use Interscript from the Git repository, you would call the following command
 instead of `interscript`:
 

ruby/lib/interscript/dsl.rb

@@ -2,18 +2,39 @@
 
 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]
 
-    reverse = false
+    # 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
-        reverse = map_name
-        Interscript.locate(Interscript::Node::Document.reverse_name(map_name))
+        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
@@ -66,12 +87,6 @@ def self.parse(map_name)
     obj.node.metadata = md.node
 
     @cache[map_name] = obj.node
-
-    if reverse
-      @cache[reverse] = @cache[map_name].reverse
-    else
-      @cache[map_name]
-    end
   end
 end
 

ruby/lib/interscript/utils/helpers.rb

@@ -28,11 +28,11 @@ def call(str, stage=:main, compiler=$compiler || Interscript::Interpreter, **kwa
 module Interscript::DSL
   class << self
     alias original_parse parse
-    def parse(map_name)
+    def parse(map_name, **kwargs)
       if $documents && $documents[map_name]
         $documents[map_name]
       else
-        original_parse(map_name)
+        original_parse(map_name, **kwargs)
       end
     end
   end

ruby/spec/composability_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe "composability" do
+  it "can depend on reversed maps" do
+    a = document("part-1-One-Two") {
+      stage {
+        sub "a", "b"
+      }
+    }
+
+    b = document("part-2-One-Two") {
+      stage {
+        sub "c", "d"
+      }
+    }
+
+    c = document("composed") {
+      dependency "part-1-Two-One", as: twoone
+      dependency "part-2-One-Two", as: onetwo
+
+      stage {
+        run map.twoone.stage.main
+        run map.onetwo.stage.main
+      }
+    }
+
+    expect(c.("abcd")).to eq("aadd")
+  end
+
+  it "can seamlessly compose two maps" do
+    a = document("part1") {
+      stage {
+        sub "a", "b"
+      }
+    }
+    b = document("part2") {
+      stage {
+        sub "c", "d"
+      }
+    }
+
+    c = document("composed2") {
+      dependency "part1|part2", as: composed
+
+      stage {
+        run map.composed.stage.main
+      }
+    }
+
+    expect(c.("abcd")).to eq("bbdd")
+  end
+end