thinreports 0.8.2 → 0.9.0

data/lib/thinreports/generator/pdf/document/graphics/basic.rb

@@ -4,6 +4,11 @@ module Thinreports
   module Generator
 
     module PDF::Graphics
+      STROKE_DASH = {
+        dashed: [2, 2],
+        dotted: [1, 2]
+      }
+
       # @param [Numeric, String] x1
       # @param [Numeric, String] y1
       # @param [Numeric, String] x2
@@ -11,7 +16,7 @@ module Thinreports
       # @param [Hash] attrs ({})
       # @option attrs [String] :stroke
       # @option attrs [Numeric, String] :stroke_width
-      # @option attrs [Array<Integer, String>] :stroke_dash
+      # @option attrs ["solid", "dashed", "dotted"] :stroke_type
       def line(x1, y1, x2, y2, attrs = {})
         with_graphic_styles(attrs) do
           pdf.line(pos(x1, y1), pos(x2, y2))
@@ -26,7 +31,7 @@ module Thinreports
       # @option attrs [Integer, String] :radius
       # @option attrs [String] :stroke
       # @option attrs [Numeric, String] :stroke_width
-      # @option attrs [Array<Integer, String>] :stroke_dash
+      # @option attrs ["solid", "dashed", "dotted"] :stroke_type
       # @option attrs [String] :fill
       def rect(x, y, w, h, attrs = {})
         w, h   = s2f(w, h)
@@ -49,6 +54,7 @@ module Thinreports
       # @option attrs [String] :stroke
       # @option attrs [Numeric, String] :stroke_width
       # @option attrs [Array<Integer, String>] :stroke_dash
+      # @option attrs ["solid", "dashed", "dotted"] :stroke_type
       # @option attrs [String] :fill
       def ellipse(x, y, rx, ry, attrs = {})
         rx, ry = s2f(rx, ry)
@@ -58,8 +64,6 @@ module Thinreports
         end
       end
 
-    private
-
       # @param [Hash] attrs
       def with_graphic_styles(attrs, &block)
         stroke = build_stroke_styles(attrs)
@@ -108,22 +112,23 @@ module Thinreports
       def build_stroke_styles(styles)
         color = styles[:stroke]
         width = styles[:stroke_width]
-
-        if color && color != 'none' && width && width != 0
-          {color: parse_color(color),
-           width: s2f(width),
-           dash: s2f(*styles[:stroke_dash])}
-        end
+        return nil unless color && color != 'none'
+        return nil unless width && width != 0
+
+        {
+          color: parse_color(color),
+          width: s2f(width),
+          dash: STROKE_DASH[styles[:stroke_type].to_sym]
+        }
       end
 
       # @param [Hash] styles
       # @return [Hash, nil]
       def build_fill_styles(styles)
         color = styles[:fill]
+        return nil unless color && color != 'none'
 
-        if color && color != 'none'
-          {color: parse_color(color)}
-        end
+        { color: parse_color(color) }
       end
 
     end

data/lib/thinreports/generator/pdf/document/graphics/image.rb

@@ -30,7 +30,7 @@ module Thinreports
         image(image_path, x, y, w, h)
       end
 
-      # @param file (see Prawn#image)
+      # @param [String, IO] file
       # @param [Numeric, Strng] x
       # @param [Numeric, Strng] y
       # @param [Numeric, Strng] w
@@ -39,13 +39,16 @@ module Thinreports
       # @option options [:left, :center, :right] :position_x (:left)
       # @option options [:top, :center, :bottom] :position_y (:top)
       def image_box(file, x, y, w, h, options = {})
-        image_path = normalize_image_from_file(file)
+        image_data_or_path = normalize_image_from_file(file)
 
         w, h = s2f(w, h)
         pdf.bounding_box(pos(x, y), width: w, height: h) do
-          pdf.image(image_path, position: options[:position_x] || :left,
-                                vposition: options[:position_y] || :top,
-                                auto_fit: [w, h])
+          pdf.image(
+            image_data_or_path,
+            position: options[:position_x] || :left,
+            vposition: options[:position_y] || :top,
+            auto_fit: [w, h]
+          )
         end
       end
 
@@ -69,13 +72,16 @@ module Thinreports
         create_temp_imagefile(image_id, image_data)
       end
 
-      def normalize_image_from_file(filename)
+      def normalize_image_from_file(file)
+        return file unless file.is_a?(String)
+
+        filename = file
         extname = File.extname(filename)
 
         return filename unless png_conversion_enabled?
         return filename unless extname.downcase == '.png' || extname.empty?
 
-        return temp_image_registry[filename] if temp_image_registry.key?(filename)
+        return temp_image_registry[filename].path if temp_image_registry.key?(filename)
 
         png_normalizer = PNGNormalizer.load_file(filename)
 
@@ -101,17 +107,16 @@ module Thinreports
 
       # @param [String] image_id
       # @param [String] image_data
-      # @return [String] imagefile path
+      # @return [String] Path to imagefile
       def create_temp_imagefile(image_id, image_data)
         temp_image_registry[image_id] ||= begin
           file = Tempfile.new('temp-image')
           file.binmode
           file.write(image_data)
-          file.path
-        ensure
-          file.close
+          file.open
+          file
         end
-        temp_image_registry[image_id]
+        temp_image_registry[image_id].path
       end
 
       def png_conversion_enabled?

data/lib/thinreports/generator/pdf/document/page.rb

@@ -48,7 +48,7 @@ module Thinreports
       # @param [Thinreports::Layout::Format] format
       def create_format_stamp(format)
         create_stamp(format.identifier.to_s) do
-          parse_svg(format.layout, '/svg/g')
+          draw_template_items(format.attributes['items'])
         end
         format_stamp_registry << format.identifier
       end

data/lib/thinreports/generator/pdf/drawer/list.rb

@@ -43,7 +43,11 @@ module Thinreports
       # @param [Thinreports::Core::Shape::List::SectionInterface] section
       def draw_section(section)
         internal = section.internal
-        drawer(internal).draw(section, internal.relative_position)
+
+        base_top = @format.section_base_position_top(internal.section_name)
+        position = [internal.relative_left, base_top + internal.relative_top]
+
+        drawer(internal).draw(section, position)
       end
 
       # @param [Thinreports::Core::Shape::List::SectionInternal] section

data/lib/thinreports/generator/pdf/drawer/list_section.rb

@@ -26,10 +26,7 @@ module Thinreports
         id = @format.identifier.to_s
 
         unless @stamp_created
-          @pdf.create_stamp(id) do
-            @pdf.parse_svg('<svg xmlns:xlink="http://www.w3.org/1999/xlink">' +
-                           "#{@format.layout}</svg>", '/svg')
-          end
+          @pdf.create_stamp(id) { @pdf.draw_template_items(@format.attributes['items']) }
           @stamp_created = true
         end
         pdf_stamp(id)

data/lib/thinreports/generator/pdf/drawer/page.rb

@@ -20,7 +20,7 @@ module Thinreports
 
           shape = shape.internal
 
-          if shape.type_of?(:pageno)
+          if shape.type_of?(Core::Shape::PageNumber::TYPE_NAME)
             # Do not draw pageno if is not for Report
             draw_pageno_shape(shape, page) if page.count? && shape.for_report?
           else
@@ -33,11 +33,11 @@ module Thinreports
 
       def draw_shape(shape)
         case
-        when shape.type_of?(:tblock)
+        when shape.type_of?(Core::Shape::TextBlock::TYPE_NAME)
           draw_tblock_shape(shape)
-        when shape.type_of?(:list)
+        when shape.type_of?(Core::Shape::List::TYPE_NAME)
           draw_list_shape(shape)
-        when shape.type_of?(:iblock)
+        when shape.type_of?(Core::Shape::ImageBlock::TYPE_NAME)
           draw_iblock_shape(shape)
         else
           id = shape.identifier
@@ -72,11 +72,11 @@ module Thinreports
       # @param [Thinreports::Core::Shape::Base::Internal] shape
       def create_basic_shape_stamp(shape)
         case
-        when shape.type_of?(:text)    then create_text_stamp(shape)
-        when shape.type_of?(:image)   then create_image_stamp(shape)
-        when shape.type_of?(:ellipse) then create_ellipse_stamp(shape)
-        when shape.type_of?(:rect)    then create_rect_stamp(shape)
-        when shape.type_of?(:line)    then create_line_stamp(shape)
+        when shape.type_of?('text')    then create_text_stamp(shape)
+        when shape.type_of?('image')   then create_image_stamp(shape)
+        when shape.type_of?('ellipse') then create_ellipse_stamp(shape)
+        when shape.type_of?('rect')    then create_rect_stamp(shape)
+        when shape.type_of?('line')    then create_line_stamp(shape)
         end
       end
 

data/lib/thinreports/layout.rb

@@ -1,17 +1,17 @@
 # coding: utf-8
 
 module Thinreports
-  
+
   module Layout
     # @see Thinreports::Layout::Base#initialize
     def self.new(filename, options = {})
       Base.new(filename, options)
     end
   end
-  
+
 end
 
 require 'thinreports/layout/version'
 require 'thinreports/layout/base'
 require 'thinreports/layout/format'
-require 'thinreports/layout/configuration'
+require 'thinreports/layout/legacy_schema'

data/lib/thinreports/layout/base.rb

@@ -44,22 +44,6 @@ module Thinreports
       def default?
         @id.nil?
       end
-
-      # @yield [config]
-      # @yieldparam [List::Configuration] config
-      # @return [List::Configuration]
-      def config(&block)
-        @config ||= Layout::Configuration.new(self)
-        call_block_in(@config, &block)
-      end
-
-      # @param [Thinreports::Report::Base] parent
-      # @param [Hash] options ({})
-      # @option option [Boolean] :count (true)
-      # @return [Page]
-      def new_page(parent, options = {})
-        Report::Page.new(parent, self, options)
-      end
     end
 
   end

data/lib/thinreports/layout/format.rb

@@ -1,80 +1,61 @@
 # coding: utf-8
-
-require 'digest/sha1'
+require 'json'
 
 module Thinreports
   module Layout
-
     class Format < Core::Shape::Manager::Format
       config_reader last_version: %w( version )
-      config_reader report_title: %w( config title )
-      config_reader page_paper_type: %w( config page paper-type ),
-                    page_width: %w( config page width ),
-                    page_height: %w( config page height ),
-                    page_orientation: %w( config page orientation )
-
-      config_checker 'user', user_paper_type: %w( config page paper-type )
+      config_reader report_title: %w( title )
+      config_reader page_paper_type: %w( report paper-type ),
+                    page_width: %w( report width ),
+                    page_height: %w( report height ),
+                    page_orientation: %w( report orientation )
 
       class << self
+        def build(filename)
+          schema = JSON.parse(read_file(filename))
 
-      private
-
-        # @param [String] filename
-        # @param [Hash] options
-        # @option options [Boolean] :force (false)
-        def build_internal(filename, options = {})
-          build_once(filename, options[:force]) do |content, id|
-            raw_format = parse_json(content)
-
-            # Check the compatibility of specified layout file.
-            unless Thinreports::Layout::Version.compatible?(raw_format['version'])
-              info = [filename, raw_format['version'],
-                      Thinreports::Layout::Version.inspect_required_rules]
-              raise Thinreports::Errors::IncompatibleLayoutFormat.new(*info)
-            end
-
-            compact_format!(raw_format)
+          unless Layout::Version.compatible?(schema['version'])
+            raise Errors::IncompatibleLayoutFormat.new(
+              filename, schema['version'], Thinreports::Layout::Version.inspect_required_rules
+            )
+          end
 
-            # Build and initialize format.
-            new(raw_format, id) do |f|
-              build_layout(f) do |type, shape_format|
-                Core::Shape::Format(type).build(shape_format)
-              end
-              clean(f.layout)
-            end
+          if schema['version'] < '0.9.0'
+            warn '[DEPRECATION] Support for the layout file with old format that generated with Editor 0.8 or lower will be dropped in Thinreports 1.1.' \
+                 ' Please convert to new layout format using Thinreports Editor 0.9 or 1.0.'
+            schema = Layout::LegacySchema.new(schema).upgrade
           end
+
+          new schema
         end
 
-        # @param [Hash] raw_format A parsed json.
-        def compact_format!(raw_format)
-          %w( finger-print state version ).each {|attr| raw_format.delete(attr) }
+        def read_file(filename)
+          File.open(filename, 'r:UTF-8') {|f| f.read }
         end
+      end
 
-        # @param [String] filename
-        # @param [Boolean] force (false)
-        def build_once(filename, force = false, &block)
-          content = read_format_file(filename)
+      def initialize(*)
+        super
+        initialize_items(attributes['items'])
+      end
 
-          if force
-            block.call(content, nil)
-          else
-            id = Digest::SHA1.hexdigest(content).to_sym
-            built_format_registry[id] ||= block.call(content, id)
-          end
-        end
+      def user_paper_type?
+        page_paper_type == 'user'
+      end
 
-        # @param [String] filename
-        # @return [String]
-        def read_format_file(filename)
-          File.open(filename, 'r:UTF-8') {|f| f.read }
-        end
+      private
+
+      def initialize_items(item_schemas)
+        item_schemas.each do |item_schema|
+          id, type = item_schema.values_at 'id', 'type'
 
-        # @return [Hash]
-        def built_format_registry
-          @built_format_registry ||= {}
+          next if id.empty? && type != 'page-number'
+
+          item = Core::Shape::Format(type).new(item_schema)
+          self.shapes[item.id.to_sym] = item
         end
       end
     end
-
   end
 end

data/lib/thinreports/layout/legacy_schema.rb

@@ -0,0 +1,354 @@
+# coding: utf-8
+
+require 'json'
+require 'rexml/document'
+
+module Thinreports
+  module Layout
+    class LegacySchema
+      def initialize(legacy_schema)
+        @legacy_schema = legacy_schema
+      end
+
+      def upgrade
+        config = legacy_schema['config']
+        page_config = config['page']
+
+        {
+          'version' => legacy_schema['version'],
+          'title' => legacy_schema['config']['title'],
+          'report' => {
+            'paper-type' => page_config['paper-type'],
+            'width' => page_config['width'].to_f,
+            'height' => page_config['height'].to_f,
+            'orientation' => page_config['orientation'],
+            'margin' => page_config.values_at('margin-top', 'margin-right', 'margin-bottom', 'margin-left').map(&:to_f)
+          },
+          'items' => build_item_schemas_from_svg(legacy_schema['svg'].dup, '/svg/g', 1)
+        }
+      end
+
+      attr_reader :legacy_schema
+
+      def build_item_schemas_from_svg(svg, root_xpath, level)
+        item_schemas = extract_item_schemas(svg, level)
+
+        svg_doc = REXML::Document.new(normalize_svg(svg, level))
+        items = []
+
+        svg_doc.elements[root_xpath].each do |item_element|
+          item_schema = item_schemas[item_element.attributes['x-id']] || {}
+          item_attributes = item_element.attributes
+
+          items <<
+            case item_element.attributes['class']
+            when 's-text' then text_item_schema(item_attributes, extract_texts_from(item_element))
+            when 's-image' then image_item_schema(item_attributes)
+            when 's-rect' then rect_item_schema(item_attributes)
+            when 's-ellipse' then ellipse_item_schema(item_attributes)
+            when 's-line' then line_item_schema(item_attributes)
+            when 's-tblock' then text_block_item_schema(item_attributes)
+            when 's-iblock' then image_block_item_schema(item_attributes)
+            when 's-pageno' then page_number_item_schema(item_attributes)
+            when 's-list' then list_item_schema(item_schema)
+            else raise 'Unknown item type'
+            end
+        end
+
+        items
+      end
+
+      def text_item_schema(attributes, texts)
+        {
+          'id' => attributes['x-id'],
+          'type' => Core::Shape::Text::TYPE_NAME,
+          'x' => attributes['x-left'].to_f,
+          'y' => attributes['x-top'].to_f,
+          'width' => attributes['x-width'].to_f,
+          'height' => attributes['x-height'].to_f,
+          'display' => display(attributes['x-display']),
+          'texts' => texts,
+          'style' => {
+            'font-family' => [ attributes['font-family'] ],
+            'font-size' => attributes['font-size'].to_f,
+            'color' => attributes['fill'],
+            'font-style' => font_style(attributes),
+            'text-align' => text_align(attributes['text-anchor']),
+            'vertical-align' => vertical_align(attributes['x-valign']),
+            'line-height' => line_height(attributes['x-line-height']),
+            'letter-spacing' => letter_spacing(attributes['kerning'])
+          }
+        }
+      end
+
+      def rect_item_schema(attributes)
+        {
+          'id' => attributes['x-id'],
+          'type' => 'rect',
+          'x' => attributes['x'].to_f,
+          'y' => attributes['y'].to_f,
+          'width' => attributes['width'].to_f,
+          'height' => attributes['height'].to_f,
+          'display' => display(attributes['x-display']),
+          'style' => {
+            'border-width' => attributes['stroke-width'].to_f,
+            'border-color' => attributes['stroke'],
+            'border-style' => attributes['x-stroke-type'],
+            'fill-color' => attributes['fill']
+          }
+        }
+      end
+
+      def line_item_schema(attributes)
+        {
+          'id' => attributes['x-id'],
+          'type' => 'line',
+          'x1' => attributes['x1'].to_f,
+          'y1' => attributes['y1'].to_f,
+          'x2' => attributes['x2'].to_f,
+          'y2' => attributes['y2'].to_f,
+          'display' => display(attributes['x-display']),
+          'style' => {
+            'border-width' => attributes['stroke-width'].to_f,
+            'border-color' => attributes['stroke'],
+            'border-style' => attributes['x-stroke-type']
+          }
+        }
+      end
+
+      def ellipse_item_schema(attributes)
+        {
+          'id' => attributes['x-id'],
+          'type' => 'ellipse',
+          'cx' => attributes['cx'].to_f,
+          'cy' => attributes['cy'].to_f,
+          'rx' => attributes['rx'].to_f,
+          'ry' => attributes['ry'].to_f,
+          'display' => display(attributes['x-display']),
+          'style' => {
+            'border-width' => attributes['stroke-width'].to_f,
+            'border-color' => attributes['stroke'],
+            'border-style' => attributes['x-stroke-type'],
+            'fill-color' => attributes['fill']
+          }
+        }
+      end
+
+      def image_item_schema(attributes)
+        _, image_type, image_data = attributes['xlink:href'].match(%r|^data:(image/[a-z]+?);base64,(.+)|).to_a
+
+        {
+          'id' => attributes['x-id'],
+          'type' => 'image',
+          'x' => attributes['x'].to_f,
+          'y' => attributes['y'].to_f,
+          'width' => attributes['width'].to_f,
+          'height' => attributes['height'].to_f,
+          'display' => display(attributes['x-display']),
+          'data' => {
+            'mime-type' => image_type,
+            'base64' => image_data
+          }
+        }
+      end
+
+      def page_number_item_schema(attributes)
+        {
+          'id' => attributes['x-id'],
+          'type' => Core::Shape::PageNumber::TYPE_NAME,
+          'x' => attributes['x-left'].to_f,
+          'y' => attributes['x-top'].to_f,
+          'width' => attributes['x-width'].to_f,
+          'height' => attributes['x-height'].to_f,
+          'format' => attributes['x-format'],
+          'target' => attributes['x-target'],
+          'display' => display(attributes['x-display']),
+          'style' => {
+            'font-family' => [ attributes['font-family'] ],
+            'font-size' => attributes['font-size'].to_f,
+            'color' => attributes['fill'],
+            'font-style' => font_style(attributes),
+            'text-align' => text_align(attributes['text-anchor']),
+            'overflow' => attributes['x-overflow']
+          }
+        }
+      end
+
+      def image_block_item_schema(attributes)
+        {
+          'id' => attributes['x-id'],
+          'type' => Core::Shape::ImageBlock::TYPE_NAME,
+          'x' => attributes['x-left'].to_f,
+          'y' => attributes['x-top'].to_f,
+          'width' => attributes['x-width'].to_f,
+          'height' => attributes['x-height'].to_f,
+          'display' => display(attributes['x-display']),
+          'style' => {
+            'position-x' => attributes['x-position-x'],
+            'position-y' => image_position_y(attributes['x-position-y'])
+          }
+        }
+      end
+
+      def text_block_item_schema(attributes)
+        text_format = {
+          'base' => attributes['x-format-base'],
+          'type' => attributes['x-format-type']
+        }
+        case text_format['type']
+        when 'datetime'
+          text_format['datetime'] = {
+            'format' => attributes['x-format-datetime-format']
+          }
+        when 'number'
+          text_format['number'] = {
+            'delimiter' => attributes['x-format-number-delimiter'],
+            'precision' => attributes['x-format-number-precision'].to_i
+          }
+        when 'padding'
+          text_format['padding'] = {
+            'length' => attributes['x-format-padding-length'].to_i,
+            'char' => attributes['x-format-padding-char'],
+            'direction' => attributes['x-format-padding-direction']
+          }
+        end
+
+        {
+          'id' => attributes['x-id'],
+          'type' => Core::Shape::TextBlock::TYPE_NAME,
+          'x' => attributes['x-left'].to_f,
+          'y' => attributes['x-top'].to_f,
+          'width' => attributes['x-width'].to_f,
+          'height' => attributes['x-height'].to_f,
+          'display' => display(attributes['x-display']),
+          'value' => attributes['x-value'],
+          'multiple-line' => attributes['x-multiple'] == 'true',
+          'format' => text_format,
+          'style' => {
+            'font-family' => [ attributes['font-family'] ],
+            'font-size' => attributes['font-size'].to_f,
+            'color' => attributes['fill'],
+            'font-style' => font_style(attributes),
+            'text-align' => text_align(attributes['text-anchor']),
+            'vertical-align' => vertical_align(attributes['x-valign']),
+            'line-height' => line_height(attributes['x-line-height']),
+            'letter-spacing' => letter_spacing(attributes['kerning']),
+            'overflow' => attributes['x-overflow'],
+            'word-wrap' => attributes['x-word-wrap']
+          }
+        }
+      end
+
+      def list_item_schema(legacy_schema)
+        {
+          'id' => legacy_schema['id'],
+          'type' => Core::Shape::List::TYPE_NAME,
+          'content-height' => legacy_schema['content-height'].to_f,
+          'auto-page-break' => legacy_schema['page-break'] == 'true',
+          'display' => display(legacy_schema['display']),
+          'header' => list_section_schema('header', legacy_schema),
+          'detail' => list_section_schema('detail', legacy_schema),
+          'page-footer' => list_section_schema('page-footer', legacy_schema),
+          'footer' => list_section_schema('footer', legacy_schema)
+        }
+      end
+
+      def list_section_schema(section_name, legacy_list_schema)
+        legacy_section_schema = legacy_list_schema[section_name]
+
+        section_svg = %(<svg xmlns:xlink="http://www.w3.org/1999/xlink">#{legacy_section_schema['svg']['content']}</svg>)
+
+        section_schema = {
+          'height' => legacy_section_schema['height'].to_f,
+          'translate' => {
+            'x' => legacy_section_schema['translate']['x'].to_f,
+            'y' => legacy_section_schema['translate']['y'].to_f
+          },
+          'items' => build_item_schemas_from_svg(section_svg, '/svg', 2)
+        }
+
+        unless section_name == 'detail'
+          section_schema['enabled'] = legacy_list_schema["#{section_name}-enabled"] == 'true'
+        end
+        section_schema
+      end
+
+      def extract_texts_from(text_item_element)
+        [].tap do |texts|
+          text_item_element.each_element('text') { |e| texts << e.text }
+        end
+      end
+
+      def image_position_y(legacy_position_y)
+        case legacy_position_y
+        when 'top' then 'top'
+        when 'center' then 'middle'
+        when 'bottom' then 'bottom'
+        end
+      end
+
+      def display(legacy_display)
+        legacy_display == 'true'
+      end
+
+      def font_style(attributes)
+        style = []
+        style << 'bold' if attributes['font-weight'] == 'bold'
+        style << 'italic' if attributes['font-style'] == 'italic'
+        style << 'underline' if attributes['text-decoration'].include?('underline')
+        style << 'linethrough' if attributes['text-decoration'].include?('line-through')
+        style
+      end
+
+      def text_align(legacy_text_align)
+        case legacy_text_align
+        when 'start' then 'left'
+        when 'middle' then 'center'
+        when 'end' then 'right'
+        else 'left'
+        end
+      end
+
+      def vertical_align(legacy_vertical_align)
+        return nil unless legacy_vertical_align
+
+        case legacy_vertical_align
+        when 'top' then 'top'
+        when 'center' then 'middle'
+        when 'bottom' then 'bottom'
+        else 'top'
+        end
+      end
+
+      def line_height(legacy_line_height)
+        legacy_line_height == '' ? '' : legacy_line_height.to_f
+      end
+
+      def letter_spacing(legacy_letter_spacing)
+        case legacy_letter_spacing
+        when 'auto', '' then ''
+        else legacy_letter_spacing.to_f
+        end
+      end
+
+      def extract_item_schemas(svg, level)
+        items = {}
+        svg.scan(/<!--#{level_symbol(level)}SHAPE(.*?)SHAPE#{level_symbol(level)}-->/) do |(item_schema_json)|
+          item_schema = JSON.parse(item_schema_json)
+          items[item_schema['id']] = item_schema
+        end
+        items
+      end
+
+      def normalize_svg(svg, level)
+        svg.gsub!(/<!--#{level_symbol(level)}SHAPE.*?SHAPE#{level_symbol(level)}-->/, '')
+        svg.gsub!(/<!--#{level_symbol(level)}LAYOUT(.*?)LAYOUT#{level_symbol(level)}-->/) { $1 }
+        svg
+      end
+
+      def level_symbol(level)
+        '-' * (level - 1)
+      end
+    end
+  end
+end