drawio_dsl 0.7.0 → 0.8.2

data/lib/drawio_dsl/dom_builder_shapes.rb

@@ -4,197 +4,248 @@
 module DrawioDsl
   # DrawioDsl is a DSL for draw-io diagrams.
   module DomBuilderShapes
-    def add_h1(**opts, &block)
+    def add_h1(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       h1 = DrawioDsl::Schema::H1.new(current_page, **opts, &block)
       add_shape(h1)
     end
 
-    def add_h2(**opts, &block)
+    def add_h2(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       h2 = DrawioDsl::Schema::H2.new(current_page, **opts, &block)
       add_shape(h2)
     end
 
-    def add_h3(**opts, &block)
+    def add_h3(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       h3 = DrawioDsl::Schema::H3.new(current_page, **opts, &block)
       add_shape(h3)
     end
 
-    def add_h4(**opts, &block)
+    def add_h4(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       h4 = DrawioDsl::Schema::H4.new(current_page, **opts, &block)
       add_shape(h4)
     end
 
-    def add_h5(**opts, &block)
+    def add_h5(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       h5 = DrawioDsl::Schema::H5.new(current_page, **opts, &block)
       add_shape(h5)
     end
 
-    def add_h6(**opts, &block)
+    def add_h6(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       h6 = DrawioDsl::Schema::H6.new(current_page, **opts, &block)
       add_shape(h6)
     end
 
-    def add_p(**opts, &block)
+    def add_p(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       p = DrawioDsl::Schema::P.new(current_page, **opts, &block)
       add_shape(p)
     end
 
-    def add_actor(**opts, &block)
+    def add_actor(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       actor = DrawioDsl::Schema::Actor.new(current_page, **opts, &block)
       add_shape(actor)
     end
 
-    def add_actor2(**opts, &block)
+    def add_actor2(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       actor2 = DrawioDsl::Schema::Actor2.new(current_page, **opts, &block)
       add_shape(actor2)
     end
 
-    def add_callout(**opts, &block)
+    def add_callout(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       callout = DrawioDsl::Schema::Callout.new(current_page, **opts, &block)
       add_shape(callout)
     end
 
-    def add_callout2(**opts, &block)
+    def add_callout2(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       callout2 = DrawioDsl::Schema::Callout2.new(current_page, **opts, &block)
       add_shape(callout2)
     end
 
-    def add_callout3(**opts, &block)
+    def add_callout3(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       callout3 = DrawioDsl::Schema::Callout3.new(current_page, **opts, &block)
       add_shape(callout3)
     end
 
-    def add_callout4(**opts, &block)
+    def add_callout4(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       callout4 = DrawioDsl::Schema::Callout4.new(current_page, **opts, &block)
       add_shape(callout4)
     end
 
-    def add_circle(**opts, &block)
+    def add_circle(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       circle = DrawioDsl::Schema::Circle.new(current_page, **opts, &block)
       add_shape(circle)
     end
 
-    def add_cloud(**opts, &block)
+    def add_cloud(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       cloud = DrawioDsl::Schema::Cloud.new(current_page, **opts, &block)
       add_shape(cloud)
     end
 
-    def add_container(**opts, &block)
+    def add_container(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       container = DrawioDsl::Schema::Container.new(current_page, **opts, &block)
       add_shape(container)
     end
 
-    def add_container2(**opts, &block)
+    def add_container2(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       container2 = DrawioDsl::Schema::Container2.new(current_page, **opts, &block)
       add_shape(container2)
     end
 
-    def add_container3(**opts, &block)
+    def add_container3(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       container3 = DrawioDsl::Schema::Container3.new(current_page, **opts, &block)
       add_shape(container3)
     end
 
-    def add_container4(**opts, &block)
+    def add_container4(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       container4 = DrawioDsl::Schema::Container4.new(current_page, **opts, &block)
       add_shape(container4)
     end
 
-    def add_cross(**opts, &block)
+    def add_cross(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       cross = DrawioDsl::Schema::Cross.new(current_page, **opts, &block)
       add_shape(cross)
     end
 
-    def add_envelop(**opts, &block)
+    def add_envelop(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       envelop = DrawioDsl::Schema::Envelop.new(current_page, **opts, &block)
       add_shape(envelop)
     end
 
-    def add_diamond(**opts, &block)
+    def add_diamond(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       diamond = DrawioDsl::Schema::Diamond.new(current_page, **opts, &block)
       add_shape(diamond)
     end
 
-    def add_document(**opts, &block)
+    def add_document(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       document = DrawioDsl::Schema::Document.new(current_page, **opts, &block)
       add_shape(document)
     end
 
-    def add_ellipse(**opts, &block)
+    def add_ellipse(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       ellipse = DrawioDsl::Schema::Ellipse.new(current_page, **opts, &block)
       add_shape(ellipse)
     end
 
-    def add_hexagon(**opts, &block)
+    def add_hexagon(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       hexagon = DrawioDsl::Schema::Hexagon.new(current_page, **opts, &block)
       add_shape(hexagon)
     end
 
-    def add_interface(**opts, &block)
+    def add_interface(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       interface = DrawioDsl::Schema::Interface.new(current_page, **opts, &block)
       add_shape(interface)
     end
 
-    def add_klass(**opts, &block)
+    def add_klass(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       klass = DrawioDsl::Schema::Klass.new(current_page, **opts, &block)
       add_shape(klass)
     end
 
-    def add_note(**opts, &block)
+    def add_note(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       note = DrawioDsl::Schema::Note.new(current_page, **opts, &block)
       add_shape(note)
     end
 
-    def add_process(**opts, &block)
+    def add_process(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       process = DrawioDsl::Schema::Process.new(current_page, **opts, &block)
       add_shape(process)
     end
 
-    def add_rectangle(**opts, &block)
+    def add_rectangle(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       rectangle = DrawioDsl::Schema::Rectangle.new(current_page, **opts, &block)
       add_shape(rectangle)
     end
 
-    def add_rectangle2(**opts, &block)
+    def add_rectangle2(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       rectangle2 = DrawioDsl::Schema::Rectangle2.new(current_page, **opts, &block)
       add_shape(rectangle2)
     end
 
-    def add_square(**opts, &block)
+    def add_square(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       square = DrawioDsl::Schema::Square.new(current_page, **opts, &block)
       add_shape(square)
     end
 
-    def add_step(**opts, &block)
+    def add_step(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       step = DrawioDsl::Schema::Step.new(current_page, **opts, &block)
       add_shape(step)
     end
 
-    def add_tick(**opts, &block)
+    def add_tick(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       tick = DrawioDsl::Schema::Tick.new(current_page, **opts, &block)
       add_shape(tick)
     end
 
-    def add_face(**opts, &block)
+    def add_todo(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
+      todo = DrawioDsl::Schema::Todo.new(current_page, **opts, &block)
+      add_shape(todo)
+    end
+
+    def add_face(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       face = DrawioDsl::Schema::Face.new(current_page, **opts, &block)
       add_shape(face)
     end
 
-    def add_triangle(**opts, &block)
+    def add_triangle(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       triangle = DrawioDsl::Schema::Triangle.new(current_page, **opts, &block)
       add_shape(triangle)
     end
 
-    def add_embed_row(**opts, &block)
+    def add_line(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
+      line = DrawioDsl::Schema::Line.new(current_page, **opts, &block)
+      add_shape(line)
+    end
+
+    def add_embed_row(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       embed_row = DrawioDsl::Schema::EmbedRow.new(current_page, **opts, &block)
       add_shape(embed_row)
     end
 
-    def add_embed_col50(**opts, &block)
+    def add_embed_col50(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       embed_col50 = DrawioDsl::Schema::EmbedCol50.new(current_page, **opts, &block)
       add_shape(embed_col50)
     end
 
-    def add_embed_col200(**opts, &block)
+    def add_embed_col200(id = nil, **opts, &block)
+      opts = { id: id }.merge(opts) if id
       embed_col200 = DrawioDsl::Schema::EmbedCol200.new(current_page, **opts, &block)
       add_shape(embed_col200)
     end

data/lib/drawio_dsl/drawio_shapes.rb

@@ -5,7 +5,7 @@ module DrawioDsl
   # :nocov:
   module DrawioShapes
     def random(**opts)
-      case rand(39)
+      case rand(41)
       when 0
         h1(**opts)
       when 1
@@ -75,172 +75,184 @@ module DrawioDsl
       when 33
         tick(**opts)
       when 34
-        face(**opts)
+        todo(**opts)
       when 35
-        triangle(**opts)
+        face(**opts)
       when 36
-        embed_row(**opts)
+        triangle(**opts)
       when 37
-        embed_col50(**opts)
+        line(**opts)
       when 38
+        embed_row(**opts)
+      when 39
+        embed_col50(**opts)
+      when 40
         embed_col200(**opts)
       end
     end
 
-    def h1(**opts, &block)
-      builder.add_h1(**opts, &block)
+    def h1(id = nil, **opts, &block)
+      builder.add_h1(id, **opts, &block)
+    end
+
+    def h2(id = nil, **opts, &block)
+      builder.add_h2(id, **opts, &block)
+    end
+
+    def h3(id = nil, **opts, &block)
+      builder.add_h3(id, **opts, &block)
     end
 
-    def h2(**opts, &block)
-      builder.add_h2(**opts, &block)
+    def h4(id = nil, **opts, &block)
+      builder.add_h4(id, **opts, &block)
     end
 
-    def h3(**opts, &block)
-      builder.add_h3(**opts, &block)
+    def h5(id = nil, **opts, &block)
+      builder.add_h5(id, **opts, &block)
     end
 
-    def h4(**opts, &block)
-      builder.add_h4(**opts, &block)
+    def h6(id = nil, **opts, &block)
+      builder.add_h6(id, **opts, &block)
     end
 
-    def h5(**opts, &block)
-      builder.add_h5(**opts, &block)
+    def p(id = nil, **opts, &block)
+      builder.add_p(id, **opts, &block)
     end
 
-    def h6(**opts, &block)
-      builder.add_h6(**opts, &block)
+    def actor(id = nil, **opts, &block)
+      builder.add_actor(id, **opts, &block)
     end
 
-    def p(**opts, &block)
-      builder.add_p(**opts, &block)
+    def actor2(id = nil, **opts, &block)
+      builder.add_actor2(id, **opts, &block)
     end
 
-    def actor(**opts, &block)
-      builder.add_actor(**opts, &block)
+    def callout(id = nil, **opts, &block)
+      builder.add_callout(id, **opts, &block)
     end
 
-    def actor2(**opts, &block)
-      builder.add_actor2(**opts, &block)
+    def callout2(id = nil, **opts, &block)
+      builder.add_callout2(id, **opts, &block)
     end
 
-    def callout(**opts, &block)
-      builder.add_callout(**opts, &block)
+    def callout3(id = nil, **opts, &block)
+      builder.add_callout3(id, **opts, &block)
     end
 
-    def callout2(**opts, &block)
-      builder.add_callout2(**opts, &block)
+    def callout4(id = nil, **opts, &block)
+      builder.add_callout4(id, **opts, &block)
     end
 
-    def callout3(**opts, &block)
-      builder.add_callout3(**opts, &block)
+    def circle(id = nil, **opts, &block)
+      builder.add_circle(id, **opts, &block)
     end
 
-    def callout4(**opts, &block)
-      builder.add_callout4(**opts, &block)
+    def cloud(id = nil, **opts, &block)
+      builder.add_cloud(id, **opts, &block)
     end
 
-    def circle(**opts, &block)
-      builder.add_circle(**opts, &block)
+    def container(id = nil, **opts, &block)
+      builder.add_container(id, **opts, &block)
     end
 
-    def cloud(**opts, &block)
-      builder.add_cloud(**opts, &block)
+    def container2(id = nil, **opts, &block)
+      builder.add_container2(id, **opts, &block)
     end
 
-    def container(**opts, &block)
-      builder.add_container(**opts, &block)
+    def container3(id = nil, **opts, &block)
+      builder.add_container3(id, **opts, &block)
     end
 
-    def container2(**opts, &block)
-      builder.add_container2(**opts, &block)
+    def container4(id = nil, **opts, &block)
+      builder.add_container4(id, **opts, &block)
     end
 
-    def container3(**opts, &block)
-      builder.add_container3(**opts, &block)
+    def cross(id = nil, **opts, &block)
+      builder.add_cross(id, **opts, &block)
     end
 
-    def container4(**opts, &block)
-      builder.add_container4(**opts, &block)
+    def envelop(id = nil, **opts, &block)
+      builder.add_envelop(id, **opts, &block)
     end
 
-    def cross(**opts, &block)
-      builder.add_cross(**opts, &block)
+    def diamond(id = nil, **opts, &block)
+      builder.add_diamond(id, **opts, &block)
     end
 
-    def envelop(**opts, &block)
-      builder.add_envelop(**opts, &block)
+    def document(id = nil, **opts, &block)
+      builder.add_document(id, **opts, &block)
     end
 
-    def diamond(**opts, &block)
-      builder.add_diamond(**opts, &block)
+    def ellipse(id = nil, **opts, &block)
+      builder.add_ellipse(id, **opts, &block)
     end
 
-    def document(**opts, &block)
-      builder.add_document(**opts, &block)
+    def hexagon(id = nil, **opts, &block)
+      builder.add_hexagon(id, **opts, &block)
     end
 
-    def ellipse(**opts, &block)
-      builder.add_ellipse(**opts, &block)
+    def interface(id = nil, **opts, &block)
+      builder.add_interface(id, **opts, &block)
     end
 
-    def hexagon(**opts, &block)
-      builder.add_hexagon(**opts, &block)
+    def klass(id = nil, **opts, &block)
+      builder.add_klass(id, **opts, &block)
     end
 
-    def interface(**opts, &block)
-      builder.add_interface(**opts, &block)
+    def note(id = nil, **opts, &block)
+      builder.add_note(id, **opts, &block)
     end
 
-    def klass(**opts, &block)
-      builder.add_klass(**opts, &block)
+    def process(id = nil, **opts, &block)
+      builder.add_process(id, **opts, &block)
     end
 
-    def note(**opts, &block)
-      builder.add_note(**opts, &block)
+    def rectangle(id = nil, **opts, &block)
+      builder.add_rectangle(id, **opts, &block)
     end
 
-    def process(**opts, &block)
-      builder.add_process(**opts, &block)
+    def rectangle2(id = nil, **opts, &block)
+      builder.add_rectangle2(id, **opts, &block)
     end
 
-    def rectangle(**opts, &block)
-      builder.add_rectangle(**opts, &block)
+    def square(id = nil, **opts, &block)
+      builder.add_square(id, **opts, &block)
     end
 
-    def rectangle2(**opts, &block)
-      builder.add_rectangle2(**opts, &block)
+    def step(id = nil, **opts, &block)
+      builder.add_step(id, **opts, &block)
     end
 
-    def square(**opts, &block)
-      builder.add_square(**opts, &block)
+    def tick(id = nil, **opts, &block)
+      builder.add_tick(id, **opts, &block)
     end
 
-    def step(**opts, &block)
-      builder.add_step(**opts, &block)
+    def todo(id = nil, **opts, &block)
+      builder.add_todo(id, **opts, &block)
     end
 
-    def tick(**opts, &block)
-      builder.add_tick(**opts, &block)
+    def face(id = nil, **opts, &block)
+      builder.add_face(id, **opts, &block)
     end
 
-    def face(**opts, &block)
-      builder.add_face(**opts, &block)
+    def triangle(id = nil, **opts, &block)
+      builder.add_triangle(id, **opts, &block)
     end
 
-    def triangle(**opts, &block)
-      builder.add_triangle(**opts, &block)
+    def line(id = nil, **opts, &block)
+      builder.add_line(id, **opts, &block)
     end
 
-    def embed_row(**opts, &block)
-      builder.add_embed_row(**opts, &block)
+    def embed_row(id = nil, **opts, &block)
+      builder.add_embed_row(id, **opts, &block)
     end
 
-    def embed_col50(**opts, &block)
-      builder.add_embed_col50(**opts, &block)
+    def embed_col50(id = nil, **opts, &block)
+      builder.add_embed_col50(id, **opts, &block)
     end
 
-    def embed_col200(**opts, &block)
-      builder.add_embed_col200(**opts, &block)
+    def embed_col200(id = nil, **opts, &block)
+      builder.add_embed_col200(id, **opts, &block)
     end
   end
   # :nocov:

data/lib/drawio_dsl/formatters/factory.rb

@@ -9,11 +9,12 @@ module DrawioDsl
       include KLog::Logging
 
       FORMATTERS = {
-        class: DrawioDsl::Formatters::KlassFormatter,
+        klass: DrawioDsl::Formatters::KlassFormatter,
+        class: DrawioDsl::Formatters::KlassFormatter, # alias for klass
         interface: DrawioDsl::Formatters::InterfaceFormatter
       }.freeze
 
-      def format(type)
+      def format_instance(type)
         unless FORMATTERS.key?(type)
           log.error "Unknown formatter type: #{type}"
           @formatter = nil

data/lib/drawio_dsl/formatters/interface_formatter.rb

@@ -10,11 +10,13 @@ module DrawioDsl
         super({ p: { margin: '0px', margin_left: '4px', margin_top: '4px' } })
       end
 
-      def header(value)
-        html.p('<i>Interface</i>', text_align: :center)
-        html.p("<b>#{value}</b>", text_align: :center)
+      def header(name, description: nil, interface_type: 'Interface')
+        html.p("<i>&lt;&lt; #{interface_type} &gt;&gt;</i>", text_align: :center)
+        html.p("<b>#{name}</b>", text_align: :center)
         html.hr
 
+        html.group(:description).p(description) if description
+
         self
       end
 

data/lib/drawio_dsl/formatters/klass_formatter.rb

@@ -10,10 +10,12 @@ module DrawioDsl
         super({ p: { margin: '0px', margin_left: '4px', margin_top: '4px' } })
       end
 
-      def header(value)
-        html.p("<b>#{value}</b>", text_align: :center)
+      def header(name, description: nil)
+        html.p("<b>#{name}</b>", text_align: :center)
         html.hr
 
+        html.group(:description).p(description) if description
+
         self
       end
 

data/lib/drawio_dsl/schema/_.rb

@@ -46,8 +46,10 @@ require_relative 'shapes/rectangle2'
 require_relative 'shapes/square'
 require_relative 'shapes/step'
 require_relative 'shapes/tick'
+require_relative 'shapes/todo'
 require_relative 'shapes/face'
 require_relative 'shapes/triangle'
+require_relative 'shapes/line'
 require_relative 'shapes/embed_row'
 require_relative 'shapes/embed_col50'
 require_relative 'shapes/embed_col200'

data/lib/drawio_dsl/schema/shapes/line.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module Schema
+    class Line < Shape
+      configure_shape(:line)
+    end
+  end
+end