drawio_dsl 0.3.0 → 0.5.0

data/lib/drawio_dsl/drawio_shapes.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  # DrawioDsl::Shapes is a list of DSL methods (one per shape)
+  # :nocov:
+  module DrawioShapes
+    def random(**opts)
+      case rand(27)
+      when 0
+        actor(**opts)
+      when 1
+        actor2(**opts)
+      when 2
+        callout(**opts)
+      when 3
+        callout2(**opts)
+      when 4
+        callout3(**opts)
+      when 5
+        callout4(**opts)
+      when 6
+        circle(**opts)
+      when 7
+        cloud(**opts)
+      when 8
+        cross(**opts)
+      when 9
+        envelop(**opts)
+      when 10
+        diamond(**opts)
+      when 11
+        document(**opts)
+      when 12
+        ellipse(**opts)
+      when 13
+        hexagon(**opts)
+      when 14
+        container(**opts)
+      when 15
+        container2(**opts)
+      when 16
+        container3(**opts)
+      when 17
+        container4(**opts)
+      when 18
+        note(**opts)
+      when 19
+        process(**opts)
+      when 20
+        rectangle(**opts)
+      when 21
+        rectangle2(**opts)
+      when 22
+        square(**opts)
+      when 23
+        step(**opts)
+      when 24
+        tick(**opts)
+      when 25
+        face(**opts)
+      when 26
+        triangle(**opts)
+      end
+    end
+
+    def actor(**opts)
+      builder.add_actor(**opts)
+    end
+
+    def actor2(**opts)
+      builder.add_actor2(**opts)
+    end
+
+    def callout(**opts)
+      builder.add_callout(**opts)
+    end
+
+    def callout2(**opts)
+      builder.add_callout2(**opts)
+    end
+
+    def callout3(**opts)
+      builder.add_callout3(**opts)
+    end
+
+    def callout4(**opts)
+      builder.add_callout4(**opts)
+    end
+
+    def circle(**opts)
+      builder.add_circle(**opts)
+    end
+
+    def cloud(**opts)
+      builder.add_cloud(**opts)
+    end
+
+    def cross(**opts)
+      builder.add_cross(**opts)
+    end
+
+    def envelop(**opts)
+      builder.add_envelop(**opts)
+    end
+
+    def diamond(**opts)
+      builder.add_diamond(**opts)
+    end
+
+    def document(**opts)
+      builder.add_document(**opts)
+    end
+
+    def ellipse(**opts)
+      builder.add_ellipse(**opts)
+    end
+
+    def hexagon(**opts)
+      builder.add_hexagon(**opts)
+    end
+
+    def container(**opts)
+      builder.add_container(**opts)
+    end
+
+    def container2(**opts)
+      builder.add_container2(**opts)
+    end
+
+    def container3(**opts)
+      builder.add_container3(**opts)
+    end
+
+    def container4(**opts)
+      builder.add_container4(**opts)
+    end
+
+    def note(**opts)
+      builder.add_note(**opts)
+    end
+
+    def process(**opts)
+      builder.add_process(**opts)
+    end
+
+    def rectangle(**opts)
+      builder.add_rectangle(**opts)
+    end
+
+    def rectangle2(**opts)
+      builder.add_rectangle2(**opts)
+    end
+
+    def square(**opts)
+      builder.add_square(**opts)
+    end
+
+    def step(**opts)
+      builder.add_step(**opts)
+    end
+
+    def tick(**opts)
+      builder.add_tick(**opts)
+    end
+
+    def face(**opts)
+      builder.add_face(**opts)
+    end
+
+    def triangle(**opts)
+      builder.add_triangle(**opts)
+    end
+  end
+  # :nocov:
+end

data/lib/drawio_dsl/layout_engine.rb

@@ -34,7 +34,7 @@ module DrawioDsl
         when :layout_rule
           @current_layout = node
         when :shape
-          current_layout.position_shape(node)
+          current_layout&.position_shape(node)
         end
         # node.debug(format: :row)
       end

data/lib/drawio_dsl/schema/_.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'common_style'
+require_relative 'default_palette'
+require_relative 'diagram'
+require_relative 'node'
+require_relative 'page'
+
+require_relative 'layouts/layout'
+require_relative 'layouts/flex_layout'
+require_relative 'layouts/grid_layout'
+
+require_relative 'shapes/shape'
+require_relative 'shapes/actor'
+require_relative 'shapes/actor2'
+require_relative 'shapes/callout'
+require_relative 'shapes/callout2'
+require_relative 'shapes/callout3'
+require_relative 'shapes/callout4'
+require_relative 'shapes/circle'
+require_relative 'shapes/cloud'
+require_relative 'shapes/cross'
+require_relative 'shapes/envelop'
+require_relative 'shapes/diamond'
+require_relative 'shapes/document'
+require_relative 'shapes/ellipse'
+require_relative 'shapes/hexagon'
+require_relative 'shapes/container'
+require_relative 'shapes/container2'
+require_relative 'shapes/container3'
+require_relative 'shapes/container4'
+require_relative 'shapes/note'
+require_relative 'shapes/process'
+require_relative 'shapes/rectangle'
+require_relative 'shapes/rectangle2'
+require_relative 'shapes/square'
+require_relative 'shapes/step'
+require_relative 'shapes/tick'
+require_relative 'shapes/face'
+require_relative 'shapes/triangle'

data/lib/drawio_dsl/schema/common_style.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module Schema
+    # Common Style is the reused on Diagram, Page and Shape
+    #
+    # When styles are not provided at each level, then they will inherit from
+    # the parent common style.
+    #
+    # Shapes will use the common style of their page
+    class CommonStyle
+      attr_accessor :white_space
+      attr_accessor :html
+      attr_accessor :rounded
+      attr_accessor :shadow
+      attr_accessor :glass
+      attr_accessor :sketch
+
+      def initialize(**args, &block)
+        @white_space      = args[:white_space]
+        @html             = args[:html]
+        @rounded          = args[:rounded]
+        @shadow           = args[:shadow]
+        @sketch           = args[:sketch]
+        @glass            = args[:glass]
+
+        instance_eval(&block) if block_given?
+      end
+
+      def to_h
+        {
+          white_space: white_space,
+          html: html,
+          rounded: rounded,
+          shadow: shadow,
+          sketch: sketch,
+          glass: glass
+        }
+      end
+    end
+  end
+end

data/lib/drawio_dsl/schema/default_palette.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module Schema
+    # Default Palette contains palette information that can be inherited at each level
+    class DefaultPalette
+      attr_accessor :fill_color
+      attr_accessor :stroke_color
+      attr_accessor :font_color
+      attr_accessor :gradient
+
+      def initialize(owner, **args, &block)
+        @fill_color   = args[:fill_color]
+        @stroke_color = args[:stroke_color]
+        @font_color   = args[:font_color]
+        @gradient     = args[:gradient]
+
+        instance_exec(owner, &block) if block_given?
+      end
+
+      def to_h
+        {
+          fill_color: fill_color,
+          stroke_color: stroke_color,
+          font_color: font_color,
+          gradient: gradient
+        }
+      end
+    end
+  end
+end

data/lib/drawio_dsl/schema/diagram.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module Schema
+    # Diagram is the root of the schema, it contains pages
+    class Diagram
+      attr_accessor :host
+      attr_accessor :theme
+      attr_accessor :style
+      attr_accessor :palette
+      attr_accessor :pages
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def initialize(**args)
+        @host = args[:host]   || SecureRandom.alphanumeric(3)
+
+        # Apply a random theme to the diagram if none is specified.
+        @theme = args[:theme] || KConfig.configuration.drawio.random_theme
+
+        @style = DrawioDsl::Schema::CommonStyle.new(**args) do
+          default_style = KConfig.configuration.drawio.base_style
+
+          # Inherit from configured style when specific style not specified.
+          @white_space  ||= default_style.white_space
+          @html         ||= default_style.html
+          @rounded      ||= default_style.rounded
+          @shadow       ||= default_style.shadow
+          @sketch       ||= default_style.sketch
+          @glass        ||= default_style.glass
+        end
+
+        @palette = DrawioDsl::Schema::DefaultPalette.new(self, **args) do |diagram|
+          theme_palette = KConfig.configuration.drawio.palette(diagram.theme)
+
+          # Inherit from theme when specific palette options are not specified.
+          @fill_color   ||= theme_palette.fill_color
+          @stroke_color ||= theme_palette.stroke_color
+          @font_color   ||= theme_palette.font_color
+          @gradient     ||= theme_palette.gradient
+        end
+
+        @pages = args[:pages] || []
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def to_h
+        {
+          host: host,
+          theme: theme,
+          palette: palette.to_h,
+          style: style.to_h,
+          pages: pages.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/drawio_dsl/schema/layouts/flex_layout.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module Schema
+    # Provides flex style layouts
+    class FlexLayout < Layout
+      attr_accessor :direction
+      attr_accessor :wrap_at
+      attr_reader :gap
+      attr_reader :perpendicular_max
+
+      def initialize(page, **args)
+        @type = :flex_layout
+        @direction = args[:direction] || :horizontal
+        @wrap_at = args[:wrap_at] || (direction == :horizontal ? 1000 : 800)
+        @gap = args[:gap] || 20
+        @perpendicular_max = 0
+
+        super(page, **args)
+      end
+
+      def position_shape(shape)
+        fire_after_init
+
+        position_shape_horizontally(shape) if direction == :horizontal
+        position_shape_vertically(shape) if direction == :vertical
+      end
+
+      def to_h
+        fire_after_init
+
+        super.merge(
+          direction: direction,
+          wrap_at: wrap_at,
+          boundary: boundary,
+          perpendicular_max: perpendicular_max
+        )
+      end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize
+      def position_shape_horizontally(shape)
+        boundary_violation = page.position_x + shape.w + gap > boundary
+
+        if boundary_violation
+          page.position_x = anchor_x
+          page.position_y += perpendicular_max
+        end
+
+        shape.x = page.position_x
+        shape.y = page.position_y
+
+        return if boundary_violation
+
+        page.position_x += shape.w + gap
+        @perpendicular_max = [perpendicular_max, shape.h].max
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def position_shape_vertically(shape)
+        boundary_violation = page.position_y + shape.h + gap > boundary
+
+        if boundary_violation
+          page.position_y = anchor_y
+          page.position_x += perpendicular_max
+        end
+
+        shape.x = page.position_x
+        shape.y = page.position_y
+
+        return if boundary_violation
+
+        page.position_y += shape.h + gap
+        @perpendicular_max = [perpendicular_max, shape.w].max
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def boundary
+        return @boundary if defined? @boundary
+
+        @boundary = wrap_at + (direction == :horizontal ? anchor_x : anchor_y)
+      end
+    end
+  end
+end

data/lib/drawio_dsl/schema/layouts/grid_layout.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module Schema
+    # Provides grid style layouts
+    class GridLayout < Layout
+      attr_accessor :direction
+      attr_accessor :wrap_at
+      attr_accessor :grid_size
+      attr_accessor :cell_no
+      attr_accessor :h_align
+      attr_accessor :v_align
+
+      def initialize(page, **args)
+        @type       = :grid_layout
+        @direction  = args[:direction]  || :horizontal
+        @wrap_at    = args[:wrap_at]    || 5
+        @grid_size  = args[:grid_size]  || 220
+        @h_align    = args[:h_align]    || :center
+        @v_align    = args[:v_align]    || :center
+        @cell_no    = 1
+
+        super(page, **args)
+      end
+
+      def position_shape(shape)
+        fire_after_init
+
+        shape.x = horizontal_shape_alignment(shape)
+        shape.y = vertical_shape_alignment(shape)
+
+        # puts '------------------'
+        # puts "cell: #{cell_no}"
+        # puts "wrap_at: #{wrap_at}"
+        # puts "shape-x: #{shape.x}"
+        # puts "shape-y: #{shape.y}"
+        # puts "page-x: #{page.position_x}"
+        # puts "page-y: #{page.position_y}"
+        # puts "anchor-x: #{anchor_x}"
+        # puts "anchor-y: #{anchor_y}"
+
+        move_cell_horizontally if direction == :horizontal
+        move_cell_vertically if direction == :vertical
+      end
+
+      def to_h
+        super.merge(
+          direction: direction,
+          wrap_at: wrap_at,
+          grid_size: grid_size,
+          cell_no: cell_no
+        )
+      end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize
+      def horizontal_shape_alignment(shape)
+        return page.position_x + ((grid_size - shape.w) / 2)  if h_align == :center
+        return page.position_x + (grid_size - shape.w)        if h_align == :right
+
+        page.position_x
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def vertical_shape_alignment(shape)
+        return page.position_y + ((grid_size - shape.h) / 2)  if v_align == :center || v_align == :middle
+        return page.position_y + (grid_size - shape.h)        if v_align == :bottom
+
+        page.position_y
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def move_cell_horizontally
+        if cell_no < wrap_at
+          page.position_x += grid_size
+          @cell_no += 1
+          return
+        end
+
+        # Flow down to the next row
+        page.position_x = anchor_x
+        page.position_y += grid_size
+        @cell_no = 1
+      end
+
+      def move_cell_vertically
+        if cell_no < wrap_at
+          page.position_y += grid_size
+          @cell_no += 1
+          return
+        end
+
+        # Flow right to the next column
+        page.position_y = anchor_y
+        page.position_x += grid_size
+        @cell_no = 1
+      end
+    end
+  end
+end

data/lib/drawio_dsl/schema/layouts/layout.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module Schema
+    # Provides base configuration for automatic layouts
+    class Layout < Node
+      attr_accessor :type
+
+      # represents the x coordinate of the top left corner layout area
+      # this coordinate is based on the current location of the page
+      attr_accessor :anchor_x
+      attr_accessor :anchor_y
+
+      def initialize(page, **args)
+        @after_init_fired = false
+
+        super(page, **args.merge(classification: :layout_rule))
+      end
+
+      def fire_after_init
+        return if @after_init_fired
+
+        @after_init_fired = true
+        after_init
+      end
+
+      def after_init
+        @anchor_x ||= page.position_x
+        @anchor_y ||= page.position_y
+      end
+
+      def to_h
+        super.merge(
+          type: type,
+          anchor_x: anchor_x,
+          anchor_y: anchor_y
+        )
+      end
+    end
+  end
+end

data/lib/drawio_dsl/schema/node.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DrawioDsl
+  module Schema
+    # Node is a base class for shapes, connections, positioners and layout rules
+    #
+    class Node
+      attr_accessor :id
+      attr_accessor :page
+      attr_accessor :classification
+
+      def initialize(page, **args)
+        @page = page
+        @id = args[:id]
+        @classification = args[:classification] || :unknown
+      end
+
+      def to_h
+        {
+          id: id,
+          classification: classification
+        }
+      end
+
+      #   def debug(format: :detail)
+      #     if format == :detail
+      #       debug_detail(to_h)
+      #     else
+      #       debug_row(classification, id)
+      #     end
+      #   end
+
+      #   def debug_detail(**key_values)
+      #     key_values.each do |key, value|
+      #       puts "#{key.to_s.ljust(15)}: #{value}"
+      #     end
+      #   end
+
+      #
+      #   def debug_row(classification, id, type = nil, x = nil, y = nil, width = nil, height = nil)
+      #     row = []
+      #     row << classification.to_s.ljust(11)
+      #     row << id.to_s.ljust(6)
+      #     row << (type.nil? ? '' : type).to_s.ljust(15)
+      #     row << (x.nil? ? '' : x).to_s.rjust(5)
+      #     row << (y.nil? ? '' : y).to_s.rjust(5)
+      #     row << (width.nil? ? '' : width).to_s.rjust(5)
+      #     row << (height.nil? ? '' : height).to_s.rjust(5)
+      #     puts row.join(' | ')
+      #   end
+    end
+  end
+end