svg_drawer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79996165279d088f2e412c952599a1f4425e6022
+  data.tar.gz: 72e4bce3f625e41bf91d581ab1b17f529f7f8619
+SHA512:
+  metadata.gz: 64e21f2a34481ceb931564a69b13c910fcda76de467e9f1507e8d472e9e3e51c0b20a953e4d10b1c38bf8ea485fe9c10bb1de7daf1ca7c07fb6c9d576777d63c
+  data.tar.gz: 545bf250522002f54b193fdc1ce20776f1287c30bacf5d52c488e5627f06b1f82076d6c37d5bbfaa136c48c4dd4c259433b8c2d3b8db7908674c8409ccb68485

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Simeon Manolov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/fonts.yml

@@ -0,0 +1,43 @@
+#
+# Heights and widths calculated experimentally with chrome inspector.
+#
+# y_offset is also calculated experimentally with chrome inspector:
+# As opposed to HTML, in SVG when a text is drawed, all text is
+# *transposed* down by (1.2 * [font_height]) px.
+# This causes problems when drawing a text box with a border, as
+# chars like 'g' or 'p' will intersect with the bottom border (and
+# and '_' char will even be drawed entirely below the border)
+# This is compensated with the y_offset, which seems to be ~0.22
+# (how that value is used can be seen in #calculate_y_offset_px)
+#
+
+default:
+  width: 0.63
+  height: 1.2
+  y_offset: 0.23
+  wrap_policies:
+    weak: 1
+    normal: 1
+    aggressive: 1
+    max: 1
+
+'NK57 Monospace':
+  width: 0.63
+
+'Ubuntu Mono':
+  width: 0.5
+
+'Roboto Mono':
+  width: 0.596
+
+'Courier New':
+  width: 0.8
+
+'Arial':
+  width: 0.63
+  height: 1.3
+  wrap_policies:
+    weak: 0.9             # english text with very occasional capitals
+    normal: 1             # randomly mixed small/capital chars
+    aggressive: 1.17      # capital chars
+    max: 1.85             # capital "W" (widest english char)

data/lib/svg_drawer/base.rb

@@ -0,0 +1,215 @@
+module SvgDrawer
+  class Base
+    class ElementIncomplete < StandardError
+      def initialize(element)
+        super("Element incomplete: #{element.inspect}")
+      end
+    end
+
+    class << self
+      attr_reader :required_params, :special_params, :default_params
+
+      #
+      # The required_params contain param keys vital to the element.
+      # For example, a table can't be initialized without a :columns param.
+      # Their values can be provided via inherited_params.
+      #
+      def requires(*names)
+        required_params.concat(names)
+      end
+
+      #
+      # The special_params contain param keys special to the element.
+      # They will not be stored in @child_params
+      # See note in #initialize
+      #
+      def special(*names)
+        # Ensure special param are also a valid param (see ParameterMerger#param)
+        names_hash = names.map { |n| [n, nil] }.to_h
+
+        # this just Hash#reverse_merge! as implemented in activesupport-4.2
+        default_params.merge!(names_hash) { |_key, left, _right| left }
+        special_params.concat(names)
+      end
+
+      #
+      # The default_values is a hash of param values that will be
+      # used as a last-resort fallback
+      #
+      # With and height are applicable to all elements, so they
+      # are always included here to avoid "No such param" errors
+      # (see ParamMerger#param for details)
+      #
+      def defaults(hash)
+        default_params.update(hash)
+      end
+
+      def required_params
+        @required_params ||= []
+      end
+
+      # These should never be passed down to children
+      def special_params
+        @special_params ||= %i[id class inherited border borders]
+      end
+
+      # Mark these as valid for *all* elements (no default value though)
+      def default_params
+        @default_params ||= {
+          id: nil,
+          class: name.gsub(/.*::/, '').downcase,
+          width: nil,
+          height: nil,
+          border: nil,
+          borders: nil,
+          border_style: nil
+        }
+      end
+    end
+
+    attr_writer :width, :height
+    attr_reader :params, :inherited_params, :child_params
+
+    #
+    # All elements can are initialized with a params hash *only*.
+    # This hash contains stuff regular keys like :width, :height, etc.
+    # If this hash does *not* contain any of the keys found
+    # in self.class.required_params, an error is risen.
+    # It may contain an :inherited. Its value is a hash
+    # which will serve as a fall-back to any keys not found in the top-level
+    # hash.
+    # For example:
+    # { width: 100, inherited: { width: 200, height: 500 } }
+    #
+    # Calling #param(:width) on the element will return 100
+    # Calling #param(:height) on the element will return 500
+    # Calling #param(:foo) will not be found in any of the hashes, so
+    # it will be looked up in self.class.default_params:
+    #   - if found, will be returned
+    #   - if not found, an error will be risen (see ParameterMerger#param)
+    #
+    # A special @child_params hash is automatically constructed every
+    # time #update_params! is called (incl. #initialize)
+    # It is a hash that will be passed on as the value of
+    # the :inherited key to any child elements constructed.
+    # Note that it will not contain any keys found in self.class.special_params
+    #
+    # Inheritance example:
+    #
+    #   Table.new(font: 'A') do |table|
+    #     table.row do |row|
+    #       row.cell do |cell|
+    #         cell.content = TextBox.new('foo')      # text 1
+    #       end
+    #
+    #     table.row(font: 'B') do |row|
+    #       row.cell do |cell|
+    #         cell.content = TextBox.new('foo')      # text 2
+    #       end
+    #
+    #       row.cell(font: 'C') do |cell|
+    #         cell.content = TextBox.new('foo')      # text 3
+    #       end
+    #
+    #       row.cell(font: 'C') do |cell|
+    #         cell.content(TextBox.new('foo', font: 'D')) # text 4
+    #       end
+    #     end
+    #   end
+    #
+    # The texts 1, 2, 3 and 4 will have font 'A', 'B', 'C' and 'D'.
+    #
+    def initialize(params = {})
+      @params = {}
+      @inherited_params = {}
+      @child_params = {}
+      @pmerger = Utils::ParameterMerger.new(@params,
+                                            @inherited_params,
+                                            self.class.default_params)
+
+      update_params!(params)
+    end
+
+    # The way to update an element's params
+    def update_params!(params)
+      @params.update(_deep_dup(params))
+      @inherited_params.update(@params.delete(:inherited) || {})
+
+      # Note: self.class.default_params is NOT to be merged in @child_params
+      @child_params = @inherited_params.merge(@params)
+      self.class.special_params.each { |name| @child_params.delete(name) }
+
+      self.class.required_params.each do |rp|
+        raise "Required param is missing: #{rp}" unless @pmerger.param?(rp)
+      end
+    end
+
+    def param(name, default = nil)
+      @pmerger.param(name) || default
+    end
+
+    def param!(name)
+      param(name) or raise "No default value for: #{name}"
+    end
+
+    def draw(*args, debug: false)
+      ensure_complete!
+      @debug = debug
+      _draw(*args)
+    end
+
+    def ensure_complete!
+      pending_element = incomplete
+      raise ElementIncomplete, pending_element if pending_element
+    end
+
+    #
+    # To be defined in subclasses
+    #
+
+    def width
+      raise NotImplementedError
+    end
+
+    def height
+      raise NotImplementedError
+    end
+
+    def incomplete
+      raise NotImplementedError
+    end
+
+    private
+
+    def _draw(*)
+      raise NotImplementedError
+    end
+
+    def _complete?
+      raise NotImplementedError
+    end
+
+    def draw_border(svg, width_override: width, height_override: height)
+      borders = param(:borders)
+      borders ||= %i[left right top bottom] if param(:border)
+      Border.draw(
+        svg,
+        width_override,
+        height_override,
+        borders,
+        param(:border_style),
+        param(:class),
+        @debug
+      )
+    end
+
+    def _deep_dup(value)
+      case value
+      when Array then value.map { |v| _deep_dup(v) }
+      when Hash then value.map { |k, v| [_deep_dup(k), _deep_dup(v)] }.to_h
+      when Fixnum, Float, Symbol, TrueClass, FalseClass then value
+      else value.dup
+      end
+    end
+  end
+end

data/lib/svg_drawer/circle.rb

@@ -0,0 +1,139 @@
+module SvgDrawer
+  class Circle < Base
+    defaults fill: 'none',
+             stroke: 'black',
+             size: 1,
+             x_reposition: 'none',  # none/left/center/right
+             y_reposition: 'none',  # none/top/middle/bottom
+             expand: false,
+             shrink: false,
+             overflow: false,
+             scale: 1,
+             scale_size: true
+
+    def initialize(center, radius, params = {})
+      @center = center
+      @radius = radius
+      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
+      false
+    end
+
+    def min_x
+      @min_x ||= @center.first - @radius
+    end
+
+    def max_x
+      @max_x ||= @center.first + @radius
+    end
+
+    def min_y
+      @min_y ||= @center.last - @radius
+    end
+
+    def max_y
+      @max_y ||= @center.last + @radius
+    end
+
+    private
+
+    def _draw(parent)
+      size = param(:scale_size) ? param(:size) : param(:size) / scale
+      style = {}
+
+      # need symbol keys due to a bug in Rasem::SVGTag#write_styles
+      style[:fill] = param(:fill)
+      style[:stroke] = param(:stroke)
+      style[:'stroke-width'] = size
+
+      Utils::RasemWrapper.group(parent, class: 'circle') do |circle_group|
+        poly = circle_group.circle(@center.first, @center.last, @radius, 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
+  end
+end

data/lib/svg_drawer/line.rb

@@ -0,0 +1,10 @@
+module SvgDrawer
+  class Line < Polyline
+    # Retranslate ensures the parent element can correctly draw borders
+    defaults Polyline.default_params
+
+    def incomplete
+      @points.size != 4 && self
+    end
+  end
+end

data/lib/svg_drawer/multipolyline.rb

@@ -0,0 +1,144 @@
+module SvgDrawer
+  class Multipolyline < Base
+    special :x_reposition, :y_reposition, :resize, :overflow,
+            :height, :width, :scale, :scale_size
+
+    # See notes in Polyline
+    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,
+             overflow: false,
+             scale: 1,
+             scale_size: true
+
+    def initialize(strokes, params = {})
+      super(params)
+      @polylines = strokes.map { |stroke| Polyline.new(stroke, child_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
+      @polylines.none? ? self : @polylines.find(&:incomplete)
+    end
+
+    private
+
+    def _draw(parent)
+      unless param(:scale_size)
+        @polylines.each { |p| p.update_params!(size: param(:size) / scale) }
+      end
+
+      Utils::RasemWrapper.group(parent, class: 'multi_polyline') do |mpoly_group|
+        # Need a sub-group to prevent parents from overwriting translate()
+        grouped = Utils::RasemWrapper.group(mpoly_group) do |g|
+          @polylines.each { |p| p.draw(g, debug: @debug) }
+        end
+
+        grouped.translate(translate_x, translate_y).scale(scale, scale)
+      end
+    end
+
+    def min_x
+      @min_x ||= @polylines.min_by(&:min_x).min_x
+    end
+
+    def max_x
+      @max_x ||= @polylines.max_by(&:max_x).max_x
+    end
+
+    def min_y
+      @min_y ||= @polylines.min_by(&:min_y).min_y
+    end
+
+    def max_y
+      @max_y ||= @polylines.max_by(&:max_y).max_y
+    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
+  end
+end

data/lib/svg_drawer/path.rb

@@ -0,0 +1,43 @@
+module SvgDrawer
+  class Path < Base
+    # Required since there is no known way to calculate them
+    requires :width
+    requires :height
+
+    # Retranslate ensures the parent element can correctly draw borders
+    defaults scale: [1, 1],
+             overflow: true,      # false not supported
+             retranslate: false   # true not supported
+
+    def initialize(path_components, defaults = {})
+      super(defaults)
+      @components = path_components
+    end
+
+    # No idea how to compute dimensions for paths
+    def width
+      raise NotImplementedError unless param(:overflow)
+      param(:width)
+    end
+
+    def height
+      raise NotImplementedError unless param(:overflow)
+      param(:height)
+    end
+
+    def incomplete
+      false
+    end
+
+    private
+
+    def _draw(parent)
+      # No idea how to find boundary coordinates
+      raise NotImplementedError if param(:retranslate)
+
+      Utils::RasemWrapper.group(parent, class: 'path') do |path_group|
+        @components.each { |path| path_group.path(d: path) }
+      end.scale(*param(:scale))
+    end
+  end
+end