thinreports 0.10.0 → 0.12.0

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,55 @@
+# 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
+
+          schema_row_ids = rows_schema.map {|row_schema| row_schema.id.to_sym}.to_set
+
+          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

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'section_renderer'
+
+module Thinreports
+  module SectionReport
+    module Renderer
+      class GroupRenderer
+        def initialize(pdf)
+          @pdf = pdf
+          @section_renderer = Renderer::SectionRenderer.new(pdf)
+        end
+
+        def render(report, group)
+          pdf.start_new_page_for_section_report report.schema
+          current_page_height = 0
+
+          max_page_height = pdf.max_content_height
+
+          group.headers.each do |header|
+            section_renderer.render(header)
+            current_page_height += section_renderer.section_height(header)
+          end
+
+          group.details.each do |detail|
+            if current_page_height + section_renderer.section_height(detail) > max_page_height
+              pdf.start_new_page_for_section_report report.schema
+              current_page_height = 0
+
+              group.headers.each do |header|
+                if header.schema.every_page?
+                  section_renderer.render(header)
+                  current_page_height += section_renderer.section_height(header)
+                end
+              end
+            end
+            section_renderer.render(detail)
+            current_page_height += section_renderer.section_height(detail)
+          end
+
+          group.footers.each do |footer|
+            if current_page_height + section_renderer.section_height(footer) > max_page_height
+              pdf.start_new_page_for_section_report report.schema
+              current_page_height = 0
+            end
+            section_renderer.render(footer)
+            current_page_height += section_renderer.section_height(footer)
+          end
+        end
+
+        private
+
+        attr_reader :pdf, :section_renderer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module SectionReport
+    module Renderer
+      class HeadersRenderer
+        def initialize(pdf)
+          @pdf = pdf
+          @section_renderer = Renderer::SectionRenderer.new(pdf)
+        end
+
+        def render(headers)
+          headers.each do |header|
+            section_renderer.render(header)
+          end
+        end
+
+        private
+
+        attr_reader :pdf, :section_renderer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module SectionReport
+    module Renderer
+      module SectionHeight
+        LayoutInfo = Struct.new(:shape, :content_height, :top_margin, :bottom_margin)
+
+        def section_height(section)
+          return [section.min_height || 0, section.schema.height].max if !section.schema.auto_stretch? || section.items.empty?
+
+          item_layouts = section.items.map { |item| item_layout(section, item.internal) }.compact
+
+          min_bottom_margin = item_layouts.each_with_object([]) do |l, margins|
+            margins << l.bottom_margin if l.shape.format.affect_bottom_margin?
+          end.min.to_f
+
+          max_content_bottom = item_layouts.each_with_object([]) do |l, bottoms|
+            bottoms << l.top_margin + l.content_height if l.shape.format.affect_bottom_margin?
+          end.max.to_f
+
+          [section.min_height || 0, max_content_bottom + min_bottom_margin].max
+        end
+
+        def calc_float_content_bottom(section)
+          item_layouts = section.items.map { |item| item_layout(section, item.internal) }.compact
+          item_layouts
+            .map { |l| l.top_margin + l.content_height }
+            .max.to_f
+        end
+
+        def item_layout(section, shape)
+          if shape.type_of?(Core::Shape::TextBlock::TYPE_NAME)
+            text_layout(section, shape)
+          elsif shape.type_of?(Core::Shape::StackView::TYPE_NAME)
+            stack_view_layout(section, shape)
+          elsif shape.type_of?(Core::Shape::ImageBlock::TYPE_NAME)
+            image_block_layout(section, shape)
+          elsif shape.type_of?('ellipse')
+            cy, ry = shape.format.attributes.values_at('cy', 'ry')
+            static_layout(section, shape, cy - ry, ry * 2)
+          elsif shape.type_of?('line')
+            y1, y2 = shape.format.attributes.values_at('y1', 'y2')
+            static_layout(section, shape, [y1, y2].min, (y2 - y1).abs)
+          else
+            y, height = shape.format.attributes.values_at('y', 'height')
+            raise ArgumentError.new("Unknown layout for #{shape}") if height == nil || y == nil
+            static_layout(section, shape, y, height)
+          end
+        end
+
+        def static_layout(section, shape, y, height)
+          LayoutInfo.new(shape, height, y, section.schema.height - height - y)
+        end
+
+        def image_block_layout(section, shape)
+          y, height = shape.format.attributes.values_at('y', 'height')
+          if shape.style.finalized_styles['position-y'] == 'top'
+            dimensions = pdf.shape_iblock_dimenions(shape)
+            content_height = dimensions ? dimensions[1] : 0
+
+            LayoutInfo.new(shape, content_height, y, section.schema.height - height - y)
+          else
+            static_layout(section, shape, y, height)
+          end
+        end
+
+        def calc_text_block_height(shape)
+          height = 0
+
+          pdf.draw_shape_tblock(shape) do |array, options|
+            modified_options = options.merge(at: [0, 10_000], height: 10_000)
+            height = pdf.pdf.height_of_formatted(array, modified_options)
+          end
+          height
+        end
+
+        def text_layout(section, shape)
+          y, schema_height = shape.format.attributes.values_at('y', 'height')
+
+          content_height = if shape.style.finalized_styles['overflow'] == 'expand'
+            [schema_height, calc_text_block_height(shape)].max
+          else
+            schema_height
+          end
+
+          LayoutInfo.new(shape, content_height, y, section.schema.height - schema_height - y)
+        end
+
+        def stack_view_layout(section, shape)
+          schema_height = 0
+          shape.format.rows.each {|row| schema_height += row.attributes['height']}
+
+          y = shape.format.attributes['y']
+          LayoutInfo.new(shape, stack_view_renderer.section_height(shape), y, section.schema.height - schema_height - y)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'stack_view_renderer'
+require_relative 'section_height'
+require_relative 'draw_item'
+
+module Thinreports
+  module SectionReport
+    module Renderer
+      class SectionRenderer
+        include SectionHeight
+        include DrawItem
+
+        def initialize(pdf)
+          @pdf = pdf
+        end
+
+        def render(section)
+          doc = pdf.pdf
+
+          actual_height = section_height(section)
+          doc.bounding_box([0, doc.cursor], width: doc.bounds.width, height: actual_height) do
+            section.items.each do |item|
+              draw_item(item, (actual_height - section.schema.height))
+            end
+          end
+        end
+
+        private
+
+        attr_reader :pdf
+
+        def stack_view_renderer
+          @stack_view_renderer ||= Renderer::StackViewRenderer.new(pdf)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'stack_view_row_renderer'
+
+module Thinreports
+  module SectionReport
+    module Renderer
+      class StackViewRenderer
+        def initialize(pdf)
+          @pdf = pdf
+          @row_renderer = Renderer::StackViewRowRenderer.new(pdf)
+        end
+
+        RowLayout = Struct.new(:row, :height, :top)
+
+        def section_height(shape)
+          row_layouts = build_row_layouts(shape.rows)
+
+          total_row_height = row_layouts.sum(0, &:height)
+          float_content_bottom = row_layouts
+            .map { |l| row_renderer.calc_float_content_bottom(l.row) + l.top }
+            .max.to_f
+
+          [total_row_height, float_content_bottom].max
+        end
+
+        def render(shape)
+          doc = pdf.pdf
+
+          x, y, w = shape.format.attributes.values_at('x', 'y', 'width')
+          doc.bounding_box([x, doc.bounds.height - y], width: w, height: section_height(shape)) do
+            shape.rows.each do |row|
+              row_renderer.render(row)
+            end
+          end
+        end
+
+        private
+
+        attr_reader :pdf, :row_renderer
+
+        def build_row_layouts(rows)
+          row_layouts = rows.map { |row| RowLayout.new(row, row_renderer.section_height(row)) }
+
+          row_layouts.inject(0) do |top, row_layout|
+            row_layout.top = top
+            top + row_layout.height
+          end
+
+          row_layouts
+        end
+      end
+    end
+  end
+end