thinreports 0.12.0 → 0.13.0

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Graphics
+          # @param [Hash] style
+          # @yield [attrs]
+          # @yieldparam [Hash] attrs
+          # @return [Hash]
+          def build_graphic_attributes(style, &block)
+            graphic_attributes = {
+              stroke: style['border-color'],
+              stroke_width: style['border-width'],
+              stroke_type: style['border-style'],
+              fill: style['fill-color']
+            }
+            block.call(graphic_attributes) if block_given?
+            graphic_attributes
+          end
+
+          # @param [Hash] style
+          # @yield [attrs]
+          # @yieldparam [Hash] attrs
+          # @return [Hash]
+          def build_text_attributes(style, &block)
+            text_attributes = {
+              font: font_family(style['font-family']),
+              size: style['font-size'],
+              color: style['color'],
+              align: text_align(style['text-align']),
+              valign: text_valign(style['vertical-align']),
+              styles: font_styles(style['font-style']),
+              letter_spacing: letter_spacing(style['letter-spacing']),
+              line_height: line_height(style['line-height']),
+              overflow: text_overflow(style['overflow']),
+              word_wrap: word_wrap(style['word-wrap'])
+            }
+            block.call(text_attributes) if block_given?
+            text_attributes
+          end
+
+          # @param [Array<String>] font_names
+          # @return [String]
+          def font_family(font_names)
+            font_name = font_names.first
+            default_family_if_missing(font_name)
+          end
+
+          # @param [Array<String>] styles
+          # @return [Array<Symbol>]
+          def font_styles(styles)
+            styles.map do |font_style|
+              case font_style
+              when 'bold' then :bold
+              when 'italic' then :italic
+              when 'underline' then :underline
+              when 'linethrough' then :strikethrough
+              end
+            end
+          end
+
+          # @param [Float, "", nil] spacing
+          # @return [Float, nil]
+          def letter_spacing(spacing)
+            blank_value?(spacing) ? nil : spacing
+          end
+
+          # @param ["left", "center", "right", ""] align
+          # @return [:left, :center, :right]
+          def text_align(align)
+            case align
+            when 'left' then :left
+            when 'center' then :center
+            when 'right' then :right
+            when '' then :left
+            else :left
+            end
+          end
+
+          # @param ["top", "middle", "bottom", "", nil] valign
+          # @return [:top, :center, :bottom]
+          def text_valign(valign)
+            case valign
+            when 'top' then :top
+            when 'middle' then :center
+            when 'bottom' then :bottom
+            when '' then :top
+            else :top
+            end
+          end
+
+          # @param ["truncate", "fit", "expand", "", nil] overflow
+          # @return [:truncate, :shrink_to_fit, :expand]
+          def text_overflow(overflow)
+            case overflow
+            when 'truncate' then :truncate
+            when 'fit' then :shrink_to_fit
+            when 'expand' then :expand
+            when '' then :truncate
+            else :truncate
+            end
+          end
+
+          # @param ["break-word", "none", "", nil] word_wrap
+          # @return [:break_word, :none]
+          def word_wrap(word_wrap)
+            case word_wrap
+            when 'break-word' then :break_word
+            when 'none' then :none
+            else :none
+            end
+          end
+
+          # @param [Float, "", nil] height
+          # @return [Float, nil]
+          def line_height(height)
+            blank_value?(height) ? nil : height
+          end
+
+          # @param ["left", "center", "right", ""] position
+          # @return [:left, :center, :right]
+          def image_position_x(position)
+            case position
+            when 'left' then :left
+            when 'center' then :center
+            when 'right' then :right
+            when '' then :left
+            else :left
+            end
+          end
+
+          # @param ["top", "middle", "bottom", ""] position
+          # @return [:left, :center, :right]
+          def image_position_y(position)
+            case position
+            when 'top' then :top
+            when 'middle' then :center
+            when 'bottom' then :bottom
+            when '' then :top
+            else :top
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Graphics
+          STROKE_DASH = {
+            dashed: [2, 2],
+            dotted: [1, 2]
+          }.freeze
+
+          # @param [Numeric, String] x1
+          # @param [Numeric, String] y1
+          # @param [Numeric, String] x2
+          # @param [Numeric, String] y2
+          # @param [Hash] attrs ({})
+          # @option attrs [String] :stroke
+          # @option attrs [Numeric, String] :stroke_width
+          # @option attrs ["solid", "dashed", "dotted"] :stroke_type
+          def line(x1, y1, x2, y2, attrs = {})
+            with_graphic_styles(attrs) do
+              pdf.line(pos(x1, y1), pos(x2, y2))
+            end
+          end
+
+          # @param [Numeric, String] x
+          # @param [Numeric, String] y
+          # @param [Numeric, String] w width
+          # @param [Numeric, String] h height
+          # @param [Hash] attrs ({})
+          # @option attrs [Integer, String] :radius
+          # @option attrs [String] :stroke
+          # @option attrs [Numeric, String] :stroke_width
+          # @option attrs ["solid", "dashed", "dotted"] :stroke_type
+          # @option attrs [String] :fill
+          def rect(x, y, w, h, attrs = {})
+            w, h = s2f(w, h)
+            radius = s2f(attrs[:radius])
+
+            with_graphic_styles(attrs) do
+              if radius && !radius.zero?
+                pdf.rounded_rectangle(pos(x, y), w, h, radius)
+              else
+                pdf.rectangle(pos(x, y), w, h)
+              end
+            end
+          end
+
+          # @param [Numeric, String] x center-x
+          # @param [Numeric, String] y center-y
+          # @param [Numeric, String] rx
+          # @param [Numeric, String] ry
+          # @param [Hash] attrs ({})
+          # @option attrs [String] :stroke
+          # @option attrs [Numeric, String] :stroke_width
+          # @option attrs [Array<Integer, String>] :stroke_dash
+          # @option attrs ["solid", "dashed", "dotted"] :stroke_type
+          # @option attrs [String] :fill
+          def ellipse(x, y, rx, ry, attrs = {})
+            rx, ry = s2f(rx, ry)
+
+            with_graphic_styles(attrs) do
+              pdf.ellipse(pos(x, y), rx, ry)
+            end
+          end
+
+          # @param [Hash] attrs
+          def with_graphic_styles(attrs, &block)
+            stroke = build_stroke_styles(attrs)
+            fill = build_fill_styles(attrs)
+
+            # Do not draw if no colors given.
+            return unless fill || stroke
+
+            save_graphics_state
+
+            # Apply stroke-dashed.
+            if stroke && stroke[:dash]
+              length, space = stroke[:dash]
+              pdf.dash(length, space: space)
+            end
+
+            # Draw with fill and stroke.
+            if fill && stroke
+              pdf.fill_and_stroke do
+                line_width(stroke[:width])
+                pdf.fill_color(fill[:color])
+                pdf.stroke_color(stroke[:color])
+                block.call
+              end
+            # Draw only with fill.
+            elsif fill
+              pdf.fill do
+                pdf.fill_color(fill[:color])
+                block.call
+              end
+            # Draw only with stroke.
+            elsif stroke
+              pdf.stroke do
+                line_width(stroke[:width])
+                pdf.stroke_color(stroke[:color])
+                block.call
+              end
+            end
+
+            restore_graphics_state
+          end
+
+          # @param [Hash] styles
+          # @return [Hash, nil]
+          def build_stroke_styles(styles)
+            color = styles[:stroke]
+            width = styles[:stroke_width]
+            return nil unless color && color != 'none'
+            return nil unless width && width != 0
+
+            {
+              color: parse_color(color),
+              width: s2f(width),
+              dash: STROKE_DASH[styles[:stroke_type].to_sym]
+            }
+          end
+
+          # @param [Hash] styles
+          # @return [Hash, nil]
+          def build_fill_styles(styles)
+            color = styles[:fill]
+            return nil unless color && color != 'none'
+
+            { color: parse_color(color) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'base64'
+require 'digest/md5'
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Graphics
+          # @param [String, IO] filename_or_io
+          # @param [Numeric, Strng] x
+          # @param [Numeric, Strng] y
+          # @param [Numeric, Strng] w
+          # @param [Numeric, Strng] h
+          def image(filename_or_io, x, y, w, h)
+            w, h = s2f(w, h)
+            pdf.image(filename_or_io, at: pos(x, y), width: w, height: h)
+          end
+
+          # @param [String] base64_data
+          # @param [Numeric, Strng] x
+          # @param [Numeric, Strng] y
+          # @param [Numeric, Strng] w
+          # @param [Numeric, Strng] h
+          def base64image(base64_data, x, y, w, h)
+            image_data = Base64.decode64(base64_data)
+            image_id = Digest::MD5.hexdigest(base64_data)
+            image_path = create_temp_imagefile(image_id, image_data)
+
+            image(image_path, x, y, w, h)
+          end
+
+          # @param [String, IO] filename_or_io
+          # @param [Numeric, Strng] x
+          # @param [Numeric, Strng] y
+          # @param [Numeric, Strng] w
+          # @param [Numeric, Strng] h
+          # @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)
+
+            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,
+                vposition: options[:position_y] || :top,
+                auto_fit: [w, h]
+              )
+            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(&:close!)
+            temp_image_registry.clear
+          end
+
+          def temp_image_registry
+            @temp_image_registry ||= {}
+          end
+
+          # @param [String] image_id
+          # @param [String] image_data
+          # @return [String] Path to imagefile
+          def create_temp_imagefile(image_id, image_data)
+            temp_image_registry[image_id] ||= begin
+              file = Tempfile.new('temp-image')
+              file.binmode
+              file.write(image_data)
+              file.open
+              file
+            end
+            temp_image_registry[image_id].path
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Graphics
+          # @param [String] content
+          # @param [Numeric, String] x
+          # @param [Numeric, String] y
+          # @param [Numeric, String] w
+          # @param [Numeric, String] h
+          # @param [Hash] attrs ({})
+          # @option attrs [String] :font
+          # @option attrs [Numeric, String] :size
+          # @option attrs [String] :color
+          # @option attrs [Array<:bold, :italic, :underline, :strikethrough>]
+          #   :styles (nil)
+          # @option attrs [:left, :center, :right] :align (:left)
+          # @option attrs [:top, :center, :bottom] :valign (:top)
+          # @option attrs [Numeric, String] :line_height The total height of an text line.
+          # @option attrs [Numeric, String] :letter_spacing
+          # @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 = {}, &block)
+            w, h = s2f(w, h)
+
+            box_attrs = text_box_attrs(
+              x, y, w, h,
+              single: attrs.delete(:single),
+              overflow: attrs[:overflow]
+            )
+
+            # Do not break by word unless :word_wrap is :break_word
+            content = text_without_line_wrap(content) if attrs[:word_wrap] == :none
+
+            with_text_styles(attrs) do |built_attrs, font_styles|
+              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.
+            #
+            # When the area is too small compared
+            # with the content and the style of the text.
+            #   (See prawn/core/text/formatted/line_wrap.rb#L185)
+          end
+
+          # @see #text_box
+          def text(content, x, y, w, h, attrs = {})
+            # Set the :overflow property to :shirink_to_fit.
+            text_box(content, x, y, w, h, { overflow: :shirink_to_fit }.merge(attrs))
+          end
+
+          private
+
+          # @param x (see #text_box)
+          # @param y (see #text_box)
+          # @param w (see #text_box)
+          # @param h (see #text_box)
+          # @param [Hash] states
+          # @option states [Boolean] :single
+          # @option states [Symbold] :overflow
+          # @return [Hash]
+          def text_box_attrs(x, y, w, h, states = {})
+            attrs = {
+              at: pos(x, y),
+              width: s2f(w)
+            }
+            if states[:single]
+              states[:overflow] != :expand ? attrs.merge(single_line: true) : attrs
+            else
+              attrs.merge(height: s2f(h))
+            end
+          end
+
+          # @param attrs (see #text)
+          # @yield [built_attrs, font_styles]
+          # @yieldparam [Hash] built_attrs The finalized attributes.
+          # @yieldparam [Array] font_styles The finalized styles.
+          def with_text_styles(attrs, &block)
+            # When no color is given, do not draw.
+            return unless attrs.key?(:color) && attrs[:color] != 'none'
+
+            save_graphics_state
+
+            fontinfo = {
+              name: attrs.delete(:font).to_s,
+              color: parse_color(attrs.delete(:color)),
+              size: s2f(attrs.delete(:size))
+            }
+
+            # Add the specified value to :leading option.
+            line_height = attrs.delete(:line_height)
+            if line_height
+              attrs[:leading] = text_line_leading(
+                s2f(line_height),
+                name: fontinfo[:name],
+                size: fontinfo[:size]
+              )
+            end
+
+            # Set the :character_spacing option.
+            spacing = attrs.delete(:letter_spacing)
+            attrs[:character_spacing] = s2f(spacing) if spacing
+
+            # Or... with_font_styles(attrs, fontinfo, &block)
+            with_font_styles(attrs, fontinfo) do |modified_attrs, styles|
+              block.call(modified_attrs, styles)
+            end
+
+            restore_graphics_state
+          end
+
+          # @param [Numeric] line_height
+          # @param [Hash] font
+          # @option font [String] :name Name of font.
+          # @option font [Numeric] :size Size of font.
+          # @return [Numeric]
+          def text_line_leading(line_height, font)
+            line_height - pdf.font(font[:name], size: font[:size]).height
+          end
+
+          # @param [String] content
+          # @return [String]
+          def text_without_line_wrap(content)
+            content.gsub(/ /, Prawn::Text::NBSP)
+          end
+
+          # @param [Hash] attrs
+          # @param [Hash] font
+          # @option font [String] :color
+          # @option font [Numeric] :size
+          # @option font [String] :name
+          # @yield [attributes, styles]
+          # @yieldparam [Hash] modified_attrs
+          # @yieldparam [Array] styles
+          def with_font_styles(attrs, font, &block)
+            # Building font styles.
+            styles = attrs.delete(:styles)
+
+            if styles
+              manual, styles = styles.partition do |style|
+                %i[bold italic].include?(style) && !font_has_style?(font[:name], style)
+              end
+            end
+
+            # Emulate bold style.
+            if manual && manual.include?(:bold)
+              pdf.stroke_color(font[:color])
+              pdf.line_width(font[:size] * 0.025)
+
+              # Change rendering mode to :fill_stroke.
+              attrs[:mode] = :fill_stroke
+            end
+
+            # Emulate italic style.
+            if manual && manual.include?(:italic)
+              # FIXME
+              # pdf.transformation_matrix(1, 0, 0.26, 1, 0, 0)
+            end
+
+            pdf.font(font[:name], size: font[:size]) do
+              pdf.fill_color(font[:color])
+              block.call(attrs, styles || [])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Graphics
+          BASE_LINE_WIDTH = 0.9
+
+          private
+
+          # Change the default graphic states defined by Prawn.
+          def setup_custom_graphic_states
+            pdf.line_width(BASE_LINE_WIDTH)
+          end
+
+          # @param [Numeric] width
+          def line_width(width)
+            pdf.line_width(width * BASE_LINE_WIDTH)
+          end
+
+          # Delegate to Prawn::Document#save_graphic_state
+          # @see Prawn::Document#save_graphics_state
+          def save_graphics_state
+            pdf.save_graphics_state
+          end
+
+          # Delegate to Prawn::Document#restore_graphic_state
+          # @see Prawn::Document#restore_graphics_state
+          def restore_graphics_state
+            pdf.restore_graphics_state
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'graphics/attributes'
+require_relative 'graphics/basic'
+require_relative 'graphics/image'
+require_relative 'graphics/text'

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Thinreports
+  module BasicReport
+    module Generator
+      class PDF
+        module Page
+          JIS_SIZES = {
+            'B4' => [728.5, 1031.8],
+            'B5' => [515.9, 728.5]
+          }.freeze
+
+          # @param [Thinreports::BasicReport::Layout::Format] format
+          def start_new_page(format)
+            format_id =
+              if change_page_format?(format)
+                pdf.start_new_page(new_basic_page_options(format))
+                @current_page_format = format
+
+                create_format_stamp(format) unless format_stamp_registry.include?(format.identifier)
+                format.identifier
+              else
+                pdf.start_new_page(new_basic_page_options(current_page_format))
+                current_page_format.identifier
+              end
+
+            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
+
+          private
+
+          # @return [Thinreports::BasicReport::Layout::Format]
+          attr_reader :current_page_format
+
+          # @param [Thinreports::BasicReport::Layout::Format] new_format
+          # @return [Boolean]
+          def change_page_format?(new_format)
+            !current_page_format ||
+              current_page_format.identifier != new_format.identifier
+          end
+
+          # @param [Thinreports::BasicReport::Layout::Format] format
+          def create_format_stamp(format)
+            create_stamp(format.identifier.to_s) do
+              draw_template_items(format.attributes['items'])
+            end
+            format_stamp_registry << format.identifier
+          end
+
+          # @return [Array]
+          def format_stamp_registry
+            @format_stamp_registry ||= []
+          end
+
+          # @param [Thinreports::BasicReport::Layout::Format] format
+          # @return [Hash]
+          def new_basic_page_options(format)
+            options = { layout: format.page_orientation.to_sym }
+
+            options[:size] =
+              if format.user_paper_type?
+                [format.page_width.to_f, format.page_height.to_f]
+              else
+                case format.page_paper_type
+                # Convert B4(5)_ISO to B4(5)
+                when 'B4_ISO', 'B5_ISO'
+                  format.page_paper_type.delete('_ISO')
+                when 'B4', 'B5'
+                  JIS_SIZES[format.page_paper_type]
+                else
+                  format.page_paper_type
+                end
+              end
+            options
+          end
+        end
+      end
+    end
+  end
+end