asciidoctor-diagram 1.2.0 → 2.0.0

data/spec/plantuml_spec.rb

@@ -1,6 +1,6 @@
 require_relative 'test_helper'
 
-describe Asciidoctor::Diagram::PlantUmlBlockMacro do
+describe Asciidoctor::Diagram::PlantUmlBlockMacroProcessor do
   it "should generate PNG images when format is set to 'png'" do
     code = <<-eos
 User -> (Start)
@@ -20,25 +20,234 @@ Doc Writer <doc@example.com>
 plantuml::plantuml.txt[format="png"]
     eos
 
-    d = Asciidoctor.load StringIO.new(doc)
+    d = load_asciidoc doc
     expect(d).to_not be_nil
 
-    b = d.find { |b| b.context == :image }
+    b = d.find { |bl| bl.context == :image }
     expect(b).to_not be_nil
 
     expect(b.content_model).to eq :empty
 
     target = b.attributes['target']
     expect(target).to_not be_nil
-    expect(target).to match /\.png$/
-    expect(File.exists?(target)).to be true
+    expect(target).to match(/\.png$/)
+    expect(File.exist?(target)).to be true
 
     expect(b.attributes['width']).to_not be_nil
     expect(b.attributes['height']).to_not be_nil
   end
+
+  it "should generate PNG images when format is set to 'png'" do
+    code = <<-eos
+User -> (Start)
+User --> (Use the application) : Label
+
+:Main Admin: ---> (Use the application) : Another label
+    eos
+
+    File.write('plantuml.txt', code)
+
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+plantuml::plantuml.txt[format="png"]
+    eos
+
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.content_model).to eq :empty
+
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(target).to match(/\.png$/)
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to_not be_nil
+    expect(b.attributes['height']).to_not be_nil
+  end
+
+  it 'should support substitutions in diagram code' do
+    code = <<-eos
+class {parent-class}
+class {child-class}
+{parent-class} <|-- {child-class}
+    eos
+
+    File.write('plantuml.txt', code)
+
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+:parent-class: ParentClass
+:child-class: ChildClass
+
+== First Section
+
+plantuml::plantuml.txt[format="svg", subs=attributes+]
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'html5'}
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    content = File.read(target, :encoding => Encoding::UTF_8)
+    expect(content).to include('ParentClass')
+    expect(content).to include('ChildClass')
+  end
+
+  it 'should support substitutions in the target attribute' do
+    code = <<-eos
+class {parent-class}
+class {child-class}
+{parent-class} <|-- {child-class}
+    eos
+
+    File.write('plantuml.txt', code)
+
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+:file: plantuml
+:parent-class: ParentClass
+:child-class: ChildClass
+
+== First Section
+
+plantuml::{file}.txt[format="svg", subs=attributes+]
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'html5'}
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    content = File.read(target, :encoding => Encoding::UTF_8)
+    expect(content).to include('ParentClass')
+    expect(content).to include('ChildClass')
+  end
+
+  it 'should support substitutions in the format attribute' do
+    code = <<-eos
+class Parent
+class Child
+Parent <|-- Child
+    eos
+
+    File.write('plantuml.txt', code)
+
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+:file: plantuml
+:plantumlformat: png
+
+== First Section
+
+plantuml::{file}.txt[format="{plantumlformat}", subs=attributes+]
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'html5'}
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(target).to match(/\.png$/)
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to_not be_nil
+    expect(b.attributes['height']).to_not be_nil
+  end
+
+  it 'should resolve !include directives with relative paths' do
+    included = <<-eos
+interface List
+List : int size()
+List : void clear()
+    eos
+
+    code = <<-eos
+!include list.iuml
+List <|.. ArrayList
+    eos
+
+    Dir.mkdir('dir')
+    File.write('dir/list.iuml', included)
+    File.write('dir/plantuml.txt', code)
+
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+:parent-class: ParentClass
+:child-class: ChildClass
+
+== First Section
+
+plantuml::dir/plantuml.txt[format="svg", subs=attributes+]
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'html5'}
+
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    content = File.read(target, :encoding => Encoding::UTF_8)
+    expect(content).to_not include('!include')
+  end
+
+  it 'should generate blocks with figure captions' do
+    code = <<-eos
+User -> (Start)
+User --> (Use the application) : Label
+
+:Main Admin: ---> (Use the application) : Another label
+    eos
+
+    File.write('plantuml.txt', code)
+
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+.This is a UML diagram
+plantuml::plantuml.txt[format="png"]
+    eos
+
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.caption).to match(/Figure \d+/)
+  end
 end
 
-describe Asciidoctor::Diagram::PlantUmlBlock do
+describe Asciidoctor::Diagram::PlantUmlBlockProcessor do
   it "should generate PNG images when format is set to 'png'" do
     doc = <<-eos
 = Hello, PlantUML!
@@ -55,18 +264,18 @@ User --> (Use the application) : Label
 ----
     eos
 
-    d = Asciidoctor.load StringIO.new(doc)
+    d = load_asciidoc doc
     expect(d).to_not be_nil
 
-    b = d.find { |b| b.context == :image }
+    b = d.find { |bl| bl.context == :image }
     expect(b).to_not be_nil
 
     expect(b.content_model).to eq :empty
 
     target = b.attributes['target']
     expect(target).to_not be_nil
-    expect(target).to match /\.png$/
-    expect(File.exists?(target)).to be true
+    expect(target).to match(/\.png$/)
+    expect(File.exist?(target)).to be true
 
     expect(b.attributes['width']).to_not be_nil
     expect(b.attributes['height']).to_not be_nil
@@ -88,18 +297,89 @@ User --> (Use the application) : Label
 ----
     eos
 
-    d = Asciidoctor.load StringIO.new(doc)
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.content_model).to eq :empty
+
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(target).to match(/\.svg/)
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to_not be_nil
+    expect(b.attributes['height']).to_not be_nil
+  end
+
+  it "should respect the svg-type attribute when format is set to 'svg'" do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="svg", svg-type="inline"]
+----
+User -> (Start)
+User --> (Use the application) : Label
+
+:Main Admin: ---> (Use the application) : Another label
+----
+    eos
+
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.content_model).to eq :empty
+
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(target).to match(/\.svg/)
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['opts']).to eq('inline')
+
+    expect(b.attributes['width']).to_not be_nil
+    expect(b.attributes['height']).to_not be_nil
+  end
+
+  it "should respect the diagram-svg-type attribute when format is set to 'svg'" do
+    doc = <<-eos
+= Hello, PlantUML!
+:diagram-svg-type: inline
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="svg"]
+----
+User -> (Start)
+User --> (Use the application) : Label
+
+:Main Admin: ---> (Use the application) : Another label
+----
+    eos
+
+    d = load_asciidoc doc
     expect(d).to_not be_nil
 
-    b = d.find { |b| b.context == :image }
+    b = d.find { |bl| bl.context == :image }
     expect(b).to_not be_nil
 
     expect(b.content_model).to eq :empty
 
     target = b.attributes['target']
     expect(target).to_not be_nil
-    expect(target).to match /\.svg/
-    expect(File.exists?(target)).to be true
+    expect(target).to match(/\.svg/)
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['opts']).to eq('inline')
 
     expect(b.attributes['width']).to_not be_nil
     expect(b.attributes['height']).to_not be_nil
@@ -121,10 +401,10 @@ User --> (Use the application) : Label
 ----
     eos
 
-    d = Asciidoctor.load StringIO.new(doc)
+    d = load_asciidoc doc
     expect(d).to_not be_nil
 
-    b = d.find { |b| b.context == :literal }
+    b = d.find { |bl| bl.context == :literal }
     expect(b).to_not be_nil
 
     expect(b.content_model).to eq :verbatim
@@ -132,7 +412,7 @@ User --> (Use the application) : Label
     expect(b.attributes['target']).to be_nil
   end
 
-  it "should raise an error when when format is set to an invalid value" do
+  it 'should raise an error when when format is set to an invalid value' do
     doc = <<-eos
 = Hello, PlantUML!
 Doc Writer <doc@example.com>
@@ -144,18 +424,19 @@ Doc Writer <doc@example.com>
 ----
     eos
 
-    expect { Asciidoctor.load StringIO.new(doc) }.to raise_error /support.*format/i
+    expect { load_asciidoc doc }.to raise_error(/support.*format/i)
   end
 
-  it "should use plantuml configuration when specified as a document attribute" do
+  it 'should use plantuml configuration when specified as a document attribute' do
     doc = <<-eos
 = Hello, PlantUML!
 Doc Writer <doc@example.com>
-:plantumlconfig: test.config
+:plantuml-config: test.config
+:plantuml-format: svg
 
 == First Section
 
-[plantuml, format="svg"]
+[plantuml]
 ----
 actor Foo1
 boundary Foo2
@@ -164,25 +445,25 @@ Foo1 -> Foo2 : To boundary
     eos
 
     config = <<-eos
-ArrowColor #DEADBE
+skinparam ArrowColor #DEADBE
     eos
 
     File.open('test.config', 'w') do |f|
       f.write config
     end
 
-    d = Asciidoctor.load StringIO.new(doc)
-    b = d.find { |b| b.context == :image }
+    d = load_asciidoc doc
+    b = d.find { |bl| bl.context == :image }
 
     target = b.attributes['target']
     expect(target).to_not be_nil
-    expect(File.exists?(target)).to be true
+    expect(File.exist?(target)).to be true
 
-    svg = File.read(target)
-    expect(svg).to match /<path.*fill="#DEADBE"/
+    svg = File.read(target, :encoding => Encoding::UTF_8)
+    expect(svg).to match(/<path.*fill="#DEADBE"/)
   end
 
-  it "should not regenerate images when source has not changed" do
+  it 'should not regenerate images when source has not changed' do
     code = <<-eos
 User -> (Start)
 User --> (Use the application) : Label
@@ -208,21 +489,21 @@ Foo1 -> Foo2 : To boundary
 ----
     eos
 
-    d = Asciidoctor.load StringIO.new(doc)
-    b = d.find { |b| b.context == :image }
+    d = load_asciidoc doc
+    b = d.find { |bl| bl.context == :image }
     target = b.attributes['target']
     mtime1 = File.mtime(target)
 
     sleep 1
 
-    d = Asciidoctor.load StringIO.new(doc)
+    d = load_asciidoc doc
 
     mtime2 = File.mtime(target)
 
     expect(mtime2).to eq mtime1
   end
 
-  it "should handle two block macros with the same source" do
+  it 'should handle two block macros with the same source' do
     code = <<-eos
 User -> (Start)
 User --> (Use the application) : Label
@@ -242,11 +523,11 @@ plantuml::plantuml.txt[]
 plantuml::plantuml.txt[]
     eos
 
-    Asciidoctor.load StringIO.new(doc)
-    expect(File.exists?('plantuml.png')).to be true
+    load_asciidoc doc
+    expect(File.exist?('plantuml.png')).to be true
   end
 
-  it "should respect target attribute in block macros" do
+  it 'should respect target attribute in block macros' do
     code = <<-eos
 User -> (Start)
 User --> (Use the application) : Label
@@ -266,14 +547,39 @@ plantuml::plantuml.txt["foobar"]
 plantuml::plantuml.txt["foobaz"]
     eos
 
-    Asciidoctor.load StringIO.new(doc)
-    expect(File.exists?('foobar.png')).to be true
-    expect(File.exists?('foobaz.png')).to be true
-    expect(File.exists?('plantuml.png')).to be false
+    load_asciidoc doc
+    expect(File.exist?('foobar.png')).to be true
+    expect(File.exist?('foobaz.png')).to be true
+    expect(File.exist?('plantuml.png')).to be false
   end
 
+  it 'should respect target attribute values with relative paths in block macros' do
+    code = <<-eos
+User -> (Start)
+User --> (Use the application) : Label
+
+:Main Admin: ---> (Use the application) : Another label
+    eos
+
+    File.write('plantuml.txt', code)
+
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+plantuml::plantuml.txt["test/foobar"]
+plantuml::plantuml.txt["test2/foobaz"]
+    eos
+
+    load_asciidoc doc
+    expect(File.exist?('test/foobar.png')).to be true
+    expect(File.exist?('test2/foobaz.png')).to be true
+    expect(File.exist?('plantuml.png')).to be false
+  end
 
-  it "should write files to outdir if set" do
+  it 'should write files to outdir if set' do
     doc = <<-eos
 = Hello, PlantUML!
 Doc Writer <doc@example.com>
@@ -288,38 +594,573 @@ Foo1 -> Foo2 : To boundary
 ----
     eos
 
-    d = Asciidoctor.load StringIO.new(doc), {:attributes => {'outdir' => 'foo'}}
-    b = d.find { |b| b.context == :image }
+    d = load_asciidoc doc, {:attributes => {'outdir' => 'foo'}}
+    b = d.find { |bl| bl.context == :image }
 
     target = b.attributes['target']
     expect(target).to_not be_nil
-    expect(File.exists?(target)).to be false
-    expect(File.exists?(File.expand_path(target, 'foo'))).to be true
+    expect(File.exist?(target)).to be false
+    expect(File.exist?(File.expand_path(target, 'foo'))).to be true
   end
 
-  it "should omit width/height attributes when generating docbook" do
+  it 'should write files to to_dir if set' do
     doc = <<-eos
 = Hello, PlantUML!
 Doc Writer <doc@example.com>
 
 == First Section
 
-[plantuml, format="png"]
+[plantuml, format="svg"]
 ----
-User -> (Start)
+actor Foo1
+boundary Foo2
+Foo1 -> Foo2 : To boundary
 ----
     eos
 
-    d = Asciidoctor.load StringIO.new(doc), :attributes => {'backend' => 'docbook5' }
-    expect(d).to_not be_nil
+    d = load_asciidoc doc, {:to_dir => 'foo'}
+    b = d.find { |bl| bl.context == :image }
 
-    b = d.find { |b| b.context == :image }
-    expect(b).to_not be_nil
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(File.exist?(target)).to be false
+    expect(File.exist?(File.expand_path(target, 'foo'))).to be true
+  end
+
+  it 'should write files to to_dir if set when embedded in table' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+|===
+|Type | Example
+
+|graphviz
+a|
+[plantuml, format="svg"]
+----
+actor Foo1
+boundary Foo2
+Foo1 -> Foo2 : To boundary
+----
+|===
+    eos
+
+    d = load_asciidoc doc, {:to_dir => 'foo'}
+    b = d.find { |bl| bl.context == :image }
 
     target = b.attributes['target']
-    expect(File.exists?(target)).to be true
+    expect(target).to_not be_nil
+    expect(File.exist?(target)).to be false
+    expect(File.exist?(File.expand_path(target, 'foo'))).to be true
+  end
 
-    expect(b.attributes['width']).to be_nil
-    expect(b.attributes['height']).to be_nil
+  it 'should write files to imagesoutdir if set' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="svg"]
+----
+actor Foo1
+boundary Foo2
+Foo1 -> Foo2 : To boundary
+----
+    eos
+
+    d = load_asciidoc doc, {:attributes => {'imagesoutdir' => 'bar', 'outdir' => 'foo'}}
+    b = d.find { |bl| bl.context == :image }
+
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(File.exist?(target)).to be false
+    expect(File.exist?(File.expand_path(target, 'bar'))).to be true
+    expect(File.exist?(File.expand_path(target, 'foo'))).to be false
+  end
+
+  it 'should omit width/height attributes when generating docbook' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="png"]
+----
+User -> (Start)
+----
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'docbook5'}
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to be_nil
+    expect(b.attributes['height']).to be_nil
+  end
+
+  it 'should generate blocks with figure captions' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+.Caption for my UML diagram
+[plantuml, format="png"]
+----
+User -> (Start)
+----
+    eos
+
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.caption).to match(/Figure \d+/)
+  end
+
+  it 'should support salt diagrams using salt block type' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[salt, format="png"]
+----
+{
+  Just plain text
+  [This is my button]
+  ()  Unchecked radio
+  (X) Checked radio
+  []  Unchecked box
+  [X] Checked box
+  "Enter text here   "
+  ^This is a droplist^
+}
+----
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'docbook5'}
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to be_nil
+    expect(b.attributes['height']).to be_nil
+  end
+
+  it 'should support salt diagrams using plantuml block type' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="png"]
+----
+salt
+{
+  Just plain text
+  [This is my button]
+  ()  Unchecked radio
+  (X) Checked radio
+  []  Unchecked box
+  [X] Checked box
+  "Enter text here   "
+  ^This is a droplist^
+}
+----
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'docbook5'}
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to be_nil
+    expect(b.attributes['height']).to be_nil
+  end
+
+  it 'should support salt diagrams containing tree widgets' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="png"]
+----
+salt
+{
+{T
++A
+++a
+}
+}
+----
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'docbook5'}
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to be_nil
+    expect(b.attributes['height']).to be_nil
+  end
+
+  it 'should support scaling diagrams' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="png"]
+----
+A -> B
+----
+    eos
+
+    scaled_doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="png", scale="1.5"]
+----
+A -> B
+----
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'html5'}
+    unscaled_image = d.find { |bl| bl.context == :image }
+
+    d = load_asciidoc scaled_doc, :attributes => {'backend' => 'html5'}
+    scaled_image = d.find { |bl| bl.context == :image }
+
+    expect(scaled_image.attributes['width']).to be_within(1).of(unscaled_image.attributes['width'] * 1.5)
+    expect(scaled_image.attributes['height']).to be_within(1).of(unscaled_image.attributes['height'] * 1.5)
+  end
+
+  it 'should handle embedded creole images correctly' do
+    creole_doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="png"]
+----
+:* You can change <color:red>text color</color>
+* You can change <back:cadetblue>background color</back>
+* You can change <size:18>size</size>
+* You use <u>legacy</u> <b>HTML <i>tag</i></b>
+* You use <u:red>color</u> <s:green>in HTML</s> <w:#0000FF>tag</w>
+* Use image : <img:sourceforge.jpg>
+* Use image : <img:http://www.foo.bar/sourceforge.jpg>
+* Use image : <img:file:///sourceforge.jpg>
+
+;
+----
+    eos
+
+    load_asciidoc creole_doc, :attributes => {'backend' => 'html5'}
+
+    # No real way to assert this since PlantUML doesn't produce an error on file not found
+  end
+
+  it 'should resolve !include directives with relative paths' do
+    included = <<-eos
+interface List
+List : int size()
+List : void clear()
+    eos
+
+    sub = <<-eos
+@startuml
+A -> A : stuff1
+!startsub BASIC
+B -> B : stuff2
+!endsub
+C -> C : stuff3
+!startsub BASIC
+D -> D : stuff4
+!endsub
+@enduml
+    eos
+
+    Dir.mkdir('dir')
+    File.write('dir/List.iuml', included)
+    File.write('dir/Sub.iuml', sub)
+
+    creole_doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="svg"]
+----
+!include dir/List.iuml
+!includesub dir/Sub.iuml!BASIC
+List <|.. ArrayList
+----
+    eos
+
+    d = load_asciidoc creole_doc, :attributes => {'backend' => 'html5'}
+
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    content = File.read(target, :encoding => Encoding::UTF_8)
+    expect(content).to_not include('!include')
+    expect(content).to_not include('!includesub')
+  end
+
+  it 'should not resolve stdlib !include directives' do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml, format="svg"]
+----
+@startuml
+!include <tupadr3/common>
+!include <tupadr3/font-awesome/server>
+!include <tupadr3/font-awesome/database>
+
+title Styling example
+
+FA_SERVER(web1,web1) #Green
+FA_SERVER(web2,web2) #Yellow
+FA_SERVER(web3,web3) #Blue
+FA_SERVER(web4,web4) #YellowGreen
+
+FA_DATABASE(db1,LIVE,database,white) #RoyalBlue
+FA_DATABASE(db2,SPARE,database) #Red
+
+db1 <--> db2
+
+web1 <--> db1
+web2 <--> db1
+web3 <--> db1
+web4 <--> db1
+@enduml
+----
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'html5'}
+
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    content = File.read(target, :encoding => Encoding::UTF_8)
+    expect(content).to_not include('!include')
+  end
+
+  it 'should support substitutions' do
+    doc = <<-eos
+= Hello, PlantUML!
+:parent-class: ParentClass
+:child-class: ChildClass
+
+[plantuml,class-inheritence,svg,subs=attributes+]
+....
+class {parent-class}
+class {child-class}
+{parent-class} <|-- {child-class}
+....
+    eos
+
+    d = load_asciidoc doc, :attributes => {'backend' => 'html5'}
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    target = b.attributes['target']
+    expect(File.exist?(target)).to be true
+
+    content = File.read(target, :encoding => Encoding::UTF_8)
+    expect(content).to include('ParentClass')
+    expect(content).to include('ChildClass')
+  end
+
+  it "should generate PNG images for jlatexmath blocks when format is set to 'png'" do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml,format="png"]
+----
+@startlatex
+e^{i\\pi} + 1 = 0
+@endlatex
+----
+    eos
+
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.content_model).to eq :empty
+
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(target).to match(/\.png$/)
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to_not be_nil
+    expect(b.attributes['height']).to_not be_nil
+  end
+
+  it "should generate SVG images for jlatexmath blocks when format is set to 'svg'" do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml,format="svg"]
+----
+@startlatex
+e^{i\\pi} + 1 = 0
+@endlatex
+----
+    eos
+
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.content_model).to eq :empty
+
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(target).to match(/\.svg$/)
+    expect(File.exist?(target)).to be true
+  end
+
+  it "should generate PNG images for diagrams with latex tags when format is set to 'png'" do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml,format="png"]
+----
+:<latex>P(y|\\mathbf{x}) \\mbox{ or } f(\\mathbf{x})+\\epsilon</latex>;
+----
+    eos
+
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.content_model).to eq :empty
+
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(target).to match(/\.png$/)
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to_not be_nil
+    expect(b.attributes['height']).to_not be_nil
+  end
+
+  it "should generate SVG images for diagrams with latex tags when format is set to 'svg'" do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml,format="svg"]
+----
+:<latex>P(y|\\mathbf{x}) \\mbox{ or } f(\\mathbf{x})+\\epsilon</latex>;
+----
+    eos
+
+    d = load_asciidoc doc
+    expect(d).to_not be_nil
+
+    b = d.find { |bl| bl.context == :image }
+    expect(b).to_not be_nil
+
+    expect(b.content_model).to eq :empty
+
+    target = b.attributes['target']
+    expect(target).to_not be_nil
+    expect(target).to match(/\.svg$/)
+    expect(File.exist?(target)).to be true
+
+    expect(b.attributes['width']).to_not be_nil
+    expect(b.attributes['height']).to_not be_nil
+  end
+
+  it "should report syntax errors" do
+    doc = <<-eos
+= Hello, PlantUML!
+Doc Writer <doc@example.com>
+
+== First Section
+
+[plantuml,format="svg"]
+----
+Bob; Alice; foo
+----
+    eos
+
+    expect {
+      load_asciidoc doc
+    }.to raise_error(/syntax error/i)
   end
 end