drawio_dsl 0.6.0 → 0.7.0

data/lib/drawio_dsl/dom_builder_shapes.rb

@@ -4,188 +4,198 @@
 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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      container = DrawioDsl::Schema::Container.new(current_page, **opts, &block)
+      add_shape(container)
+    end
+
+    def add_container2(**opts, &block)
+      container2 = DrawioDsl::Schema::Container2.new(current_page, **opts, &block)
+      add_shape(container2)
+    end
+
+    def add_container3(**opts, &block)
+      container3 = DrawioDsl::Schema::Container3.new(current_page, **opts, &block)
+      add_shape(container3)
+    end
+
+    def add_container4(**opts, &block)
+      container4 = DrawioDsl::Schema::Container4.new(current_page, **opts, &block)
+      add_shape(container4)
+    end
+
+    def add_cross(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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)
-    end
-
-    def add_container4(**opts)
-      container4 = DrawioDsl::Schema::Container4.new(current_page, **opts)
-      add_shape(container4)
+    def add_klass(**opts, &block)
+      klass = DrawioDsl::Schema::Klass.new(current_page, **opts, &block)
+      add_shape(klass)
     end
 
-    def add_note(**opts)
-      note = DrawioDsl::Schema::Note.new(current_page, **opts)
+    def add_note(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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_face(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(**opts, &block)
+      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(39)
       when 0
         h1(**opts)
       when 1
@@ -37,198 +37,210 @@ 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)
+        face(**opts)
       when 35
-        embed_col50(**opts)
+        triangle(**opts)
       when 36
+        embed_row(**opts)
+      when 37
+        embed_col50(**opts)
+      when 38
         embed_col200(**opts)
       end
     end
 
-    def h1(**opts)
-      builder.add_h1(**opts)
+    def h1(**opts, &block)
+      builder.add_h1(**opts, &block)
+    end
+
+    def h2(**opts, &block)
+      builder.add_h2(**opts, &block)
+    end
+
+    def h3(**opts, &block)
+      builder.add_h3(**opts, &block)
     end
 
-    def h2(**opts)
-      builder.add_h2(**opts)
+    def h4(**opts, &block)
+      builder.add_h4(**opts, &block)
     end
 
-    def h3(**opts)
-      builder.add_h3(**opts)
+    def h5(**opts, &block)
+      builder.add_h5(**opts, &block)
     end
 
-    def h4(**opts)
-      builder.add_h4(**opts)
+    def h6(**opts, &block)
+      builder.add_h6(**opts, &block)
     end
 
-    def h5(**opts)
-      builder.add_h5(**opts)
+    def p(**opts, &block)
+      builder.add_p(**opts, &block)
     end
 
-    def h6(**opts)
-      builder.add_h6(**opts)
+    def actor(**opts, &block)
+      builder.add_actor(**opts, &block)
     end
 
-    def p(**opts)
-      builder.add_p(**opts)
+    def actor2(**opts, &block)
+      builder.add_actor2(**opts, &block)
     end
 
-    def actor(**opts)
-      builder.add_actor(**opts)
+    def callout(**opts, &block)
+      builder.add_callout(**opts, &block)
     end
 
-    def actor2(**opts)
-      builder.add_actor2(**opts)
+    def callout2(**opts, &block)
+      builder.add_callout2(**opts, &block)
     end
 
-    def callout(**opts)
-      builder.add_callout(**opts)
+    def callout3(**opts, &block)
+      builder.add_callout3(**opts, &block)
     end
 
-    def callout2(**opts)
-      builder.add_callout2(**opts)
+    def callout4(**opts, &block)
+      builder.add_callout4(**opts, &block)
     end
 
-    def callout3(**opts)
-      builder.add_callout3(**opts)
+    def circle(**opts, &block)
+      builder.add_circle(**opts, &block)
     end
 
-    def callout4(**opts)
-      builder.add_callout4(**opts)
+    def cloud(**opts, &block)
+      builder.add_cloud(**opts, &block)
     end
 
-    def circle(**opts)
-      builder.add_circle(**opts)
+    def container(**opts, &block)
+      builder.add_container(**opts, &block)
     end
 
-    def cloud(**opts)
-      builder.add_cloud(**opts)
+    def container2(**opts, &block)
+      builder.add_container2(**opts, &block)
     end
 
-    def cross(**opts)
-      builder.add_cross(**opts)
+    def container3(**opts, &block)
+      builder.add_container3(**opts, &block)
     end
 
-    def envelop(**opts)
-      builder.add_envelop(**opts)
+    def container4(**opts, &block)
+      builder.add_container4(**opts, &block)
     end
 
-    def diamond(**opts)
-      builder.add_diamond(**opts)
+    def cross(**opts, &block)
+      builder.add_cross(**opts, &block)
     end
 
-    def document(**opts)
-      builder.add_document(**opts)
+    def envelop(**opts, &block)
+      builder.add_envelop(**opts, &block)
     end
 
-    def ellipse(**opts)
-      builder.add_ellipse(**opts)
+    def diamond(**opts, &block)
+      builder.add_diamond(**opts, &block)
     end
 
-    def hexagon(**opts)
-      builder.add_hexagon(**opts)
+    def document(**opts, &block)
+      builder.add_document(**opts, &block)
     end
 
-    def container(**opts)
-      builder.add_container(**opts)
+    def ellipse(**opts, &block)
+      builder.add_ellipse(**opts, &block)
     end
 
-    def container2(**opts)
-      builder.add_container2(**opts)
+    def hexagon(**opts, &block)
+      builder.add_hexagon(**opts, &block)
     end
 
-    def container3(**opts)
-      builder.add_container3(**opts)
+    def interface(**opts, &block)
+      builder.add_interface(**opts, &block)
     end
 
-    def container4(**opts)
-      builder.add_container4(**opts)
+    def klass(**opts, &block)
+      builder.add_klass(**opts, &block)
     end
 
-    def note(**opts)
-      builder.add_note(**opts)
+    def note(**opts, &block)
+      builder.add_note(**opts, &block)
     end
 
-    def process(**opts)
-      builder.add_process(**opts)
+    def process(**opts, &block)
+      builder.add_process(**opts, &block)
     end
 
-    def rectangle(**opts)
-      builder.add_rectangle(**opts)
+    def rectangle(**opts, &block)
+      builder.add_rectangle(**opts, &block)
     end
 
-    def rectangle2(**opts)
-      builder.add_rectangle2(**opts)
+    def rectangle2(**opts, &block)
+      builder.add_rectangle2(**opts, &block)
     end
 
-    def square(**opts)
-      builder.add_square(**opts)
+    def square(**opts, &block)
+      builder.add_square(**opts, &block)
     end
 
-    def step(**opts)
-      builder.add_step(**opts)
+    def step(**opts, &block)
+      builder.add_step(**opts, &block)
     end
 
-    def tick(**opts)
-      builder.add_tick(**opts)
+    def tick(**opts, &block)
+      builder.add_tick(**opts, &block)
     end
 
-    def face(**opts)
-      builder.add_face(**opts)
+    def face(**opts, &block)
+      builder.add_face(**opts, &block)
     end
 
-    def triangle(**opts)
-      builder.add_triangle(**opts)
+    def triangle(**opts, &block)
+      builder.add_triangle(**opts, &block)
     end
 
-    def embed_row(**opts)
-      builder.add_embed_row(**opts)
+    def embed_row(**opts, &block)
+      builder.add_embed_row(**opts, &block)
     end
 
-    def embed_col50(**opts)
-      builder.add_embed_col50(**opts)
+    def embed_col50(**opts, &block)
+      builder.add_embed_col50(**opts, &block)
     end
 
-    def embed_col200(**opts)
-      builder.add_embed_col200(**opts)
+    def embed_col200(**opts, &block)
+      builder.add_embed_col200(**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'

data/lib/drawio_dsl/formatters/base_formatter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Work with HTML formatters to DrawIO shapes
+module DrawioDsl
+  # HTML formatters can be used on shapes to render HTML using a DSL
+  module Formatters
+    # Create an instance of a HTML formatter on the shape
+    class BaseFormatter
+      attr_reader :html
+
+      def initialize(element_style_defaults = {})
+        @html = DrawioDsl::Formatters::HtmlBuilder.new(element_style_defaults)
+      end
+
+      def empty?
+        html.empty?
+      end
+
+      def as_html(new_line: false)
+        html.as_html(new_line: new_line)
+      end
+    end
+  end
+end

data/lib/drawio_dsl/formatters/factory.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Work with HTML formatters to DrawIO shapes
+module DrawioDsl
+  # HTML formatters can be used on shapes to render HTML using a DSL
+  module Formatters
+    # Create an instance of a HTML formatter on the shape
+    module Factory
+      include KLog::Logging
+
+      FORMATTERS = {
+        class: DrawioDsl::Formatters::KlassFormatter,
+        interface: DrawioDsl::Formatters::InterfaceFormatter
+      }.freeze
+
+      def format(type)
+        unless FORMATTERS.key?(type)
+          log.error "Unknown formatter type: #{type}"
+          @formatter = nil
+          return formatter
+        end
+
+        @formatter = FORMATTERS[type].new
+        formatter
+      end
+
+      def formatter
+        @formatter ||= DrawioDsl::Formatters::BaseFormatter.new
+      end
+    end
+  end
+end