svg_drawer 1.0.0

data/lib/svg_drawer/polyline.rb

@@ -0,0 +1,171 @@
+module SvgDrawer
+  class Polyline < Base
+    # NOTE: reposition and scale behaviors can be moved to Base
+    #       but that is not needed at the moment
+    #
+    # :expand ensures that if the elem is smaller than the given dimensions,
+    # it will be scaled *up* until its either X or Y dim hits the bounds
+    # :shrink is similar, but scales the element *down* until both X and Y
+    # dim fit within the bounds
+    #
+    # If either :expand or :shrink are given, :overflow is ignored
+    #
+    # :scale_size is taken into account only if :shrink and/or :expand are
+    # given, and determines whether the given size (i.e. stroke-width) is
+    # also scaled accordingly
+    #
+    # :dotspace, if given, will cause the line to become dotted
+    #
+    defaults fill: 'none',
+             stroke: 'black',
+             linecap: 'butt',
+             linejoin: 'miter',
+             size: 1,
+             x_reposition: 'none',  # none/left/center/right
+             y_reposition: 'none',  # none/top/middle/bottom
+             expand: false,
+             shrink: false,
+             dotspace: 0,
+             overflow: false,
+             scale: 1,
+             scale_size: true
+
+    def initialize(points, params = {})
+      @points = points
+      super(params)
+    end
+
+    def width
+      param(:overflow) ?
+        param(:width, calc_width) :
+        [param(:width, 0), calc_width].max
+    end
+
+    def height
+      param(:overflow) ?
+        param(:height, calc_height) :
+        [param(:height, 0), calc_height].max
+    end
+
+    def incomplete
+      @points.size < 4 || @points.size.odd? ? self : nil
+    end
+
+    def min_x
+      @min_x ||= @points.each_slice(2).min_by(&:first).first - cap_size
+    end
+
+    def max_x
+      @max_x ||= @points.each_slice(2).max_by(&:first).first + cap_size
+    end
+
+    def min_y
+      @min_y ||= @points.each_slice(2).min_by(&:last).last - cap_size
+    end
+
+    def max_y
+      @max_y ||= @points.each_slice(2).max_by(&:last).last + cap_size
+    end
+
+    private
+
+    def _draw(parent)
+      size = param(:scale_size) ? param(:size) : param(:size) / scale
+      dotspace = param(:scale_size) ? param(:dotspace) : param(:dotspace) / scale
+      dotsize = size
+      style = {}
+
+      if param(:linecap).eql?('round')
+        dotsize = 0
+        dotspace *= 2
+      end
+
+      # need symbol keys due to a bug in Rasem::SVGTag#write_styles
+      style[:fill] = param(:fill)
+      style[:stroke] = param(:stroke)
+      style[:'stroke-width'] = size
+      style[:'stroke-linecap'] = param(:linecap)
+      style[:'stroke-linejoin'] = param(:linejoin)
+      style[:'stroke-dasharray'] = "#{dotsize}, #{dotspace}" if dotspace > 0
+
+      Utils::RasemWrapper.group(parent, class: 'polyline') do |polyline_group|
+        poly = polyline_group.polyline(@points, style: style.dup)
+        poly.translate(translate_x, translate_y).scale(scale, scale)
+      end
+    end
+
+    def calc_width
+      calc_width_unscaled * scale
+    end
+
+    def calc_height
+      calc_height_unscaled * scale
+    end
+
+    def calc_width_unscaled
+      max_x - min_x
+    end
+
+    def calc_height_unscaled
+      max_y - min_y
+    end
+
+    def width_unscaled
+      param(:overflow) ?
+        param(:width, calc_width_unscaled) :
+        [param(:width, 0), calc_width_unscaled].max
+    end
+
+    def height_unscaled
+      param(:overflow) ?
+        param(:height, calc_height_unscaled) :
+        [param(:height, 0), calc_height_unscaled].max
+    end
+
+    def scale
+      [scale_x, scale_y].min * param(:scale)
+    end
+
+    def scale_x
+      return 1 unless param(:width) && (param(:expand) || param(:shrink))
+      scale = param(:width).to_d / calc_width_unscaled
+      return 1 if (scale > 1 && !param(:expand)) || (scale < 1 && !param(:shrink))
+      scale
+    end
+
+    def scale_y
+      return 1 unless param(:height) && (param(:expand) || param(:shrink))
+      scale = param(:height).to_d / calc_height_unscaled
+      return 1 if (scale > 1 && !param(:expand)) || (scale < 1 && !param(:shrink))
+      scale
+    end
+
+    def translate_x
+      width_diff = (width - calc_width)
+
+      case param(:x_reposition)
+      when 'left' then -min_x * scale
+      when 'center' then -min_x * scale + width_diff / 2
+      when 'right' then -min_x * scale + width_diff
+      when 'none' then 0
+      else raise "Bad x_reposition: #{param(:x_reposition)}. Valid are: [left, right, center, none]"
+      end
+    end
+
+    def translate_y
+      height_diff = height - calc_height
+
+      case param(:y_reposition)
+      when 'top' then -min_y * scale
+      when 'middle' then -min_y * scale + height_diff / 2
+      when 'bottom' then -min_y * scale + height_diff
+      when 'none' then 0
+      else raise "Bad y_reposition: #{param(:y_reposition)}. Valid are: [top, bottom, middle, none]"
+      end
+    end
+
+    def cap_size
+      param(:size).to_d / 2
+    end
+  end
+end

data/lib/svg_drawer/table/blank_row.rb

@@ -0,0 +1,32 @@
+module SvgDrawer
+  class BlankRow < Base
+    requires :columns
+    requires :width
+    requires :height
+
+    def incomplete
+      false
+    end
+
+    def width
+      @width ||= param(:width)
+    end
+
+    def height
+      @height ||= param(:height)
+    end
+
+    def cell_widths
+      Array.new(param(:columns), 0)
+    end
+
+    private
+
+    def _draw(parent, _col_widths)
+      Utils::RasemWrapper.group(parent, class: param(:class), id: param(:id)) do |row_group|
+        draw_border(row_group)
+        row_group.rectangle(0, 0, width, height, fill: 'none', stroke: 'none')
+      end
+    end
+  end
+end

data/lib/svg_drawer/table/border.rb

@@ -0,0 +1,62 @@
+module SvgDrawer
+  module Border
+    module_function
+
+    DEFAULT_STYLE = { stroke: 'black', size: 1 }.freeze
+
+    #
+    # Draw a rectangle with the given width and height
+    # The rectangle is actually 4 lines, with opacity of 1 or 0,
+    # depending on the values in the `borders` array.
+    # (e.g. [:left, :top])
+    #
+    # All lines share the same style, given by the border_style hash
+    # (see DEFAULT_STYLE for possible keys and their default values)
+    #
+    # For debugging purposes, lines can always be drawn even when there
+    # are no borders specified -- they are drawn transparent in this case.
+    # Drawing opacity=0 lines helps debugging in web inspector, but has
+    # some performance impact.
+    #
+    # @param  parent [Rasem::SVGTagWithParent]
+    # @param  width [Integer]
+    # @param  height [Integer]
+    # @param  borders [Array] (optional)
+    # @param  border_style [Hash] (optional)
+    # @param  svg_class [String] (optional)
+    # @param  debug [Boolean] (optional) draw invisible borders
+    # @return  [Rasem::SVGTagWithParent]
+    #
+    def draw(parent, width, height, borders, border_style, svg_class, debug)
+      return if !debug && (borders.nil? || borders.empty?)
+
+      style = DEFAULT_STYLE.merge(border_style || {})
+      style['stroke-width'] = style.delete(:size)
+      borders ||= []
+
+      line_points = {
+        top: [0, 0, width, 0],
+        right: [width,  0, width, height],
+        bottom: [width, height, 0, height],
+        left: [0, height, 0, 0]
+      }
+
+      klass = 'border'
+      klass.prepend("#{svg_class} ") if svg_class
+
+      Utils::RasemWrapper.group(parent, class: klass) do |group|
+        line_points.each do |border, points|
+          line_style = style.dup
+
+          # It is useful to draw an invisible border as this
+          # significantly helps debugging
+          unless borders.include?(border)
+            debug ? line_style[:opacity] = 0 : next
+          end
+
+          group.line(*points, line_style)
+        end
+      end
+    end
+  end
+end

data/lib/svg_drawer/table/cell.rb

@@ -0,0 +1,65 @@
+module SvgDrawer
+  class Cell < Base
+    def width
+      return @width if @width
+      ensure_complete!
+      @width = [param(:width, 0), @content.width].max
+    end
+
+    def height
+      return @height if @height
+      ensure_complete!
+      @height = [param(:height, 0), @content.height].max
+    end
+
+    def incomplete
+      @content.nil? ? self : @content.incomplete
+    end
+
+    def content(element = nil)
+      return @content unless element
+      raise TypeError, 'Argument must to respond to #draw' unless element.respond_to?(:draw)
+      element.update_params!(inherited: child_params)
+      @content = element
+    end
+
+    def text_box(text, params = {})
+      @content = TextBox.new(text, params.merge(inherited: child_params))
+    end
+
+    def path(path_components, params = {})
+      @content = Path.new(path_components, params.merge(inherited: child_params))
+    end
+
+    def polyline(points, params = {})
+      @content = Polyline.new(points, params.merge(inherited: child_params))
+    end
+
+    def multipolyline(strokes, params = {})
+      @content = Multipolyline.new(strokes, params.merge(inherited: child_params))
+    end
+
+    def line(points, params = {})
+      @content = Line.new(points, params.merge(inherited: child_params))
+    end
+
+    def circle(center, radius, params = {})
+      @content = Circle.new(center, radius, params.merge(inherited: child_params))
+    end
+
+    #
+    # See Row#draw for info on col_width and row_height
+    #
+    # @param  parent [Rasem::SVGTagWithParent]
+    # @param  col_width [Integer]  Table-wide max colum width
+    # @param  row_height [Integer]  Table-wide max row height
+    # @return  [Rasem::SVGTagWithParent]
+    #
+    def _draw(parent)
+      Utils::RasemWrapper.group(parent, class: param(:class), id: param(:id)) do |cell_group|
+        draw_border(cell_group)
+        @content.draw(cell_group, debug: @debug)
+      end
+    end
+  end
+end

data/lib/svg_drawer/table/row.rb

@@ -0,0 +1,127 @@
+module SvgDrawer
+  class Row < Base
+    requires :columns
+
+    special :width        # row width is not the same as cell width
+    special :columns      # makes no sense for a cell
+    special :col_widths   # makes no sense for a cell
+
+    def width
+      ensure_complete!
+      sum_width = cell_widths.reduce(&:+)
+      [param(:width, 0), sum_width].max
+    end
+
+    def height
+      ensure_complete!
+      [param(:height, 0), cell_heights.max].max
+    end
+
+    def incomplete
+      cells.size != param(:columns) ? self : find_incomplete_descendant
+    end
+
+    def cell_widths
+      ensure_complete!
+      cells.map(&:width)
+    end
+
+    def cell_heights
+      ensure_complete!
+      cells.map(&:height)
+    end
+
+    def col_widths
+      Table.col_widths(param(:col_widths), param(:width), param(:columns))
+    end
+
+    def cells
+      @cells ||= []
+    end
+
+    def add_cell(cell)
+      raise TypeError, "Expected Cell, got: #{cell.class}" unless cell.is_a?(Cell)
+      cell.update_params!(inherited: cell_params)
+      cells << cell
+      self
+    end
+
+    #
+    # @param  params [Hash]  cell params.
+    # @return  [Row]  self
+    #
+    def cell(params = {})
+      raise 'Cannot add more cells' unless incomplete
+      cell = Cell.new(params.merge(inherited: cell_params))
+      yield(cell)
+      cells << cell
+      self
+    end
+
+    def text_cell(text, params = {})
+      cell(params) { |c| c.text_box(text) }
+    end
+
+    def path_cell(path_components, params = {})
+      cell(params) { |c| c.path(path_components) }
+    end
+
+    def line_cell(points, params = {})
+      cell(params) { |c| c.line(points) }
+    end
+
+    def polyline_cell(points, params = {})
+      cell(params) { |c| c.polyline(points) }
+    end
+
+    def multipolyline_cell(strokes, params = {})
+      cell(params) { |c| c.multipolyline(strokes) }
+    end
+
+    def circle_cell(center, radius, params = {})
+      cell(params) { |c| c.circle(center, radius) }
+    end
+
+    private
+
+    #
+    # A note on cell widths:
+    # Cells are drawed not with their initial widths, but with the
+    # table-wide maximum width for the corresponding columns.
+    # This must happen at draw time, as we can't know what the max col
+    # width is until we have added all rows for the entire table.
+    #
+    # Similarly, for the heights:
+    # Cells are not drawed with their initial heigths, but with the
+    # row-wide maximum height.
+    # This must happen at draw time, as we can't know what the max cell
+    # height is until we have added all cells for this row.
+    #
+    # @param  parent [Rasem::SVGTagWithParent]
+    # @param  col_widths [Array]  Table-wide max column widths
+    # @return  [Rasem::SVGTagWithParent]
+    #
+    def _draw(parent, max_col_widths)
+      Utils::RasemWrapper.group(parent, class: param(:class), id: param(:id)) do |row_group|
+        draw_border(row_group, width_override: max_col_widths.reduce(&:+))
+
+        cells.zip(max_col_widths).reduce(0) do |x, (cell, col_width)|
+          cell.draw(row_group, debug: @debug).translate(x, 0)
+          x + col_width
+        end
+      end
+    end
+
+    def cell_params
+      return child_params unless col_widths && col_widths[cells.size]
+      child_params.merge(width: col_widths[cells.size])
+    end
+
+    def find_incomplete_descendant
+      cells.each.with_object(nil) do |cell, _|
+        res = cell.incomplete
+        break res if res
+      end
+    end
+  end
+end

data/lib/svg_drawer/table/table.rb

@@ -0,0 +1,147 @@
+module SvgDrawer
+  class Table < Base
+    requires :columns
+
+    special :height       # table height is not the same as row height
+    special :row_height   # makes no sense for a row
+
+    defaults col_widths: nil
+
+    #
+    # Infer col_widths from width (if needed)
+    #
+    def self.col_widths(col_widths, width, columns)
+      return if col_widths.nil? && width.nil?
+      sum_width = col_widths.reduce(&:+) if col_widths
+
+      if col_widths && width && sum_width != width
+        raise ArgumentError, "Sum of given col widths (#{col_widths}) doesn't match total element width (#{width})"
+      end
+
+      col_widths || Array.new(columns, width.to_d / columns)
+    end
+
+    def width
+      ensure_complete!
+      sum_width = col_widths ? col_widths.reduce(&:+) : 0
+      max_width = max_col_widths.reduce(&:+)
+
+      [sum_width, max_width].max
+    end
+
+    def height
+      ensure_complete!
+      sum_height = rows.reduce(0) { |a, e| a + e.height }
+      [param(:height, 0), sum_height].max
+    end
+
+    def incomplete
+      rows.none? ? self : find_incomplete_descendant
+    end
+
+    def rows
+      @rows ||= []
+    end
+
+    def add_row(row)
+      raise TypeError, "Expected Row, got: #{row.class}" unless row.is_a?(Row)
+      row.update_params!(inherited: row_params)
+      rows << row
+    end
+
+    #
+    # The params hash can contain a special :height value
+    # It will be used instead of the @row_height when creating the row
+    #
+    # @param  params [Hash]  row params
+    # @return  [Table]  self
+    #
+    def row(params = {})
+      row = Row.new(params.merge(inherited: row_params))
+      yield(row)
+      rows << row
+      self
+    end
+
+    def text_row(texts, params = {})
+      texts = texts.nil? ? [nil] : Array(texts)
+      row(params) { |r| texts.each { |text| r.text_cell(text) } }
+    end
+
+    def path_row(path_components, params = {})
+      row(params) { |r| r.path_cell(path_components) }
+    end
+
+    def line_row(points, params = {})
+      row(params) { |r| r.line_cell(points) }
+    end
+
+    def polyline_row(points, params = {})
+      row(params) { |r| r.polyline_cell(points) }
+    end
+
+    def multipolyline_row(strokes, params = {})
+      row(params) { |r| r.multipolyline_cell(strokes) }
+    end
+
+    def circle_row(center, radius, params = {})
+      row(params) { |r| r.circle_cell(center, radius) }
+    end
+
+    def sub_table_row(params = {})
+      t = Table.new(params)
+      row { |r| r.cell { |c| c.content(t) && yield(t) } }
+    end
+
+    def blank_row(params = {})
+      raise ArgumentError, ':height required' if !param(:row_height) && !params[:height]
+      rows << BlankRow.new(params.merge(inherited: row_params))
+      self
+    end
+
+    def col_widths
+      Table.col_widths(param(:col_widths), param(:width), param(:columns))
+    end
+
+    private
+
+    #
+    # The dimension overrides given when the table is actually
+    # the child of a (parent) table cell.
+    # In this case the overrides are used to draw proper borders
+    # (since the Cell element of the parent determines its)
+    #
+    # @param  parent [Rasem::SVGTagWithParent]
+    # @param  width_override [Integer]  (optional) container width
+    # @param  height_override [Integer]  (optional) container height
+    # @return  [Rasem::SVGTagWithParent]
+    #
+    def _draw(parent)
+      Utils::RasemWrapper.group(parent, class: param(:class), id: param(:id)) do |table_group|
+        draw_border(table_group)
+
+        rows.reduce(0) do |y, row|
+          row.draw(table_group, max_col_widths, debug: @debug).translate(0, y)
+          y + row.height
+        end
+      end
+    end
+
+    def row_params
+      param(:row_height)
+      return child_params unless param(:row_height)
+      child_params.merge(height: param(:row_height))
+    end
+
+    def find_incomplete_descendant
+      rows.each.with_object(nil) do |row, _|
+        res = row.incomplete
+        break res if res
+      end
+    end
+
+    def max_col_widths
+      rows.map(&:cell_widths).transpose.map(&:max)
+    end
+  end
+end