drawio_dsl 0.5.6 → 0.7.0

data/lib/drawio_dsl/drawio_extensions_active.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module DrawIoExtensionsActive
+    def apply_active_flags
+      sections.each do |section|
+        section[:shapes].each do |shape|
+          shape[:active] = check_if_active(shape)
+        end
+        section[:active] = section[:shapes].any? { |s| s[:active] }
+      end
+    end
+
+    def check_if_active(shape)
+      style = shape[:style]
+
+      ban = %w[
+        mxCompositeShape
+        strokeColor=none;fillColor=none
+        shape=image
+        shadow=1
+        shape=partialRectangle;right=0
+        shape=partialRectangle;right=0;left=0
+      ]
+
+      return false if style.empty?
+      return false if ban.include?(style)
+
+      true
+    end
+  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

data/lib/drawio_dsl/formatters/html_builder.rb

@@ -0,0 +1,84 @@
+# 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 HtmlBuilder
+      attr_reader :element_style_defaults
+
+      def initialize(element_style_defaults = {})
+        @element_style_defaults = element_style_defaults
+      end
+
+      def default_for(tag)
+        element_style_defaults[tag] || {}
+      end
+
+      def style_for(tag, **opts)
+        defaults = default_for(tag)
+        DrawioDsl::Formatters::StyleBuilder.new(**defaults).customize(**opts).style_attribute
+      end
+
+      def empty?
+        build_lines.empty?
+      end
+
+      def exist?
+        !empty?
+      end
+
+      def as_html(new_line: false)
+        new_line ? build_lines.join("\n") : build_lines.join
+      end
+
+      def hr(size: 1)
+        add_line("<hr size=\"#{size}\"/>")
+      end
+
+      def b(content, **opts)
+        add_line("<b#{style_for(:b, **opts)}>#{content}</b>")
+      end
+
+      def p(content, **opts)
+        # style_parts = %w[margin:0px margin-top:4px]
+        # style_parts << "text-align:#{opts[:text_align]}" if opts[:text_align]
+        # style=\"#{style_parts.join(';')}\"
+        add_line("<p#{style_for(:p, **opts)}>#{content}</p>")
+      end
+
+      def add_line(line)
+        lines << line
+      end
+
+      def add_placeholder(group_key)
+        lines << group_key
+      end
+
+      def group(key)
+        groups[key] ||= DrawioDsl::Formatters::HtmlBuilder.new(element_style_defaults)
+      end
+
+      def build_lines
+        lines.flat_map do |line|
+          if line.is_a?(Symbol)
+            group(line).build_lines
+          else
+            line
+          end
+        end
+      end
+
+      private
+
+      def lines
+        @lines ||= []
+      end
+
+      def groups
+        @groups ||= {}
+      end
+    end
+  end
+end

data/lib/drawio_dsl/formatters/interface_formatter.rb

@@ -0,0 +1,53 @@
+# 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 InterfaceFormatter < BaseFormatter
+      def initialize
+        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)
+        html.hr
+
+        self
+      end
+
+      def field(name, type: nil)
+        value = if type
+                  "#{name}: #{type}"
+                else
+                  name
+                end
+        html.group(:fields).p(value)
+
+        self
+      end
+
+      def method(name, type: nil)
+        value = if type
+                  "#{name}() : #{type}"
+                else
+                  "#{name}()"
+                end
+        html.group(:methods).p(value)
+
+        self
+      end
+
+      def as_html(new_line: false)
+        html.add_placeholder(:fields)
+        html.add_placeholder(:methods)
+
+        html.group(:fields).hr if html.group(:fields).exist? && html.group(:methods).exist?
+
+        html.as_html(new_line: new_line)
+      end
+    end
+  end
+end

data/lib/drawio_dsl/formatters/klass_formatter.rb

@@ -0,0 +1,52 @@
+# 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 KlassFormatter < BaseFormatter
+      def initialize
+        super({ p: { margin: '0px', margin_left: '4px', margin_top: '4px' } })
+      end
+
+      def header(value)
+        html.p("<b>#{value}</b>", text_align: :center)
+        html.hr
+
+        self
+      end
+
+      def field(name, type: nil)
+        value = if type
+                  "#{name}: #{type}"
+                else
+                  name
+                end
+        html.group(:fields).p(value)
+
+        self
+      end
+
+      def method(name, type: nil)
+        value = if type
+                  "#{name}() : #{type}"
+                else
+                  "#{name}()"
+                end
+        html.group(:methods).p(value)
+
+        self
+      end
+
+      def as_html(new_line: false)
+        html.add_placeholder(:fields)
+        html.add_placeholder(:methods)
+
+        html.group(:fields).hr if html.group(:fields).exist? && html.group(:methods).exist?
+
+        html.as_html(new_line: new_line)
+      end
+    end
+  end
+end

data/lib/drawio_dsl/formatters/style_builder.rb

@@ -0,0 +1,63 @@
+# 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 StyleBuilder
+      MAPPINGS = {
+        margin: 'margin',
+        margin_top: 'margin-top',
+        margin_bottom: 'margin-bottom',
+        margin_left: 'margin-left',
+        margin_right: 'margin-right',
+        padding: 'padding',
+        padding_top: 'padding-top',
+        padding_bottom: 'padding-bottom',
+        padding_left: 'padding-left',
+        padding_right: 'padding-right',
+        text_align: 'text-align',
+        font_size: 'font-size',
+        font_weight: 'font-weight',
+        font_style: 'font-style',
+        font_family: 'font-family',
+        color: 'color'
+      }.freeze
+
+      attr_reader :defaults
+      attr_reader :custom
+
+      def initialize(**opts)
+        @style_parts = []
+        @defaults = opts
+        @custom = {}
+      end
+
+      def customize(**opts)
+        @custom = opts
+
+        self
+      end
+
+      def style
+        build
+        @style_parts.join(';')
+      end
+
+      def style_attribute
+        style_value = style
+        style_value.empty? ? nil : " style=\"#{style_value}\""
+      end
+
+      private
+
+      def build
+        defaults.merge(custom).each do |key, value|
+          style_key = MAPPINGS[key]
+          @style_parts << "#{style_key}:#{value}" if style_key
+        end
+      end
+    end
+  end
+end