drawio_dsl 0.1.0 → 0.4.0

data/lib/drawio_dsl/drawio.rb

@@ -5,12 +5,6 @@ module DrawioDsl
   class Drawio < KDirector::Directors::BaseDirector
     default_builder_type(DrawioDsl::DomBuilder)
 
-    def layout(**opts)
-      builder.set_layout_engine(**opts)
-
-      self
-    end
-
     def diagram(**opts)
       builder.set_diagram(**opts)
 
@@ -21,6 +15,15 @@ module DrawioDsl
       page = DrawioDsl::DrawioPage.new(self, **opts.merge(name: name))
       page.instance_eval(&block) if block_given?
 
+      layout = DrawioDsl::LayoutEngine.new(builder.current_page)
+      layout.call
+      self
+    end
+
+    def apply_layout
+      engine = DrawioDsl::LayoutEngine.new(builder.diagram)
+      engine.call
+
       self
     end
   end
@@ -41,63 +44,89 @@ module DrawioDsl
       builder.add_page(**opts)
     end
 
+    def layout_rule(**opts)
+      builder.add_layout_rule(**opts)
+    end
+
+    def grid_layout(**opts)
+      builder.add_grid_layout(**opts)
+    end
+
+    def flex_layout(**opts)
+      builder.add_flex_layout(**opts)
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def random(**opts)
+      case rand(10)
+      when 0
+        square(**opts)
+      when 1
+        rectangle(**opts)
+      when 2
+        circle(**opts)
+      when 3
+        process(**opts)
+      when 4
+        ellipse(**opts)
+      when 5
+        diamond(**opts)
+      when 6
+        hexagon(**opts)
+      when 7
+        cloud(**opts)
+      when 8
+        note(**opts)
+      when 9
+        callout(**opts)
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
     def square(**opts)
-      opts = attach_xy(**opts)
       builder.add_square(**opts)
-      update_layout
     end
 
     def rectangle(**opts)
-      opts = attach_xy(**opts)
       builder.add_rectangle(**opts)
-      update_layout
     end
 
     def circle(**opts)
-      opts = attach_xy(**opts)
       builder.add_circle(**opts)
-      update_layout
     end
 
     def process(**opts)
-      opts = attach_xy(**opts)
       builder.add_process(**opts)
-      update_layout
     end
 
     def ellipse(**opts)
-      opts = attach_xy(**opts)
       builder.add_ellipse(**opts)
-      update_layout
     end
 
-    private
-
-    def current_element
-      builder.current_element
+    def diamond(**opts)
+      builder.add_diamond(**opts)
     end
 
-    # attr_reader :layout_engine
-    # set_layout
-
-    # layout.container.place_element(element)
+    def hexagon(**opts)
+      builder.add_hexagon(**opts)
+    end
 
-    def update_layout
-      return unless auto_layout
+    def cloud(**opts)
+      builder.add_cloud(**opts)
+    end
 
-      # puts current_element.page.x
-      # puts current_element.page.y
-      # puts current_element.page.w
-      # puts current_element.page.h
+    def note(**opts)
+      builder.add_note(**opts)
+    end
 
-      @current_x += current_element.w + 20
-      @current_y += current_element.h + 20
+    def callout(**opts)
+      builder.add_callout(**opts)
     end
 
-    def attach_xy(**opts)
-      opts[:x] ||= current_x
-      opts[:y] ||= current_y
-      opts
+    private
+
+    def current_shape
+      builder.current_shape
     end
   end
 end

data/lib/drawio_dsl/layout_engine.rb

@@ -9,39 +9,35 @@ module DrawioDsl
   # Elements will be placed on the page in the order they are added.
   # Row/column flow objects will hold information about horizontal and vertical element padding
   class LayoutEngine
-    attr_accessor :margin_left
-    attr_accessor :margin_top
-    attr_accessor :x
-    attr_accessor :y
+    attr_reader :page
 
-    def initialize(**opts)
-      @margin_left = opts[:margin_left] || 20
-      @margin_top  = opts[:margin_top]  || 20
-      @x           = opts[:x]           || @margin_left
-      @y           = opts[:y]           || @margin_top
-    end
+    attr_reader :current_page
+    attr_reader :current_layout
 
-    def container
-      @container ||= LayoutContainer.new(self)
-    end
+    # attr_reader :page_margin_top
+    # attr_reader :page_margin_left
+    # attr_reader :x
+    # attr_reader :y
 
-    def go_vertical(**opts)
-      @container = LayoutContainer.new(self, direction: :vertical, **opts)
+    def initialize(page)
+      @page = page
+      # @x = 0
+      # @y = 0
     end
 
-    def go_horizontal(**opts)
-      @container = LayoutContainer.new(self, direction: :horizontal, **opts)
+    def call
+      page.position_x = page.margin_left
+      page.position_y = page.margin_top
+
+      page.nodes.each do |node|
+        case node.classification
+        when :layout_rule
+          @current_layout = node
+        when :shape
+          current_layout&.position_shape(node)
+        end
+        # node.debug(format: :row)
+      end
     end
-
-    # # Position the incoming element by altering it's x, y coordinates based on the rules engine
-    # def position_element(element)
-    #   container.horizontal?
-    # end
-
-    # private
-
-    # def position_horizontally(element)
-
-    # end
   end
 end

data/lib/drawio_dsl/schema/_.rb

@@ -0,0 +1,23 @@
+# 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/callout'
+require_relative 'shapes/circle'
+require_relative 'shapes/cloud'
+require_relative 'shapes/diamond'
+require_relative 'shapes/ellipse'
+require_relative 'shapes/hexagon'
+require_relative 'shapes/note'
+require_relative 'shapes/process'
+require_relative 'shapes/rectangle'
+require_relative 'shapes/square'

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