thinreports 0.12.1 → 0.13.0

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative 'document/font'
+require_relative 'document/parse_color'
+require_relative 'document/graphics'
+require_relative 'document/draw_shape'
+require_relative 'document/draw_template_items'
+require_relative 'document/page'
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        class Document
+          include Utils
+
+          include PDF::Font
+          include PDF::ParseColor
+          include PDF::Graphics
+          include PDF::DrawShape
+          include PDF::DrawTemplateItems
+          include PDF::Page
+
+          # @return [Prawn::Document]
+          attr_reader :pdf
+
+          # @param [String] title (nil)
+          # @param [Hash] security (nil)
+          def initialize(title: nil, security: nil)
+            @pdf = Prawn::Document.new(
+              skip_page_creation: true,
+              margin: [0, 0],
+              info: {
+                CreationDate: Time.now,
+                Creator: 'Thinreports Generator for Ruby ' + Thinreports::VERSION,
+                Title: title
+              }
+            )
+            # Setup to Prawn::Document.
+            setup_fonts
+            setup_custom_graphic_states
+
+            # Encrypts the document.
+            @pdf.encrypt_document(security) if security
+          end
+
+          # Delegate to Prawn::Document#render
+          # @see Prawn::Document#render
+          def render
+            result = pdf.render
+            finalize
+            result
+          end
+
+          # Delegate to Prawn::Document#render_file
+          # @see Prawn::Document#render_file
+          def render_file(*args)
+            finalize
+            pdf.render_file(*args)
+          end
+
+          # @param [Numeric, String] x
+          # @param [Numeric, String] y
+          def translate(x, y, &block)
+            x, y = rpos(x, y)
+            pdf.translate(x, y, &block)
+          end
+
+          # @param [String] stamp_id
+          # @param [Array<Numeric>] at (nil)
+          def stamp(stamp_id, at = nil)
+            if at.nil?
+              pdf.stamp(stamp_id)
+            else
+              pdf.stamp_at(stamp_id, rpos(*at))
+            end
+          end
+
+          # Delegate to Prawn::Document#create_stamp
+          # @param [String] id
+          # @see Prawn::Document#create_stamp
+          def create_stamp(id, &block)
+            pdf.create_stamp(id, &block)
+          end
+
+          # @see #pdf
+          def internal
+            @pdf
+          end
+
+          private
+
+          def finalize
+            clean_temp_images
+          end
+
+          # @param [Array<String, Numeric>] values
+          # @return [Numeric, Array<Numeric>, nil]
+          def s2f(*values)
+            return nil if values.empty?
+
+            if values.size == 1
+              value = values.first
+              return nil unless value
+              value.is_a?(::Numeric) ? value : value.to_f
+            else
+              values.map { |v| s2f(v) }
+            end
+          end
+
+          # @param [Numeric, String] x
+          # @param [Numeric, String] y
+          # @return [Array<Float>]
+          def map_to_upper_left_relative_position(x, y)
+            x, y = s2f(x, y)
+            [x, -y]
+          end
+          alias rpos map_to_upper_left_relative_position
+
+          # @param [Numeric, String] x
+          # @param [Numeric, String] y
+          # @return [Array<Float>]
+          def map_to_upper_left_position(x, y)
+            x, y = s2f(x, y)
+            [x, pdf.bounds.height - y]
+          end
+          alias pos map_to_upper_left_position
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/generator/pdf/drawer/base.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Drawer
+          # @abstract
+          class Base
+            # @param [Thinreports::BasicReport::Generator::PDF::Document] pdf
+            # @param [Thinreports::BasicReport::Core::Shape::Manager::Format] format
+            def initialize(pdf, format)
+              @pdf = pdf
+              @format = format
+              @stamps = []
+              @draw_at = nil
+            end
+
+            # @abstract
+            def draw
+              raise NotImplementedError
+            end
+
+            private
+
+            # @param [Thinreports::BasicReport::Core::Shape::Base::Internal] shape
+            # @return [String]
+            def pdf_stamp_id(shape)
+              "#{@format.identifier}#{shape.identifier}"
+            end
+
+            # @overload pdf_stamp(shape_id)
+            #   @param [String] shape_id
+            # @overload pdf_stamp(shape)
+            #   @param [Thinreports::BasicReport::Core::Shape::Base::Internal] shape
+            def pdf_stamp(shape)
+              shape = pdf_stamp_id(shape) unless shape.is_a?(::String)
+              @pdf.stamp(shape, @draw_at)
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::Base::Internal] shape
+            def create_pdf_stamp(shape, &block)
+              @pdf.create_stamp(pdf_stamp_id(shape), &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/generator/pdf/drawer/list.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Drawer
+          class List < Base
+            # @param (see PDF::Drawer::Base#initialize)
+            def initialize(pdf, format)
+              super
+              @sections = {}
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::PageState] list_page
+            def draw(list_page)
+              draw_section(list_page.header) if list_page.header
+              list_page.rows.each do |row|
+                draw_section(row)
+              end
+
+              # Returns Thinreports::BasicReport::Report::Page object
+              manager = list_page.parent.manager
+
+              list_id = list_page.id.to_s
+              manager.format.shapes.each do |id, shape|
+                next unless list_pageno?(list_id, shape)
+
+                shape = manager.final_shape(id)
+                @pdf.draw_shape_pageno(shape.internal,
+                                       list_page.no, list_page.manager.page_count)
+              end
+            end
+
+            private
+
+            # @param [String] list_id
+            # @param [Thinreports::BasicReport::Core::Shape::Base::Format] shape
+            # @return [Boolean]
+            def list_pageno?(list_id, shape)
+              shape.type == Thinreports::BasicReport::Core::Shape::PageNumber::TYPE_NAME &&
+                shape.target == list_id
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::SectionInterface] section
+            def draw_section(section)
+              internal = section.internal
+
+              base_top = @format.section_base_position_top(internal.section_name)
+              position = [internal.relative_left, base_top + internal.relative_top]
+
+              drawer(internal).draw(section, position)
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::SectionInternal] section
+            # @return [Thinreports::BasicReport::Generator::PDF::Drawer::ListSection]
+            def drawer(section)
+              @sections[section.section_name] ||= ListSection.new(@pdf, section)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/generator/pdf/drawer/list_section.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Drawer
+          class ListSection < Page
+            # @param pdf (see PDF::Drawer::Page#initialize)
+            # @param section [Thinreports::BasicReport::Core::Shape::List::SectionInternal] section
+            def initialize(pdf, section)
+              super(pdf, section.format)
+              @section = section
+              @stamp_created = false
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::List::SectionInternal] section
+            # @param [Array<Numeric>] at
+            def draw(section, at)
+              @draw_at = at
+              draw_section
+              super(section)
+            end
+
+            private
+
+            def draw_section
+              id = @format.identifier.to_s
+
+              unless @stamp_created
+                @pdf.create_stamp(id) { @pdf.draw_template_items(@format.attributes['items']) }
+                @stamp_created = true
+              end
+              pdf_stamp(id)
+            end
+
+            # @see Thinreports::BasicReport::Generator::PDF::Drawer::Page#draw_tblock_shape
+            def draw_tblock_shape(shape)
+              @pdf.translate(*@draw_at) { super }
+            end
+
+            # @see Thinreports::BasicReport::Generator::PDF::Drawer::Page#draw_iblock_shape
+            def draw_iblock_shape(shape)
+              @pdf.translate(*@draw_at) { super }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/generator/pdf/drawer/page.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Drawer
+          class Page < Base
+            # @param (see PDF::Drawer::Base#initialize)
+            def initialize(pdf, format)
+              super
+              @lists = {}
+            end
+
+            # @param [Thinreports::BasicReport::Report::Page] page
+            def draw(page)
+              manager = page.manager
+
+              manager.format.shapes.each_key do |id|
+                shape = manager.final_shape(id)
+                next unless shape
+
+                shape = shape.internal
+
+                if shape.type_of?(Core::Shape::PageNumber::TYPE_NAME)
+                  # Do not draw pageno if is not for Report
+                  draw_pageno_shape(shape, page) if page.count? && shape.for_report?
+                else
+                  draw_shape(shape)
+                end
+              end
+            end
+
+            private
+
+            def draw_shape(shape)
+              if shape.type_of?(Core::Shape::TextBlock::TYPE_NAME)
+                draw_tblock_shape(shape)
+              elsif shape.type_of?(Core::Shape::List::TYPE_NAME)
+                draw_list_shape(shape)
+              elsif shape.type_of?(Core::Shape::ImageBlock::TYPE_NAME)
+                draw_iblock_shape(shape)
+              else
+                id = shape.identifier
+                unless @stamps.include?(id)
+                  create_basic_shape_stamp(shape)
+                  @stamps << id
+                end
+                pdf_stamp(shape)
+              end
+            end
+
+            def draw_pageno_shape(shape, page)
+              @pdf.draw_shape_pageno(shape, page.no, page.report.page_count)
+            end
+
+            # @see #draw_shape
+            def draw_list_shape(shape)
+              drawer = @lists[shape.id] ||= List.new(@pdf, shape.format)
+              drawer.draw(shape)
+            end
+
+            # @see #draw_shape
+            def draw_tblock_shape(shape)
+              @pdf.draw_shape_tblock(shape)
+            end
+
+            # @see #draw_shape
+            def draw_iblock_shape(shape)
+              @pdf.draw_shape_iblock(shape)
+            end
+
+            # @param [Thinreports::BasicReport::Core::Shape::Base::Internal] shape
+            def create_basic_shape_stamp(shape)
+              if shape.type_of?('text')
+                create_text_stamp(shape)
+              elsif shape.type_of?('image')
+                create_image_stamp(shape)
+              elsif shape.type_of?('ellipse')
+                create_ellipse_stamp(shape)
+              elsif shape.type_of?('rect')
+                create_rect_stamp(shape)
+              elsif shape.type_of?('line')
+                create_line_stamp(shape)
+              end
+            end
+
+            # @see #create_basic_shape_stamp
+            def create_image_stamp(shape)
+              create_pdf_stamp(shape) do
+                @pdf.draw_shape_image(shape)
+              end
+            end
+
+            # @see #create_basic_shape_stamp
+            def create_rect_stamp(shape)
+              create_pdf_stamp(shape) do
+                @pdf.draw_shape_rect(shape)
+              end
+            end
+
+            # @see #create_basic_shape_stamp
+            def create_ellipse_stamp(shape)
+              create_pdf_stamp(shape) do
+                @pdf.draw_shape_ellipse(shape)
+              end
+            end
+
+            # @see #create_basic_shape_stamp
+            def create_line_stamp(shape)
+              create_pdf_stamp(shape) do
+                @pdf.draw_shape_line(shape)
+              end
+            end
+
+            # @see #create_basic_shape_stamp
+            def create_text_stamp(shape)
+              create_pdf_stamp(shape) do
+                @pdf.draw_shape_text(shape)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinreports/basic_report/generator/pdf/prawn_ext/calc_image_dimensions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      module PrawnExt
+        module CalcImageDimensions
+          # Implement :auto_fit option for image size calculation.
+          #
+          # When the image is larger than the box, the original: fit option does not change
+          # the image size. The :auto_fit option changes the image size to fit in the box
+          # while maintaining the aspect ratio.
+          #
+          # Usage:
+          #   image '/path/to/image.png', at: [100, 100], auto_fit: [100, 100]
+          #
+          def calc_image_dimensions(options)
+            if options[:auto_fit]
+              image_width = options[:width] || width
+              image_height = options[:height] || height
+
+              box_width, box_height = options.delete(:auto_fit)
+
+              options[:fit] = [box_width, box_height] if image_width > box_width || image_height > box_height
+            end
+            super(options)
+          end
+        end
+      end
+    end
+  end
+end
+
+Prawn::Images::Image.prepend Thinreports::BasicReport::Generator::PrawnExt::CalcImageDimensions

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      module PrawnExt
+        module WidthOf
+          # This patch fixes the character_spacing effect on text width calculation.
+          #
+          # The original #width_of:
+          #
+          #   width_of('abcd') #=> 4 + 4 = 8
+          #
+          # The #width_of in this patch:
+          #
+          #   width_of('abcd') #=> 4 + 3 = 7
+          #
+          def width_of(*)
+            width = super - character_spacing
+            width > 0 ? width : 0
+          end
+        end
+      end
+    end
+  end
+end
+
+# 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::BasicReport::Generator::PrawnExt::WidthOf
+end

data/lib/thinreports/basic_report/generator/pdf.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'prawn'
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        # @return [Thinreports::BasicReport::Report::Base]
+        attr_reader :report
+
+        # @param [Thinreports::BasicReport::Report::Base] report
+        # @param [Hash] security (nil)
+        # @param [String] title (nil)
+        def initialize(report, security: nil, title: nil)
+          report.finalize
+
+          @report = report.internal
+          title ||= default_layout ? default_layout.format.report_title : nil
+
+          @document = Document.new(title: title, security: security)
+          @drawers = {}
+        end
+
+        # @param [String, nil] filename
+        # @return [String, nil]
+        def generate(filename = nil)
+          draw_report
+          filename ? @document.render_file(filename) : @document.render
+        end
+
+        def default_layout
+          report.default_layout
+        end
+
+        private
+
+        def draw_report
+          report.pages.each do |page|
+            draw_page(page)
+          end
+        end
+
+        def draw_page(page)
+          return @document.add_blank_page if page.blank?
+
+          format = page.layout.format
+          @document.start_new_page(format)
+
+          drawer(format).draw(page)
+        end
+
+        def drawer(format)
+          @drawers[format.identifier] ||= Drawer::Page.new(@document, format)
+        end
+      end
+    end
+  end
+end
+
+require_relative 'pdf/prawn_ext'
+require_relative 'pdf/document'
+require_relative 'pdf/drawer/base'
+require_relative 'pdf/drawer/page'
+require_relative 'pdf/drawer/list'
+require_relative 'pdf/drawer/list_section'

data/lib/thinreports/basic_report/layout/base.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Layout
+      class Base
+        EXT_NAME = 'tlf'
+        include Utils
+
+        class << self
+          # @param [String] filename
+          # @return [Thinreports::BasicReport::Layout::Format]
+          # @raise [Thinreports::BasicReport::Errors::InvalidLayoutFormat]
+          # @raise [Thinreports::BasicReport::Errors::IncompatibleLayoutFormat]
+          def load_format(filename)
+            filename += ".#{EXT_NAME}" unless filename =~ /\.#{EXT_NAME}$/
+
+            raise Thinreports::BasicReport::Errors::LayoutFileNotFound unless File.exist?(filename)
+            # Build format.
+            Thinreports::BasicReport::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
+end

data/lib/thinreports/basic_report/layout/format.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Thinreports
+  module BasicReport
+    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
+end