drawio_dsl 0.6.0 → 0.8.1

data/lib/drawio_dsl/dom_builder_shapes.rb

@@ -4,188 +4,243 @@
 module DrawioDsl
   # DrawioDsl is a DSL for draw-io diagrams.
   module DomBuilderShapes
-    def add_h1(**opts)
-      h1 = DrawioDsl::Schema::H1.new(current_page, **opts)
+    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)
-      h2 = DrawioDsl::Schema::H2.new(current_page, **opts)
+    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)
-      h3 = DrawioDsl::Schema::H3.new(current_page, **opts)
+    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)
-      h4 = DrawioDsl::Schema::H4.new(current_page, **opts)
+    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)
-      h5 = DrawioDsl::Schema::H5.new(current_page, **opts)
+    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)
-      h6 = DrawioDsl::Schema::H6.new(current_page, **opts)
+    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)
-      p = DrawioDsl::Schema::P.new(current_page, **opts)
+    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)
-      actor = DrawioDsl::Schema::Actor.new(current_page, **opts)
+    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)
-      actor2 = DrawioDsl::Schema::Actor2.new(current_page, **opts)
+    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)
-      callout = DrawioDsl::Schema::Callout.new(current_page, **opts)
+    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)
-      callout2 = DrawioDsl::Schema::Callout2.new(current_page, **opts)
+    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)
-      callout3 = DrawioDsl::Schema::Callout3.new(current_page, **opts)
+    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)
-      callout4 = DrawioDsl::Schema::Callout4.new(current_page, **opts)
+    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)
-      circle = DrawioDsl::Schema::Circle.new(current_page, **opts)
+    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)
-      cloud = DrawioDsl::Schema::Cloud.new(current_page, **opts)
+    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_cross(**opts)
-      cross = DrawioDsl::Schema::Cross.new(current_page, **opts)
+    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(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(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(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(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)
-      envelop = DrawioDsl::Schema::Envelop.new(current_page, **opts)
+    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)
-      diamond = DrawioDsl::Schema::Diamond.new(current_page, **opts)
+    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)
-      document = DrawioDsl::Schema::Document.new(current_page, **opts)
+    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)
-      ellipse = DrawioDsl::Schema::Ellipse.new(current_page, **opts)
+    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)
-      hexagon = DrawioDsl::Schema::Hexagon.new(current_page, **opts)
+    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_container(**opts)
-      container = DrawioDsl::Schema::Container.new(current_page, **opts)
-      add_shape(container)
-    end
-
-    def add_container2(**opts)
-      container2 = DrawioDsl::Schema::Container2.new(current_page, **opts)
-      add_shape(container2)
+    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_container3(**opts)
-      container3 = DrawioDsl::Schema::Container3.new(current_page, **opts)
-      add_shape(container3)
+    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_container4(**opts)
-      container4 = DrawioDsl::Schema::Container4.new(current_page, **opts)
-      add_shape(container4)
-    end
-
-    def add_note(**opts)
-      note = DrawioDsl::Schema::Note.new(current_page, **opts)
+    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)
-      process = DrawioDsl::Schema::Process.new(current_page, **opts)
+    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)
-      rectangle = DrawioDsl::Schema::Rectangle.new(current_page, **opts)
+    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)
-      rectangle2 = DrawioDsl::Schema::Rectangle2.new(current_page, **opts)
+    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)
-      square = DrawioDsl::Schema::Square.new(current_page, **opts)
+    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)
-      step = DrawioDsl::Schema::Step.new(current_page, **opts)
+    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)
-      tick = DrawioDsl::Schema::Tick.new(current_page, **opts)
+    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)
-      face = DrawioDsl::Schema::Face.new(current_page, **opts)
+    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)
-      triangle = DrawioDsl::Schema::Triangle.new(current_page, **opts)
+    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)
-      embed_row = DrawioDsl::Schema::EmbedRow.new(current_page, **opts)
+    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)
-      embed_col50 = DrawioDsl::Schema::EmbedCol50.new(current_page, **opts)
+    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)
-      embed_col200 = DrawioDsl::Schema::EmbedCol200.new(current_page, **opts)
+    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
   end

data/lib/drawio_dsl/drawio_shapes.rb

@@ -5,7 +5,7 @@ module DrawioDsl
   # :nocov:
   module DrawioShapes
     def random(**opts)
-      case rand(37)
+      case rand(40)
       when 0
         h1(**opts)
       when 1
@@ -37,198 +37,216 @@ module DrawioDsl
       when 14
         cloud(**opts)
       when 15
-        cross(**opts)
+        container(**opts)
       when 16
-        envelop(**opts)
+        container2(**opts)
       when 17
-        diamond(**opts)
+        container3(**opts)
       when 18
-        document(**opts)
+        container4(**opts)
       when 19
-        ellipse(**opts)
+        cross(**opts)
       when 20
-        hexagon(**opts)
+        envelop(**opts)
       when 21
-        container(**opts)
+        diamond(**opts)
       when 22
-        container2(**opts)
+        document(**opts)
       when 23
-        container3(**opts)
+        ellipse(**opts)
       when 24
-        container4(**opts)
+        hexagon(**opts)
       when 25
-        note(**opts)
+        interface(**opts)
       when 26
-        process(**opts)
+        klass(**opts)
       when 27
-        rectangle(**opts)
+        note(**opts)
       when 28
-        rectangle2(**opts)
+        process(**opts)
       when 29
-        square(**opts)
+        rectangle(**opts)
       when 30
-        step(**opts)
+        rectangle2(**opts)
       when 31
-        tick(**opts)
+        square(**opts)
       when 32
-        face(**opts)
+        step(**opts)
       when 33
-        triangle(**opts)
+        tick(**opts)
       when 34
-        embed_row(**opts)
+        todo(**opts)
       when 35
-        embed_col50(**opts)
+        face(**opts)
       when 36
+        triangle(**opts)
+      when 37
+        embed_row(**opts)
+      when 38
+        embed_col50(**opts)
+      when 39
         embed_col200(**opts)
       end
     end
 
-    def h1(**opts)
-      builder.add_h1(**opts)
+    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 h4(id = nil, **opts, &block)
+      builder.add_h4(id, **opts, &block)
     end
 
-    def h2(**opts)
-      builder.add_h2(**opts)
+    def h5(id = nil, **opts, &block)
+      builder.add_h5(id, **opts, &block)
     end
 
-    def h3(**opts)
-      builder.add_h3(**opts)
+    def h6(id = nil, **opts, &block)
+      builder.add_h6(id, **opts, &block)
     end
 
-    def h4(**opts)
-      builder.add_h4(**opts)
+    def p(id = nil, **opts, &block)
+      builder.add_p(id, **opts, &block)
     end
 
-    def h5(**opts)
-      builder.add_h5(**opts)
+    def actor(id = nil, **opts, &block)
+      builder.add_actor(id, **opts, &block)
     end
 
-    def h6(**opts)
-      builder.add_h6(**opts)
+    def actor2(id = nil, **opts, &block)
+      builder.add_actor2(id, **opts, &block)
     end
 
-    def p(**opts)
-      builder.add_p(**opts)
+    def callout(id = nil, **opts, &block)
+      builder.add_callout(id, **opts, &block)
     end
 
-    def actor(**opts)
-      builder.add_actor(**opts)
+    def callout2(id = nil, **opts, &block)
+      builder.add_callout2(id, **opts, &block)
     end
 
-    def actor2(**opts)
-      builder.add_actor2(**opts)
+    def callout3(id = nil, **opts, &block)
+      builder.add_callout3(id, **opts, &block)
     end
 
-    def callout(**opts)
-      builder.add_callout(**opts)
+    def callout4(id = nil, **opts, &block)
+      builder.add_callout4(id, **opts, &block)
     end
 
-    def callout2(**opts)
-      builder.add_callout2(**opts)
+    def circle(id = nil, **opts, &block)
+      builder.add_circle(id, **opts, &block)
     end
 
-    def callout3(**opts)
-      builder.add_callout3(**opts)
+    def cloud(id = nil, **opts, &block)
+      builder.add_cloud(id, **opts, &block)
     end
 
-    def callout4(**opts)
-      builder.add_callout4(**opts)
+    def container(id = nil, **opts, &block)
+      builder.add_container(id, **opts, &block)
     end
 
-    def circle(**opts)
-      builder.add_circle(**opts)
+    def container2(id = nil, **opts, &block)
+      builder.add_container2(id, **opts, &block)
     end
 
-    def cloud(**opts)
-      builder.add_cloud(**opts)
+    def container3(id = nil, **opts, &block)
+      builder.add_container3(id, **opts, &block)
     end
 
-    def cross(**opts)
-      builder.add_cross(**opts)
+    def container4(id = nil, **opts, &block)
+      builder.add_container4(id, **opts, &block)
     end
 
-    def envelop(**opts)
-      builder.add_envelop(**opts)
+    def cross(id = nil, **opts, &block)
+      builder.add_cross(id, **opts, &block)
     end
 
-    def diamond(**opts)
-      builder.add_diamond(**opts)
+    def envelop(id = nil, **opts, &block)
+      builder.add_envelop(id, **opts, &block)
     end
 
-    def document(**opts)
-      builder.add_document(**opts)
+    def diamond(id = nil, **opts, &block)
+      builder.add_diamond(id, **opts, &block)
     end
 
-    def ellipse(**opts)
-      builder.add_ellipse(**opts)
+    def document(id = nil, **opts, &block)
+      builder.add_document(id, **opts, &block)
     end
 
-    def hexagon(**opts)
-      builder.add_hexagon(**opts)
+    def ellipse(id = nil, **opts, &block)
+      builder.add_ellipse(id, **opts, &block)
     end
 
-    def container(**opts)
-      builder.add_container(**opts)
+    def hexagon(id = nil, **opts, &block)
+      builder.add_hexagon(id, **opts, &block)
     end
 
-    def container2(**opts)
-      builder.add_container2(**opts)
+    def interface(id = nil, **opts, &block)
+      builder.add_interface(id, **opts, &block)
     end
 
-    def container3(**opts)
-      builder.add_container3(**opts)
+    def klass(id = nil, **opts, &block)
+      builder.add_klass(id, **opts, &block)
     end
 
-    def container4(**opts)
-      builder.add_container4(**opts)
+    def note(id = nil, **opts, &block)
+      builder.add_note(id, **opts, &block)
     end
 
-    def note(**opts)
-      builder.add_note(**opts)
+    def process(id = nil, **opts, &block)
+      builder.add_process(id, **opts, &block)
     end
 
-    def process(**opts)
-      builder.add_process(**opts)
+    def rectangle(id = nil, **opts, &block)
+      builder.add_rectangle(id, **opts, &block)
     end
 
-    def rectangle(**opts)
-      builder.add_rectangle(**opts)
+    def rectangle2(id = nil, **opts, &block)
+      builder.add_rectangle2(id, **opts, &block)
     end
 
-    def rectangle2(**opts)
-      builder.add_rectangle2(**opts)
+    def square(id = nil, **opts, &block)
+      builder.add_square(id, **opts, &block)
     end
 
-    def square(**opts)
-      builder.add_square(**opts)
+    def step(id = nil, **opts, &block)
+      builder.add_step(id, **opts, &block)
     end
 
-    def step(**opts)
-      builder.add_step(**opts)
+    def tick(id = nil, **opts, &block)
+      builder.add_tick(id, **opts, &block)
     end
 
-    def tick(**opts)
-      builder.add_tick(**opts)
+    def todo(id = nil, **opts, &block)
+      builder.add_todo(id, **opts, &block)
     end
 
-    def face(**opts)
-      builder.add_face(**opts)
+    def face(id = nil, **opts, &block)
+      builder.add_face(id, **opts, &block)
     end
 
-    def triangle(**opts)
-      builder.add_triangle(**opts)
+    def triangle(id = nil, **opts, &block)
+      builder.add_triangle(id, **opts, &block)
     end
 
-    def embed_row(**opts)
-      builder.add_embed_row(**opts)
+    def embed_row(id = nil, **opts, &block)
+      builder.add_embed_row(id, **opts, &block)
     end
 
-    def embed_col50(**opts)
-      builder.add_embed_col50(**opts)
+    def embed_col50(id = nil, **opts, &block)
+      builder.add_embed_col50(id, **opts, &block)
     end
 
-    def embed_col200(**opts)
-      builder.add_embed_col200(**opts)
+    def embed_col200(id = nil, **opts, &block)
+      builder.add_embed_col200(id, **opts, &block)
     end
   end
   # :nocov:

data/lib/drawio_dsl/formatters/_.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'style_builder'
+require_relative 'html_builder'
+require_relative 'base_formatter'
+require_relative 'klass_formatter'
+require_relative 'interface_formatter'
+require_relative 'factory'