thinreports 0.12.1 → 0.13.0

data/lib/thinreports/basic_report/layout/legacy_schema.rb

@@ -0,0 +1,383 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rexml/document'
+
+module Thinreports
+  module BasicReport
+    module Layout
+      class LegacySchema
+        include Utils
+
+        def initialize(legacy_schema)
+          @legacy_schema = legacy_schema
+          @legacy_svg = legacy_schema['svg'].dup
+          @legacy_item_schemas = extract_legacy_item_schemas(legacy_svg)
+
+          @legacy_svg = cleanup_svg(@legacy_svg)
+        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' => item_schemas
+          }
+        end
+
+        attr_reader :legacy_schema, :legacy_svg, :legacy_item_schemas
+
+        def item_schemas
+          svg = REXML::Document.new(legacy_svg)
+          build_item_schemas_from_svg(svg.elements['/svg/g'])
+        end
+
+        def build_item_schemas_from_svg(svg_elements)
+          return [] unless svg_elements
+
+          items = []
+
+          svg_elements.each do |item_element|
+            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_element)
+              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']),
+            'border-radius' => attributes['rx'].to_i,
+            '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,
+            'reference-id' => attributes['x-ref-id'],
+            '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_element)
+          legacy_schema = legacy_item_schemas[legacy_element.attributes['x-id']]
+
+          header = list_section_schema('header', legacy_element, legacy_schema)
+          detail = list_section_schema('detail', legacy_element, legacy_schema)
+          page_footer = list_section_schema('page-footer', legacy_element, legacy_schema)
+          footer = list_section_schema('footer', legacy_element, legacy_schema)
+
+          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' => header,
+            'detail' => detail,
+            'page-footer' => page_footer,
+            'footer' => footer
+          }
+
+          page_footer['translate']['y'] += detail['height'] if page_footer['enabled']
+
+          if footer['enabled']
+            footer['translate']['y'] += detail['height']
+            footer['translate']['y'] += page_footer['height'] if page_footer['enabled']
+          end
+          schema
+        end
+
+        def list_section_schema(section_name, legacy_list_element, legacy_list_schema)
+          legacy_section_schema = legacy_list_schema[section_name]
+          return {} if legacy_section_schema.empty?
+
+          section_item_elements = legacy_list_element.elements["g[@class='s-list-#{section_name}']"]
+
+          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_item_elements)
+          }
+
+          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 '' 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)
+          blank_value?(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_legacy_item_schemas(svg)
+          items = {}
+          svg.scan(/<!--SHAPE(.*?)SHAPE-->/) do |(item_schema_json)|
+            item_schema = JSON.parse(item_schema_json)
+            items[item_schema['id']] = item_schema
+          end
+          items
+        end
+
+        def cleanup_svg(svg)
+          cleaned_svg = svg.gsub(/<!--SHAPE.*?SHAPE-->/, '')
+          cleaned_svg.gsub(/<!--LAYOUT(.*?)LAYOUT-->/) { $1 }
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/layout/version.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Layout
+      class Version
+        COMPATIBLE_RULES = ['>= 0.8.0', '< 1.0.0'].freeze
+        NEW_SCHEMA_FROM = '0.9.0'
+
+        class << self
+          def compatible_rules
+            COMPATIBLE_RULES
+          end
+        end
+
+        def initialize(schema_version)
+          @schema_version = normalize_version(schema_version)
+        end
+
+        def compatible?
+          self.class.compatible_rules.all? do |rule|
+            op, ver = rule.split(' ')
+            schema_version.send(op.to_sym, normalize_version(ver))
+          end
+        end
+
+        def legacy?
+          @schema_version < normalize_version(NEW_SCHEMA_FROM)
+        end
+
+        private
+
+        attr_reader :schema_version
+
+        def normalize_version(version)
+          Gem::Version.create(version)
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/{layout.rb → basic_report/layout.rb}

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Thinreports
-  module Layout
-    # @see Thinreports::Layout::Base#initialize
-    def self.new(filename, options = {})
-      Base.new(filename, options)
+  module BasicReport
+    module Layout
+      # @see Thinreports::BasicReport::Layout::Base#initialize
+      def self.new(filename, options = {})
+        Base.new(filename, options)
+      end
     end
   end
 end

data/lib/thinreports/basic_report/report/base.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Report
+      class Base
+        extend  Forwardable
+        include Utils
+
+        class << self
+          # @param options (see #initialize)
+          # @option options (see #initialize)
+          # @yield [report]
+          # @yieldparam [Thinreports::BasicReport::Report::Base] report
+          # @return [Thinreports::BasicReport::Report::Base]
+          def create(options = {}, &block)
+            raise ArgumentError, '#create requires a block' unless block_given?
+
+            report = new(options)
+            call_block_in(report, &block)
+            report.finalize
+
+            report
+          end
+
+          # @param layout (see #initialize)
+          # @param filename (see #generate)
+          # @param security (see #generate)
+          # @param [Hash] report ({}) DEPRECATED. Options for Report.
+          # @param [Hash] generator ({}) DEPRECATED. Options for Generator.
+          # @yield (see .create)
+          # @yieldparam (see .create)
+          # @return [String]
+          def generate(layout: nil, filename: nil, security: nil, report: {}, generator: {}, &block)
+            raise ArgumentError, '#generate requires a block' unless block_given?
+
+            if report.any? || generator.any?
+              warn '[DEPRECATION] :report and :generator argument has been deprecated. ' \
+                   'Use :layout and :filename, :security argument instead.'
+            end
+
+            layout ||= report[:layout]
+            filename ||= generator[:filename]
+            security ||= generator[:security]
+
+            report = create(layout: layout, &block)
+            report.generate(filename: filename, security: security)
+          end
+        end
+
+        # @return [Thinreports::BasicReport::Report::Internal]
+        attr_reader :internal
+
+        # @return [Integer]
+        attr_reader :start_page_number
+
+        # @return [Thinreports::BasicReport::Report::Page]
+        def_delegator :internal, :page
+
+        # @return [Integer]
+        def_delegator :internal, :page_count
+
+        # @return [Array<Thinreports::BasicReport::Report::Page>]
+        def_delegator :internal, :pages
+
+        # @return [Thinreports::BasicReport::Layout::Base]
+        def_delegator :internal, :default_layout
+
+        # @param [Hash] options
+        # @option options [String, nil] :layout (nil)
+        def initialize(options = {})
+          @internal = Report::Internal.new(self, options)
+          @start_page_number = 1
+        end
+
+        # @yield [page]
+        # @yieldparam [Thinreports::BasicReport::Report::Page] page
+        # @example
+        #   report.on_page_create do |page|
+        #     page.item(:header_title).value = 'Title'
+        #   end
+        def on_page_create(&block)
+          internal.page_create_handler = block
+        end
+
+        # @param [Integer] page_number
+        def start_page_number_from(page_number)
+          @start_page_number = page_number
+        end
+
+        # @param [String] layout filename of layout file
+        # @param [Hash] options
+        # @option options [Boolean] :default (true)
+        # @option options [Symbol] :id (nil)
+        # @example
+        #   report.use_layout '/path/to/default_layout.tlf' # Default layout
+        #   report.use_layout '/path/to/default_layout.tlf', default: true
+        #   report.use_layout '/path/to/other_layout', id: :other_layout
+        def use_layout(layout, options = {})
+          internal.register_layout(layout, options)
+        end
+
+        # @example
+        #   page = report.start_new_page
+        #
+        #   report.start_new_page do |page|
+        #     page.item(:text).value = 'value'
+        #   end
+        #
+        #   report.use_layout 'foo.tlf', default: true
+        #   report.use_layout 'bar.tlf', id: :bar
+        #
+        #   report.start_new_page                   # Use 'foo.tlf'
+        #   report.start_new_page layout: :bar      # Use 'bar.tlf'
+        #   report.start_new_page layout: 'boo.tlf' # Use 'boo.tlf'
+        # @param [Hash] options
+        # @option options [String, Symbol] :layout (nil)
+        # @option options [Boolean] :count (true)
+        # @yield [page]
+        # @yieldparam [Thinreports::BasicReport::Report::Page] page
+        # @return [Thinreports::BasicReport::Report::Page]
+        def start_new_page(options = {}, &block)
+          layout = internal.load_layout(options.delete(:layout))
+
+          raise Thinreports::BasicReport::Errors::NoRegisteredLayoutFound unless layout
+
+          page = internal.add_page(Report::Page.new(self, layout, options))
+          call_block_in(page, &block)
+        end
+
+        # @param [Hash] options
+        # @option options [Boolean] :count (true)
+        # @return [Thinreports::BasicReport::Report::BlankPage]
+        def add_blank_page(options = {})
+          internal.add_page(Report::BlankPage.new(options[:count]))
+        end
+        alias blank_page add_blank_page
+
+        # @param [Symbol, nil] id
+        # @return [Thinreports::BasicReport::Layout::Base]
+        def layout(id = nil)
+          if id
+            internal.layout_registry[id] ||
+              raise(Thinreports::BasicReport::Errors::UnknownLayoutId)
+          else
+            internal.default_layout
+          end
+        end
+
+        # @param [String] filename
+        # @param [Hash] security (see http://prawnpdf.org/api-docs/2.0/Prawn/Document/Security.html#encrypt_document-instance_method)
+        # @param [String] title Value of the title attribute of the PDF document metadata.
+        #   if nil, the title of the default layout file is set.
+        # @return [String]
+        # @example Generate PDF data
+        #   report.generate # => "%PDF-1.4...."
+        # @example Create a PDF file
+        #   report.generate(filename: 'foo.pdf')
+        def generate(filename: nil, security: nil, title: nil)
+          Thinreports::BasicReport::Generator::PDF.new(self, security: security, title: title).generate(filename)
+        end
+
+        # @see Thinreports::BasicReport::Core::Shape::Manager::Target#list
+        def list(id = nil, &block)
+          start_new_page if page.nil? || page.finalized?
+          page.list(id, &block)
+        end
+
+        def_delegators :internal, :finalize, :finalized?
+      end
+    end
+  end
+end