thinreports 0.12.1 → 0.13.0

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

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  module Generator
-    class PDF
-      module Font
-        FONT_STORE = Thinreports.root.join('fonts')
-
-        BUILTIN_FONTS = {
-          'IPAMincho'  => FONT_STORE.join('ipam.ttf').to_s,
-          'IPAPMincho' => FONT_STORE.join('ipamp.ttf').to_s,
-          'IPAGothic'  => FONT_STORE.join('ipag.ttf').to_s,
-          'IPAPGothic' => FONT_STORE.join('ipagp.ttf').to_s
-        }.freeze
-
-        DEFAULT_FALLBACK_FONTS = %w[IPAMincho].freeze
-
-        PRAWN_BUINTIN_FONT_ALIASES = {
-          'Courier New' => 'Courier',
-          'Times New Roman' => 'Times-Roman'
-        }.freeze
-
-        def setup_fonts
-          # Install built-in fonts.
-          BUILTIN_FONTS.each do |font_name, font_path|
-            install_font(font_name, font_path)
-          end
-
-          # Create aliases from the font list provided by Prawn.
-          PRAWN_BUINTIN_FONT_ALIASES.each do |alias_name, name|
-            pdf.font_families[alias_name] = pdf.font_families[name]
-          end
-
-          # Setup custom fallback fonts
-          fallback_fonts = Thinreports.config.fallback_fonts.uniq
-          fallback_fonts.map!.with_index do |font, i|
-            if pdf.font_families.key?(font)
-              font
-            else
-              install_font "Custom-fallback-font#{i}", font
-            end
-          end
-
-          # Set fallback fonts
-          pdf.fallback_fonts(fallback_fonts + DEFAULT_FALLBACK_FONTS)
-        end
-
-        # @param [String] name
-        # @param [String] file
-        # @return [String] installed font name
-        def install_font(name, file)
-          raise Errors::FontFileNotFound unless File.exist?(file)
-
-          pdf.font_families[name] = {
-            normal: file,
-            bold: file,
-            italic: file,
-            bold_italic: file
-          }
-          name
-        end
-
-        # @return [String]
-        def default_family
-          'Helvetica'
-        end
-
-        # @param [String] family
-        # @return [String]
-        def default_family_if_missing(family)
-          pdf.font_families.key?(family) ? family : default_family
-        end
-
-        # @param [String] font_name
-        # @param [:bold, :italic] font_style
-        # @return [Boolean]
-        def font_has_style?(font_name, font_style)
-          font = pdf.font_families[font_name]
-
-          return false unless font
-          return false unless font.key?(font_style)
-
-          font[font_style] != font[:normal]
-        end
-      end
-    end
-  end
-end

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

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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

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

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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

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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require 'tempfile'
-require 'base64'
-require 'digest/md5'
-
-module Thinreports
-  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 do |image_path|
-            File.delete(image_path) if File.exist?(image_path)
-          end
-        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

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

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Thinreports
-  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
-
-require_relative 'graphics/attributes'
-require_relative 'graphics/basic'
-require_relative 'graphics/image'
-require_relative 'graphics/text'