thinreports 0.10.2 → 0.12.1

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/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

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'section_height'
+require_relative 'draw_item'
+
+module Thinreports
+  module SectionReport
+    module Renderer
+      class StackViewRowRenderer
+        include SectionHeight
+        include DrawItem
+
+        def initialize(pdf)
+          @pdf = pdf
+        end
+
+        def render(row)
+          doc = pdf.pdf
+
+          actual_height = section_height(row)
+          doc.bounding_box([0, doc.cursor], width: doc.bounds.width, height: actual_height) do
+            row.items.each do |item|
+              draw_item(item, (actual_height - row.schema.height))
+            end
+          end
+        end
+
+        private
+
+        attr_reader :pdf
+
+        def stack_view_renderer
+          raise Thinreports::Errors::InvalidLayoutFormat, 'nested StackView does not supported'
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/schema/loader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'parser'
+
+module Thinreports
+  module SectionReport
+    module Schema
+      class Loader
+        def initialize
+          @parser = Schema::Parser.new
+        end
+
+        def load_from_file(filename)
+          data = File.read(filename, encoding: 'UTF-8')
+          load_from_data(data)
+        end
+
+        def load_from_data(data)
+          parser.parse(data)
+        end
+
+        private
+
+        attr_reader :parser
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/schema/parser.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'report'
+require_relative 'section'
+
+module Thinreports
+  module SectionReport
+    module Schema
+      class Parser
+        def parse(schema_json_data)
+          schema_data = JSON.parse(schema_json_data)
+
+          section_schema_datas = schema_data['sections'].group_by { |section| section['type'] }
+
+          Schema::Report.new(
+            schema_data,
+            headers: parse_sections(:header, section_schema_datas['header']),
+            details: parse_sections(:detail, section_schema_datas['detail']),
+            footers: parse_sections(:footer, section_schema_datas['footer'])
+          )
+        end
+
+        private
+
+        attr_reader :schema_data
+
+        def parse_sections(section_type, section_schema_datas = nil)
+          return {} if section_schema_datas.nil?
+
+          section_schema_datas.each_with_object({}) do |section_schema_data, section_schemas|
+            id = section_schema_data['id']
+            section_schemas[id.to_sym] = parse_section(section_type, section_schema_data)
+          end
+        end
+
+        def parse_section(type, section_schema_data)
+          items = section_schema_data['items'].map do |item_schema_data|
+            item_type = item_schema_data['type']
+            Core::Shape::Format(item_type).new(item_schema_data)
+          end
+          section_schema_class_for(type).new(section_schema_data, items: items)
+        end
+
+        def section_schema_class_for(section_type)
+          Schema::Section.const_get(section_type.capitalize)
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/schema/report.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module SectionReport
+    module Schema
+      class Report < 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_orientation: %w( report orientation ),
+                      page_margin: %w( report margin ),
+                      page_width: %w[report width],
+                      page_height: %w[report height]
+
+        attr_reader :headers, :details, :footers
+
+        def user_paper_type?
+          page_paper_type == 'user'
+        end
+
+        def initialize(schema_data, headers:, details:, footers:)
+          super(schema_data)
+          @headers = headers
+          @details = details
+          @footers = footers
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/section_report/schema/section.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module SectionReport
+    module Schema
+      module Section
+        class Base < Core::Shape::Manager::Format
+          config_reader :id, :type
+          config_reader :height
+          config_checker true, :display
+          config_checker true, auto_stretch: 'auto-stretch'
+
+          attr_reader :items
+
+          def initialize(schema_data, items:)
+            super(schema_data)
+            initialize_items(items)
+          end
+
+          def find_item(id)
+            @item_with_ids[id.to_sym]
+          end
+
+          private
+
+          def initialize_items(items)
+            @items = items
+            @item_with_ids = items.each_with_object({}) do |item, item_with_ids|
+              next if item.id.empty?
+              item_with_ids[item.id.to_sym] = item
+            end
+          end
+        end
+
+        class Header < Base
+          config_checker true, every_page: 'every-page'
+        end
+
+        class Footer < Base
+        end
+
+        class Detail < Base
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Thinreports
-  VERSION = '0.10.2'.freeze
+  VERSION = '0.12.1'
 end

data/lib/thinreports.rb

@@ -6,6 +6,10 @@ module Thinreports
   def self.root
     @root ||= Pathname.new(__FILE__).join('..', '..')
   end
+
+  def self.generate(report_params, filename: nil)
+    Generate.new.call(report_params, filename: filename)
+  end
 end
 
 require_relative 'thinreports/version'
@@ -18,3 +22,4 @@ require_relative 'thinreports/core/utils'
 require_relative 'thinreports/report'
 require_relative 'thinreports/layout'
 require_relative 'thinreports/generator/pdf'
+require_relative 'thinreports/generate'

data/thinreports.gemspec

@@ -14,17 +14,18 @@ Gem::Specification.new do |s|
   s.homepage    = 'http://www.thinreports.org'
   s.license     = 'MIT'
 
-  s.required_ruby_version = '>= 2.1.0'
+  s.required_ruby_version = '>= 2.5.0'
 
-  s.files = `git ls-files`.split($\)
-  s.require_path = 'lib'
+  s.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^test/}) }
+  end
+  s.require_paths = ['lib']
 
-  s.add_dependency 'prawn', '~> 2.2.0'
+  s.add_dependency 'prawn', '~> 2.2'
+  s.add_dependency 'rexml'
 
-  s.add_development_dependency 'bundler', '>= 1.0.0'
-  s.add_development_dependency 'minitest', '>= 5.0.0'
-  s.add_development_dependency 'mocha', '>= 0'
-  s.add_development_dependency 'pdf-inspector', '>= 0'
-  s.add_development_dependency 'rake', '>= 0'
-  s.add_development_dependency 'yard', '>= 0'
+  s.add_development_dependency 'minitest', '>= 5.14.1'
+  s.add_development_dependency 'mocha', '>= 1.11.2'
+  s.add_development_dependency 'pdf-inspector', '>= 1.3.0'
+  s.add_development_dependency 'rake', '>= 13.0.1'
 end