thinreports 0.10.2 → 0.12.1

data/lib/thinreports/core/shape.rb

@@ -18,6 +18,7 @@ module Thinreports
         when TextBlock::TYPE_NAME  then TextBlock
         when ImageBlock::TYPE_NAME then ImageBlock
         when List::TYPE_NAME       then List
+        when StackView::TYPE_NAME  then StackView
         when Text::TYPE_NAME       then Text
         when PageNumber::TYPE_NAME then PageNumber
         when *Basic::TYPE_NAMES    then Basic
@@ -37,4 +38,5 @@ require_relative 'shape/text'
 require_relative 'shape/text_block'
 require_relative 'shape/image_block'
 require_relative 'shape/list'
+require_relative 'shape/stack_view'
 require_relative 'shape/page_number'

data/lib/thinreports/generate.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'section_report/generate'
+
+module Thinreports
+  class Generate
+    def call(report_params, filename: nil)
+      SectionReport::Generate.new.call(report_params, filename: filename)
+    end
+  end
+end

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

@@ -5,20 +5,26 @@ module Thinreports
     class PDF
       module DrawShape
         # @param [Thinreports::Core::Shape::TextBlock::Internal] shape
-        def draw_shape_tblock(shape)
-          x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+        # @param [Numeric] height (nil) It will be used as rendering height if present.
+        #   Otherwise, the rendering height is the height of schema.
+        # @param [:truncate, :shrink_to_fit, :expand] overflow (nil) It will be set the overflow attribute if present.
+        def draw_shape_tblock(shape, height: nil, overflow: nil, &block)
+          x, y, w = shape.format.attributes.values_at('x', 'y', 'width')
+
+          h = height || shape.format.attributes['height']
 
           content = shape.real_value.to_s
           return if content.empty?
 
           attrs = build_text_attributes(shape.style.finalized_styles)
+          attrs[:overflow] = overflow if overflow
 
           unless shape.multiple?
             content = content.tr("\n", ' ')
             attrs[:single] = true
           end
 
-          text_box(content, x, y, w, h, attrs)
+          text_box(content, x, y, w, h, attrs, &block)
         end
 
         def draw_shape_pageno(shape, page_no, page_count)
@@ -44,6 +50,21 @@ module Thinreports
           style = shape.style.finalized_styles
 
           image_box(
+            shape.src, x, y, w, h,
+            position_x: image_position_x(style['position-x']),
+            position_y: image_position_y(style['position-y']),
+            offset_x: style['offset-x'],
+            offset_y: style['offset-y']
+          )
+        end
+
+        def shape_iblock_dimenions(shape)
+          return nil if blank_value?(shape.src)
+
+          x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+          style = shape.style.finalized_styles
+
+          image_dimensions(
             shape.src, x, y, w, h,
             position_x: image_position_x(style['position-x']),
             position_y: image_position_y(style['position-y'])
@@ -51,10 +72,10 @@ module Thinreports
         end
 
         # @param [Thinreports::Core::Shape::Text::Internal] shape
-        def draw_shape_text(shape)
+        def draw_shape_text(shape, dheight = 0)
           x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
           text(
-            shape.texts.join("\n"), x, y, w, h,
+            shape.texts.join("\n"), x, y, w, h + dheight,
             build_text_attributes(shape.style.finalized_styles)
           )
         end
@@ -66,18 +87,18 @@ module Thinreports
         end
 
         # @param [Thinreports::Core::Shape::Basic::Internal] shape
-        def draw_shape_line(shape)
+        def draw_shape_line(shape, dy1 = 0, dy2 = 0)
           x1, y1, x2, y2 = shape.format.attributes.values_at('x1', 'y1', 'x2', 'y2')
-          line(x1, y1, x2, y2, build_graphic_attributes(shape.style.finalized_styles))
+          line(x1, y1 + dy1, x2, y2 + dy2, build_graphic_attributes(shape.style.finalized_styles))
         end
 
         # @param [Thinreports::Core::Shape::Basic::Internal] shape
-        def draw_shape_rect(shape)
+        def draw_shape_rect(shape, dheight = 0)
           x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
           rect_attributes = build_graphic_attributes(shape.style.finalized_styles) do |attrs|
-            attrs[:radius] = shape.format.attributes['rx']
+            attrs[:radius] = shape.format.attributes['border-radius']
           end
-          rect(x, y, w, h, rect_attributes)
+          rect(x, y, w, h + dheight, rect_attributes)
         end
       end
     end

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

@@ -25,7 +25,7 @@ module Thinreports
         def draw_rect(item_attributes)
           x, y, w, h = item_attributes.values_at('x', 'y', 'width', 'height')
           graphic_attributes = build_graphic_attributes(item_attributes['style']) do |attrs|
-            attrs[:radius] = item_attributes['rx']
+            attrs[:radius] = item_attributes['border-radius']
           end
 
           rect(x, y, w, h, graphic_attributes)

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

@@ -39,9 +39,16 @@ module Thinreports
         # @param [Hash] options
         # @option options [:left, :center, :right] :position_x (:left)
         # @option options [:top, :center, :bottom] :position_y (:top)
+        # @option options [Numeric] :offset_x
+        # @option options [Numeric] :offset_y
         def image_box(filename_or_io, x, y, w, h, options = {})
           w, h = s2f(w, h)
-          pdf.bounding_box(pos(x, y), width: w, height: h) do
+
+          computed_position = pos(
+            x + (options[:offset_x] || 0),
+            y + (options[:offset_y] || 0)
+          )
+          pdf.bounding_box(computed_position, width: w, height: h) do
             pdf.image(
               filename_or_io,
               position: options[:position_x] || :left,
@@ -51,6 +58,17 @@ module Thinreports
           end
         end
 
+        def image_dimensions(filename_or_io, x, y, w, h, options = {})
+          w, h = s2f(w, h)
+          # XXX: Calling @private method
+          _pdf_obj, info = pdf.build_image_object(filename_or_io)
+          info.calc_image_dimensions(
+            position: options[:position_x] || :left,
+            vposition: options[:position_y] || :top,
+            auto_fit: [w, h]
+          )
+        end
+
         def clean_temp_images
           temp_image_registry.each_value do |image_path|
             File.delete(image_path) if File.exist?(image_path)

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

@@ -22,7 +22,7 @@ module Thinreports
         # @option attrs [Boolean] :single (false)
         # @option attrs [:trancate, :shrink_to_fit, :expand] :overflow (:trancate)
         # @option attrs [:none, :break_word] :word_wrap (:none)
-        def text_box(content, x, y, w, h, attrs = {})
+        def text_box(content, x, y, w, h, attrs = {}, &block)
           w, h = s2f(w, h)
 
           box_attrs = text_box_attrs(
@@ -35,10 +35,15 @@ module Thinreports
           content = text_without_line_wrap(content) if attrs[:word_wrap] == :none
 
           with_text_styles(attrs) do |built_attrs, font_styles|
-            pdf.formatted_text_box(
-              [{ text: content, styles: font_styles }],
-              built_attrs.merge(box_attrs)
-            )
+            if block
+              block.call [{ text: content, styles: font_styles }],
+                built_attrs.merge(box_attrs)
+            else
+              pdf.formatted_text_box(
+                [{ text: content, styles: font_styles }],
+                built_attrs.merge(box_attrs)
+              )
+            end
           end
         rescue Prawn::Errors::CannotFit
           # Nothing to do.

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

@@ -26,6 +26,18 @@ module Thinreports
           stamp(format_id.to_s)
         end
 
+        def start_new_page_for_section_report(format)
+          @current_page_format = format
+          pdf.start_new_page(new_basic_page_options(current_page_format).merge(
+            top_margin: current_page_format.page_margin[0],
+            bottom_margin: current_page_format.page_margin[2]
+          ))
+        end
+
+        def max_content_height
+          pdf.margin_box.height
+        end
+
         def add_blank_page
           pdf.start_new_page(pdf.page_count.zero? ? { size: 'A4' } : {})
         end

data/lib/thinreports/generator/pdf/prawn_ext/width_of.rb

@@ -4,16 +4,13 @@ module Thinreports
   module Generator
     module PrawnExt
       module WidthOf
-        # Subtract the width of one character space from the string width calculation result.
+        # This patch fixes the character_spacing effect on text width calculation.
         #
-        # The original Prawn::Document#width_of returns the following result:
-        #
-        #  Width of Character is 1
-        #  Width of Character Space is 1
+        # The original #width_of:
         #
         #   width_of('abcd') #=> 4 + 4 = 8
         #
-        # In this width_of, returns the following result:
+        # The #width_of in this patch:
         #
         #   width_of('abcd') #=> 4 + 3 = 7
         #
@@ -26,4 +23,7 @@ module Thinreports
   end
 end
 
-Prawn::Document.prepend Thinreports::Generator::PrawnExt::WidthOf
+# Prawn v2.3 and later includes this patch by https://github.com/prawnpdf/prawn/pull/1117.
+if Prawn::VERSION < '2.3.0'
+  Prawn::Document.prepend Thinreports::Generator::PrawnExt::WidthOf
+end

data/lib/thinreports/layout/base.rb

@@ -3,7 +3,7 @@
 module Thinreports
   module Layout
     class Base
-      EXT_NAME = 'tlf'.freeze
+      EXT_NAME = 'tlf'
       include Utils
 
       class << self

data/lib/thinreports/layout/legacy_schema.rb

@@ -104,6 +104,7 @@ module Thinreports
           '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'],

data/lib/thinreports/layout/version.rb

@@ -4,7 +4,7 @@ module Thinreports
   module Layout
     class Version
       COMPATIBLE_RULES = ['>= 0.8.0', '< 1.0.0'].freeze
-      NEW_SCHEMA_FROM = '0.9.0'.freeze
+      NEW_SCHEMA_FROM = '0.9.0'
 
       class << self
         def compatible_rules

data/lib/thinreports/report/internal.rb

@@ -96,6 +96,8 @@ module Thinreports
       end
 
       def init_layout(filename, id = nil)
+        filename = filename.to_path if filename.is_a?(Pathname)
+
         Thinreports::Layout.new(filename, id: id)
       end
     end

data/lib/thinreports/report.rb

@@ -13,8 +13,8 @@ module Thinreports
     end
 
     # @see Thinreports::Report::Base#generate
-    def self.generate(*args, &block)
-      Base.generate(*args, &block)
+    def self.generate(**args, &block)
+      Base.generate(**args, &block)
     end
   end
 end

data/lib/thinreports/section_report/build.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'schema/loader'
+require_relative 'builder/report_builder'
+
+module Thinreports
+  module SectionReport
+    class Build
+      def call(report_params)
+        schema = load_schema(report_params)
+        params = report_params[:params] || {}
+
+        Builder::ReportBuilder.new(schema).build(params)
+      end
+
+      private
+
+      def load_schema(report_params)
+        loader = Schema::Loader.new
+
+        case
+        when report_params[:layout_file]
+          loader.load_from_file(report_params[:layout_file])
+        when report_params[:layout_data]
+          loader.load_from_data(report_params[:layout_data])
+        else
+          raise Errors::LayoutFileNotFound
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/builder/item_builder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'stack_view_builder'
+
+module Thinreports
+  module SectionReport
+    module Builder
+      class ItemBuilder
+        Context = Struct.new(:parent_schema)
+
+        def initialize(item_schema, parent_schema)
+          @item = Core::Shape::Interface(nil, item_schema)
+          @parent_schema = parent_schema
+        end
+
+        def build(item_params)
+          params = build_params(item_params)
+
+          item.visible(params[:display]) if params.key?(:display)
+          item.value(params[:value]) if params.key?(:value)
+          item.styles(params[:styles]) if params.key?(:styles)
+
+          if item.internal.format.attributes['type'] == Core::Shape::StackView::TYPE_NAME
+            StackViewBuilder.new(item).update(params)
+          end
+
+          item
+        end
+
+        private
+
+        attr_reader :item, :parent_schema
+
+        def build_params(params)
+          return {} unless params
+
+          case params
+          when Hash
+            params
+          when Proc
+            params.call(Context.new(parent_schema))
+          else
+            { value: params }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/builder/report_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'report_data'
+require_relative 'item_builder'
+
+module Thinreports
+  module SectionReport
+    module Builder
+      class ReportBuilder
+        def initialize(schema)
+          @schema = schema
+        end
+
+        def build(params)
+          ReportData::Main.new(
+            schema,
+            build_groups(params[:groups])
+          )
+        end
+
+        private
+
+        attr_reader :schema
+
+        def build_groups(groups_params)
+          return [] unless groups_params
+
+          groups_params.map do |group_params|
+            ReportData::Group.new(
+              build_sections(:header, group_params[:headers] || {}),
+              build_detail_sections(group_params[:details] || []),
+              build_sections(:footer, group_params[:footers] || {})
+            )
+          end
+        end
+
+        def build_sections(section_type, sections_params)
+          sections_schemas =
+            case section_type
+            when :header then schema.headers
+            when :footer then schema.footers
+            end
+
+          sections_schemas.each_with_object([]) do |(section_id, section_schema), sections|
+            section_params = sections_params[section_id.to_sym] || {}
+            next unless section_enabled?(section_schema, section_params)
+
+            items = build_items(section_schema, section_params[:items] || {})
+            sections << ReportData::Section.new(section_schema, items, section_params[:min_height])
+          end
+        end
+
+        def build_detail_sections(details_params)
+          details_params.each_with_object([]) do |detail_params, details|
+            detail_id = detail_params[:id].to_sym
+            detail_schema = schema.details[detail_id]
+
+            next unless detail_schema
+
+            items = build_items(detail_schema, detail_params[:items] || {})
+            details << ReportData::Section.new(detail_schema, items, detail_params[:min_height])
+          end
+        end
+
+        def build_items(section_schema, items_params)
+          section_schema.items.each_with_object([]) do |item_schema, items|
+            item = ItemBuilder.new(item_schema, section_schema).build(items_params[item_schema.id&.to_sym])
+            items << item if item.visible?
+          end
+        end
+
+        def section_enabled?(section_schema, section_params)
+          if section_params.key?(:display)
+            section_params[:display]
+          else
+            section_schema.display?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/builder/report_data.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module SectionReport
+    module Builder
+      module ReportData
+        Main = Struct.new :schema, :groups
+        Group = Struct.new :headers, :details, :footers
+        Section = Struct.new :schema, :items, :min_height
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/builder/stack_view_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'stack_view_data'
+
+module Thinreports
+  module SectionReport
+    module Builder
+      class StackViewBuilder
+        def initialize(item)
+          @item = item
+        end
+
+        def update(params)
+          rows_params = params[:rows] || {}
+          rows_schema = item.internal.format.rows
+
+          rows = []
+          rows_schema.each do |row_schema|
+            row_params = rows_params[row_schema.id.to_sym] || {}
+            next unless row_enabled?(row_schema, row_params)
+
+            items = build_row_items(
+              row_schema,
+              row_params[:items] || {}
+            )
+
+            rows << StackViewData::Row.new(row_schema, items, row_params[:min_height])
+          end
+          item.internal.rows = rows
+        end
+
+        private
+
+        attr_reader :item
+
+        def build_row_items(row_schema, items_params)
+          row_schema.items.each_with_object([]) do |item_schema, items|
+            item = ItemBuilder.new(item_schema, row_schema).build(items_params[item_schema.id&.to_sym])
+            items << item if item.visible?
+          end
+        end
+
+        def row_enabled?(row_schema, row_params)
+          if row_params.key?(:display)
+            row_params[:display]
+          else
+            row_schema.display?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/builder/stack_view_data.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module SectionReport
+    module Builder
+      module StackViewData
+        Row = Struct.new :schema, :items, :min_height
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/generate.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'build'
+require_relative 'pdf/render'
+
+module Thinreports
+  module SectionReport
+    class Generate
+      def initialize
+        @pdf = Thinreports::Generator::PDF::Document.new
+      end
+
+      def call(report_params, filename: nil)
+        report = Build.new.call(report_params)
+
+        PDF::Render.new(pdf).call!(report)
+
+        filename ? pdf.render_file(filename) : pdf.render
+      end
+
+      private
+
+      attr_reader :pdf
+    end
+  end
+end

data/lib/thinreports/section_report/pdf/render.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'renderer/group_renderer'
+
+module Thinreports
+  module SectionReport
+    module PDF
+      class Render
+        def initialize(pdf)
+          @group_renderer = Renderer::GroupRenderer.new(pdf)
+        end
+
+        def call!(report)
+          report.groups.each { |group| group_renderer.render(report, group) }
+        end
+
+        private
+
+        attr_reader :group_renderer
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/pdf/renderer/draw_item.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module SectionReport
+    module Renderer
+      module DrawItem
+        def draw_item(item, expanded_height = 0)
+          shape = item.internal
+
+          if shape.type_of?(Core::Shape::TextBlock::TYPE_NAME)
+            computed_height = shape.format.attributes['height']
+            computed_height += expanded_height if shape.format.follow_stretch == 'height'
+
+            if shape.style.finalized_styles['overflow'] == 'expand'
+              # When overflow is "expand", the value of the height argument is ignored and the shape is expanded to
+              # the bottom of the outer bounding box.
+              # That causes a position shift problem if vertical-align is "middle" or "bottom".
+              # To solve it, we overwrite the overflow to "truncate" when drawing.
+              # To emulate the "expand" behavior in the "truncate" mode,
+              # here we pass the greater value of the computed_height and the text height as text block height.
+              pdf.draw_shape_tblock(shape, height: [computed_height, calc_text_block_height(shape)].max, overflow: :truncate)
+            else
+              pdf.draw_shape_tblock(shape, height: computed_height)
+            end
+          elsif shape.type_of?(Core::Shape::ImageBlock::TYPE_NAME)
+            pdf.draw_shape_iblock(shape)
+          elsif shape.type_of?('text')
+            case shape.format.follow_stretch
+            when 'height'
+              pdf.draw_shape_text(shape, expanded_height)
+            else
+              pdf.draw_shape_text(shape)
+            end
+          elsif shape.type_of?('image')
+            pdf.draw_shape_image(shape)
+          elsif shape.type_of?('ellipse')
+            pdf.draw_shape_ellipse(shape)
+          elsif shape.type_of?('rect')
+            case shape.format.follow_stretch
+            when 'height'
+              pdf.draw_shape_rect(shape, expanded_height)
+            else
+              pdf.draw_shape_rect(shape)
+            end
+          elsif shape.type_of?('line')
+            case shape.format.follow_stretch
+            when 'height'
+              y1, y2 = shape.format.attributes.values_at('y1', 'y2')
+              if y1 < y2
+                pdf.draw_shape_line(shape, 0, expanded_height)
+              else
+                pdf.draw_shape_line(shape, expanded_height, 0)
+              end
+            when 'y'
+              pdf.draw_shape_line(shape, expanded_height, expanded_height)
+            else
+              pdf.draw_shape_line(shape)
+            end
+          elsif shape.type_of?(Core::Shape::StackView::TYPE_NAME)
+            stack_view_renderer.render(shape)
+          else
+            raise Thinreports::Errors::UnknownShapeType
+          end
+        end
+      end
+    end
+  end
+end