thinreports 0.11.0 → 0.12.0

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,22 +4,13 @@ module Thinreports
   module Generator
     module PrawnExt
       module WidthOf
-        # TODO: Remove this path when a version of prawn that includes the following PR is released:
-        # https://github.com/prawnpdf/prawn/pull/1117
+        # This patch fixes the character_spacing effect on text width calculation.
         #
-        # This PR makes this patch unnecessary.
-        #
-        #
-        # Subtract the width of one character space from the string width calculation result.
-        #
-        # 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
         #
@@ -32,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/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,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