thinreports 0.9.1 → 0.10.0

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

@@ -1,172 +1,80 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 require 'tempfile'
 require 'base64'
 require 'digest/md5'
-require 'chunky_png'
 
 module Thinreports
   module Generator
-
-    module PDF::Graphics
-      # @param [String] filename
-      # @param [Numeric, Strng] x
-      # @param [Numeric, Strng] y
-      # @param [Numeric, Strng] w
-      # @param [Numeric, Strng] h
-      def image(filename, x, y, w, h)
-        w, h = s2f(w, h)
-        pdf.image(filename, at: pos(x, y), width: w, height: h)
-      end
-
-      # @param [String] image_type Mime-type of image
-      # @param [String] base64
-      # @param [Numeric, Strng] x
-      # @param [Numeric, Strng] y
-      # @param [Numeric, Strng] w
-      # @param [Numeric, Strng] h
-      def base64image(image_type, base64_data, x, y, w, h)
-        image_path = normalize_image_from_base64(image_type, base64_data)
-        image(image_path, x, y, w, h)
-      end
-
-      # @param [String, IO] file
-      # @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)
-      def image_box(file, x, y, w, h, options = {})
-        image_data_or_path = normalize_image_from_file(file)
-
-        w, h = s2f(w, h)
-        pdf.bounding_box(pos(x, y), width: w, height: h) do
-          pdf.image(
-            image_data_or_path,
-            position: options[:position_x] || :left,
-            vposition: options[:position_y] || :top,
-            auto_fit: [w, h]
-          )
+    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
-      end
-
-      def normalize_image_from_base64(image_type, base64_string)
-        raw_image_data = Base64.decode64(base64_string)
-
-        image_data =
-          if png_conversion_enabled? && image_type == 'image/png'
-            png_normalizer = PNGNormalizer.load_blob(raw_image_data)
-
-            if png_normalizer.need_normalize?
-              png_normalizer.normalize
-            else
-              raw_image_data
-            end
-          else
-            raw_image_data
-          end
 
-        image_id = Digest::MD5.hexdigest(base64_string)
-        create_temp_imagefile(image_id, image_data)
-      end
-
-      def normalize_image_from_file(file)
-        return file unless file.is_a?(String)
-
-        filename = file
-        extname = File.extname(filename)
-
-        return filename unless png_conversion_enabled?
-        return filename unless extname.downcase == '.png' || extname.empty?
-
-        return temp_image_registry[filename].path if temp_image_registry.key?(filename)
-
-        png_normalizer = PNGNormalizer.load_file(filename)
-
-        # Returns the original filename when the image is not PNG.
-        return filename if png_normalizer.nil?
-        return filename unless png_normalizer.need_normalize?
-
-        image_id = filename
-        image_data = png_normalizer.normalize
-
-        create_temp_imagefile(image_id, image_data)
-      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
-
-      def png_conversion_enabled?
-        Thinreports.config.convert_palleted_transparency_png
-      end
-
-      class PNGNormalizer
-        def self.load_file(filename)
-          image = ChunkyPNG::Image.from_file(filename)
-          datastream = ChunkyPNG::Datastream.from_file(filename)
-          self.new image, datastream
-        rescue ChunkyPNG::SignatureMismatch
-          # Returns nil if image is not PNG.
-          nil
-        end
-
-        def self.load_blob(data)
-          image = ChunkyPNG::Image.from_blob(data)
-          datastream = ChunkyPNG::Datastream.from_blob(data)
-          self.new image, datastream
-        rescue ChunkyPNG::SignatureMismatch
-          # Returns nil if image is not PNG.
-          nil
-        end
-
-        def initialize(image, datastream)
-          @image = image
-          @datastream = datastream
+        # @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
 
-        def need_normalize?
-          pallete_based? && transparency_chunk?
+        # @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)
+        def image_box(filename_or_io, x, y, w, h, options = {})
+          w, h = s2f(w, h)
+          pdf.bounding_box(pos(x, y), 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 normalize
-          @image.to_blob(color_mode: ChunkyPNG::COLOR_TRUECOLOR_ALPHA)
+        def clean_temp_images
+          temp_image_registry.each_value do |image_path|
+            File.delete(image_path) if File.exist?(image_path)
+          end
         end
 
-        private
-
-        def pallete_based?
-          color_mode, _depth = @image.palette.best_color_settings
-          color_mode == ChunkyPNG::COLOR_INDEXED
+        def temp_image_registry
+          @temp_image_registry ||= {}
         end
 
-        def transparency_chunk?
-          !@datastream.transparency_chunk.nil?
+        # @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,161 +1,176 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Thinreports
   module Generator
-
-    module PDF::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 = {})
-        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|
-          pdf.formatted_text_box([{ text: content, styles: font_styles }],
-            built_attrs.merge(box_attrs))
+    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 = {})
+          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|
+            pdf.formatted_text_box(
+              [{ text: content, styles: font_styles }],
+              built_attrs.merge(box_attrs)
+            )
+          end
+        # rubocop:disable Lint/HandleExceptions
+        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
-      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))
+        # @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
-      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])
+        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
 
-        # Set the :character_spacing option.
-        spacing = attrs.delete(:letter_spacing)
-        attrs[:character_spacing] = s2f(spacing) if spacing
+        # @param attrs (see #text)
+        # @yield [built_attrs, font_styles]
+        # @yieldparam [Hash] built_attrs The finalized attributes.
+        # @yieldparam [Array] font_styles The finalized styles.
+        # rubocop:disable Metrics/AbcSize
+        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
 
-        # Or... with_font_styles(attrs, fontinfo, &block)
-        with_font_styles(attrs, fontinfo) do |modified_attrs, styles|
-          block.call(modified_attrs, styles)
-        end
+          # Set the :character_spacing option.
+          spacing = attrs.delete(:letter_spacing)
+          attrs[:character_spacing] = s2f(spacing) if spacing
 
-        restore_graphics_state
-      end
+          # Or... with_font_styles(attrs, fontinfo, &block)
+          with_font_styles(attrs, fontinfo) do |modified_attrs, styles|
+            block.call(modified_attrs, styles)
+          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
+          restore_graphics_state
+        end
 
-      # @param [String] content
-      # @return [String]
-      def text_without_line_wrap(content)
-        content.gsub(/ /, Prawn::Text::NBSP)
-      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 [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|
-            [:bold, :italic].include?(style) && !font_has_style?(font[:name], style)
-          end
+        # @param [String] content
+        # @return [String]
+        def text_without_line_wrap(content)
+          content.gsub(/ /, Prawn::Text::NBSP)
         end
 
-        # Emulate bold style.
-        if manual && manual.include?(:bold)
-          pdf.stroke_color(font[:color])
-          pdf.line_width(font[:size] * 0.025)
+        # @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
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        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
 
-          # Change rendering mode to :fill_stroke.
-          attrs[:mode] = :fill_stroke
-        end
+          # Emulate bold style.
+          if manual && manual.include?(:bold)
+            pdf.stroke_color(font[:color])
+            pdf.line_width(font[:size] * 0.025)
 
-        # Emulate italic style.
-        if manual && manual.include?(:italic)
-          # FIXME
-          # pdf.transformation_matrix(1, 0, 0.26, 1, 0, 0)
-        end
+            # 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 || [])
+          pdf.font(font[:name], size: font[:size]) do
+            pdf.fill_color(font[:color])
+            block.call(attrs, styles || [])
+          end
         end
       end
-
     end
-
   end
 end