thinreports 0.12.0 → 0.13.0

data/lib/thinreports/layout/base.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Layout
-    class Base
-      EXT_NAME = 'tlf'
-      include Utils
-
-      class << self
-        # @param [String] filename
-        # @return [Thinreports::Layout::Format]
-        # @raise [Thinreports::Errors::InvalidLayoutFormat]
-        # @raise [Thinreports::Errors::IncompatibleLayoutFormat]
-        def load_format(filename)
-          filename += ".#{EXT_NAME}" unless filename =~ /\.#{EXT_NAME}$/
-
-          raise Thinreports::Errors::LayoutFileNotFound unless File.exist?(filename)
-          # Build format.
-          Thinreports::Layout::Format.build(filename)
-        end
-      end
-
-      attr_reader :format
-
-      # @return [String]
-      attr_reader :filename
-
-      # @return [Symbol]
-      attr_reader :id
-
-      # @param [String] filename
-      # @param [Hash] options
-      # @option options [Symbol] :id (nil)
-      def initialize(filename, options = {})
-        @filename = filename
-        @format = self.class.load_format(filename)
-        @id = options[:id]
-      end
-
-      # @return [Boolean] Return the true if is default layout.
-      def default?
-        @id.nil?
-      end
-    end
-  end
-end

data/lib/thinreports/layout/format.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Thinreports
-  module Layout
-    class Format < Core::Shape::Manager::Format
-      config_reader last_version: %w[version]
-      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))
-          schema_version = Layout::Version.new(schema['version'])
-
-          unless schema_version.compatible?
-            raise Errors::IncompatibleLayoutFormat.new(
-              filename, schema['version'],
-              Layout::Version.compatible_rules.join(' and ')
-            )
-          end
-
-          if schema_version.legacy?
-            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
-
-        def read_file(filename)
-          File.read(filename, encoding: 'UTF-8')
-        end
-      end
-
-      def initialize(*)
-        super
-        initialize_items(attributes['items'])
-      end
-
-      def user_paper_type?
-        page_paper_type == 'user'
-      end
-
-      private
-
-      def initialize_items(item_schemas)
-        item_schemas.each do |item_schema|
-          id, type = item_schema.values_at 'id', 'type'
-
-          next if id.empty? && type != 'page-number'
-
-          item = Core::Shape::Format(type).new(item_schema)
-          shapes[item.id.to_sym] = item
-        end
-      end
-    end
-  end
-end

data/lib/thinreports/layout/legacy_schema.rb

@@ -1,381 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'rexml/document'
-
-module Thinreports
-  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

data/lib/thinreports/layout/version.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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

data/lib/thinreports/report/base.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Report
-    class Base
-      extend  Forwardable
-      include Utils
-
-      class << self
-        # @param options (see #initialize)
-        # @option options (see #initialize)
-        # @yield [report]
-        # @yieldparam [Thinreports::Report::Base] report
-        # @return [Thinreports::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::Report::Internal]
-      attr_reader :internal
-
-      # @return [Integer]
-      attr_reader :start_page_number
-
-      # @return [Thinreports::Report::Page]
-      def_delegator :internal, :page
-
-      # @return [Integer]
-      def_delegator :internal, :page_count
-
-      # @return [Array<Thinreports::Report::Page>]
-      def_delegator :internal, :pages
-
-      # @return [Thinreports::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::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::Report::Page] page
-      # @return [Thinreports::Report::Page]
-      def start_new_page(options = {}, &block)
-        layout = internal.load_layout(options.delete(:layout))
-
-        raise Thinreports::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::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::Layout::Base]
-      def layout(id = nil)
-        if id
-          internal.layout_registry[id] ||
-            raise(Thinreports::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)
-      # @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)
-        Thinreports::Generator::PDF.new(self, security: security).generate(filename)
-      end
-
-      # @see Thinreports::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