thinreports 0.8.2 → 0.9.0

data/lib/thinreports/core/shape/text_block.rb

@@ -2,11 +2,11 @@
 
 module Thinreports
   module Core::Shape
-    
+
     module TextBlock
-      TYPE_NAME = 's-tblock'
+      TYPE_NAME = 'text-block'
     end
-    
+
   end
 end
 

data/lib/thinreports/core/shape/text_block/format.rb

@@ -4,9 +4,12 @@ module Thinreports
   module Core::Shape
 
     class TextBlock::Format < Basic::BlockFormat
-      config_reader ref_id: %w( ref-id )
-      config_reader :valign, :overflow
-      config_reader line_height: %w( line-height )
+      # For saving compatible 0.8.x format API
+      config_reader ref_id: %w( reference-id )
+      config_reader valign: %w( style vertical-align )
+      config_reader overflow: %w( style overflow )
+      config_reader line_height: %w( style line-height )
+
       config_reader format_base: %w( format base ),
                     format_type: %w( format type ),
                     format_datetime_format: %w( format datetime format ),
@@ -14,9 +17,8 @@ module Thinreports
                     format_number_precision: %w( format number precision ),
                     format_padding_char: %w( format padding char ),
                     format_padding_dir: %w( format padding direction )
-      config_reader word_wrap: %w( word-wrap )
 
-      config_checker 'true', :multiple
+      config_checker true, multiple: %w( multiple-line )
       config_checker 'R', format_padding_rdir: %w( format padding direction )
 
       config_reader format_padding_length: %w( format padding length ) do |len|
@@ -27,7 +29,8 @@ module Thinreports
         %w( datetime number padding ).include?(type)
       end
 
-      config_reader :has_reference? => %w( ref-id ) do |ref_id|
+      # For saving compatible 0.8.x format API
+      def has_reference?
         !blank_value?(ref_id)
       end
     end

data/lib/thinreports/core/shape/text_block/interface.rb

@@ -2,17 +2,17 @@
 
 module Thinreports
   module Core::Shape
-    
+
     class TextBlock::Interface < Basic::BlockInterface
       internal_delegators :format_enabled?
-      
+
       # @param [Boolean] enabled
       # @return [self]
       def format_enabled(enabled)
         internal.format_enabled(enabled)
         self
       end
-      
+
       # @param [Object] val
       # @param [Hash<Symbol, Object>] style_settings
       # @return [self]
@@ -20,14 +20,14 @@ module Thinreports
         value(val)
         styles(style_settings) #=> self
       end
-    
+
     private
-      
+
       # @see Thinreports::Core::Shape::Base::Interface#init_internal
       def init_internal(parent, format)
         TextBlock::Internal.new(parent, format)
       end
     end
-    
+
   end
-end
+end

data/lib/thinreports/core/shape/text_block/internal.rb

@@ -61,7 +61,7 @@ module Thinreports
       end
 
       def type_of?(type_name)
-        type_name == :tblock || super
+        type_name == TextBlock::TYPE_NAME || super
       end
 
     private

data/lib/thinreports/generator/pdf.rb

@@ -56,7 +56,6 @@ module Thinreports
   end
 end
 
-require 'thinreports/generator/pdf/configuration'
 require 'thinreports/generator/pdf/prawn_ext'
 require 'thinreports/generator/pdf/document'
 require 'thinreports/generator/pdf/drawer/base'

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

@@ -4,7 +4,7 @@ require 'thinreports/generator/pdf/document/font'
 require 'thinreports/generator/pdf/document/parse_color'
 require 'thinreports/generator/pdf/document/graphics'
 require 'thinreports/generator/pdf/document/draw_shape'
-require 'thinreports/generator/pdf/document/parse_svg'
+require 'thinreports/generator/pdf/document/draw_template_items'
 require 'thinreports/generator/pdf/document/page'
 
 module Thinreports
@@ -17,7 +17,7 @@ module Thinreports
       include PDF::ParseColor
       include PDF::Graphics
       include PDF::DrawShape
-      include PDF::ParseSVG
+      include PDF::DrawTemplateItems
       include PDF::Page
 
       # @return [Prawn::Document]

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

@@ -6,11 +6,11 @@ module Thinreports
     module PDF::DrawShape
       # @param [Thinreports::Core::Shape::TextBlock::Internal] shape
       def draw_shape_tblock(shape)
-        x, y, w, h = shape.box.values_at('x', 'y', 'width', 'height')
+        x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
 
         content = shape.real_value.to_s
         unless content.empty?
-          attrs = shape_text_attrs(shape)
+          attrs = build_text_attributes(shape.style.finalized_styles)
 
           unless shape.multiple?
             content = content.gsub(/\n/, ' ')
@@ -21,83 +21,57 @@ module Thinreports
       end
 
       def draw_shape_pageno(shape, page_no, page_count)
-        x, y, w, h = shape.box.values_at('x', 'y', 'width', 'height')
+        x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
 
         text_box(shape.build_format(page_no, page_count), x, y, w, h,
-                 common_text_attrs(shape.style.svg_attrs))
+          build_text_attributes(shape.style.finalized_styles))
       end
 
       # @param [Thinreports::Core::Shape::Basic::Internal] shape
       def draw_shape_image(shape)
-        x, y, w, h = shape.style.svg_attrs.values_at('x', 'y', 'width', 'height')
+        x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
 
-        image_type, image_data = extract_base64_string(shape.style.svg_attrs['xlink:href'])
-        base64image(image_type, image_data, x, y, w, h)
+        image_data = shape.format.attributes['data']
+        base64image(image_data['mime-type'], image_data['base64'], x, y, w, h)
       end
 
       # @param [Thinreports::Core::Shape::ImageBlock::Internal] shape
       def draw_shape_iblock(shape)
-        x, y, w, h = shape.box.values_at('x', 'y', 'width', 'height')
-        unless blank_value?(shape.src)
-          posx = shape.format.position_x
-          posy = shape.format.position_y
-
-          image_box(shape.src, x, y, w, h,
-                    position_x: posx ? posx.to_sym : nil,
-                    position_y: posy ? posy.to_sym : nil)
-        end
+        return if blank_value?(shape.src)
+
+        x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+        style = shape.style.finalized_styles
+
+        image_box(shape.src, x, y, w, h,
+          position_x: image_position_x(style['position-x']),
+          position_y: image_position_y(style['position-y']))
       end
 
       # @param [Thinreports::Core::Shape::Text::Internal] shape
       def draw_shape_text(shape)
-        x, y, w, h = shape.box.values_at('x', 'y', 'width', 'height')
-        text(shape.text.join("\n"), x, y, w, h,
-             shape_text_attrs(shape))
+        x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+        text(shape.texts.join("\n"), x, y, w, h, build_text_attributes(shape.style.finalized_styles))
       end
 
       # @param [Thinreports::Core::Shape::Basic::Internal] shape
       def draw_shape_ellipse(shape)
-        args = shape.style.svg_attrs.values_at('cx', 'cy', 'rx', 'ry')
-        args << common_graphic_attrs(shape.style.svg_attrs)
-        ellipse(*args)
+        cx, cy, rx, ry = shape.format.attributes.values_at('cx', 'cy', 'rx', 'ry')
+        ellipse(cx, cy, rx, ry, build_graphic_attributes(shape.style.finalized_styles))
       end
 
       # @param [Thinreports::Core::Shape::Basic::Internal] shape
       def draw_shape_line(shape)
-        args = shape.style.svg_attrs.values_at('x1', 'y1', 'x2', 'y2')
-        args << common_graphic_attrs(shape.style.svg_attrs)
-        line(*args)
+        x1, y1, x2, y2 = shape.format.attributes.values_at('x1', 'y1', 'x2', 'y2')
+        line(x1, y1, x2, y2, build_graphic_attributes(shape.style.finalized_styles))
       end
 
       # @param [Thinreports::Core::Shape::Basic::Internal] shape
       def draw_shape_rect(shape)
-        args = shape.style.svg_attrs.values_at('x', 'y', 'width', 'height')
-        args << common_graphic_attrs(shape.style.svg_attrs) do |attrs|
-          attrs[:radius] = shape.style.svg_attrs['rx']
-        end
-        rect(*args)
-      end
-
-    private
-
-      # @param [Thinreports::Core::Shape::Text::Internal, Thinreports::Core::Shape::TextBlock::Internal] shape
-      # @return [Hash]
-      def shape_text_attrs(shape)
-        format = shape.format
-
-        common_text_attrs(shape.style.svg_attrs) do |attrs|
-          # Set the :line_height option.
-          attrs[:line_height] = format.line_height unless blank_value?(format.line_height)
-          # Set the :valign option.
-          attrs[:valign]      = shape.style.valign
-
-          if shape.type_of?(:tblock)
-            # Set the :overflow option.
-            attrs[:overflow] = text_overflow(format.overflow)
-            # Set the :word_wrap option
-            attrs[:word_wrap] = text_word_wrap(format.word_wrap)
-          end
+        x, y, w, h = shape.format.attributes.values_at('x', 'y', 'width', 'height')
+        rect_attributes = build_graphic_attributes(shape.style.finalized_styles) do |attrs|
+          attrs[:radius] = shape.format.attributes['rx']
         end
+        rect(x, y, w, h, rect_attributes)
       end
     end
 

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

@@ -0,0 +1,66 @@
+# coding: utf-8
+
+module Thinreports
+  module Generator
+
+    module PDF::DrawTemplateItems
+      # @param [Array<Hash>] items
+      def draw_template_items(items)
+        items.each do |item_attributes|
+          next unless drawable?(item_attributes)
+
+          case item_attributes['type']
+          when 'text' then draw_text(item_attributes)
+          when 'image' then draw_image(item_attributes)
+          when 'rect' then draw_rect(item_attributes)
+          when 'ellipse' then draw_ellipse(item_attributes)
+          when 'line' then draw_line(item_attributes)
+          end
+        end
+      end
+
+      private
+
+      # @param [Hash] item_attributes
+      def draw_rect(item_attributes)
+        x, y, w, h = item_attributes.values_at('x', 'y', 'width', 'height')
+        graphic_attributes = build_graphic_attributes(item_attributes['style']) do |attrs|
+          attrs[:radius] = item_attributes['rx']
+        end
+
+        rect(x, y, w, h, graphic_attributes)
+      end
+
+      # @see #draw_rect
+      def draw_ellipse(item_attributes)
+        x, y, rx, ry = item_attributes.values_at('cx', 'cy', 'rx', 'ry')
+        ellipse(x, y, rx, ry, build_graphic_attributes(item_attributes['style']))
+      end
+
+      # @see #draw_rect
+      def draw_line(item_attributes)
+        x1, y1, x2, y2 = item_attributes.values_at('x1', 'y1', 'x2', 'y2')
+        line(x1, y1, x2, y2, build_graphic_attributes(item_attributes['style']))
+      end
+
+      # @see #draw_rect
+      def draw_text(item_attributes)
+        x, y, w, h = item_attributes.values_at('x', 'y', 'width', 'height')
+        text(item_attributes['texts'].join("\n"), x, y, w, h, build_text_attributes(item_attributes['style']))
+      end
+
+      # @see #draw_rect
+      def draw_image(item_attributes)
+        x, y, w, h = item_attributes.values_at('x', 'y', 'width', 'height')
+        image_data = item_attributes['data']
+
+        base64image(image_data['mime-type'], image_data['base64'], x, y, w, h)
+      end
+
+      def drawable?(item_attributes)
+        item_attributes['id'].empty? && item_attributes['display']
+      end
+    end
+
+  end
+end

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

@@ -15,7 +15,7 @@ module Thinreports
 
       DEFAULT_FALLBACK_FONTS = %w( Helvetica IPAMincho )
 
-      PRAWN_BUINTIN_FONT_ARIASES = {
+      PRAWN_BUINTIN_FONT_ALIASES = {
         'Courier New' => 'Courier',
         'Times New Roman' => 'Times-Roman'
       }
@@ -25,17 +25,12 @@ module Thinreports
         pdf.font_families.update(BUILTIN_FONTS)
 
         # Create aliases from the font list provided by Prawn.
-        PRAWN_BUINTIN_FONT_ARIASES.each do |alias_name, name|
+        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 = []
-        # For compatible to v0.7 or less
-        fallback_fonts |= Thinreports.config.generator.pdf.eudc_fonts
-        fallback_fonts |= Thinreports.config.fallback_fonts
-        fallback_fonts.uniq!
-
+        fallback_fonts = Thinreports.config.fallback_fonts.uniq
         fallback_fonts.map!.with_index do |font, i|
           unless pdf.font_families.key?(font)
             install_font "Custom-fallback-font#{i}", font

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

@@ -4,122 +4,142 @@ module Thinreports
   module Generator
 
     module PDF::Graphics
-      # @param [Hash] svg_attrs
+      # @param [Hash] style
       # @yield [attrs]
       # @yieldparam [Hash] attrs
       # @return [Hash]
-      def common_graphic_attrs(svg_attrs, &block)
-        attrs = {stroke: svg_attrs['stroke'],
-                 stroke_width: svg_attrs['stroke-width'],
-                 fill: svg_attrs['fill']}
-
-        # Set 0 to stroke_width if stroke_opacity is '0'.
-        if svg_attrs['stroke-opacity'] == '0'
-          attrs[:stroke_width] = 0
-        end
-
-        # Setting for stroke dash.
-        if (dash = svg_attrs['stroke-dasharray']) && dash != 'none'
-          attrs[:stroke_dash] = dash.split(',')
-        end
-        block.call(attrs) if block_given?
-        attrs
+      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] svg_attrs
+      # @param [Hash] style
       # @yield [attrs]
       # @yieldparam [Hash] attrs
       # @return [Hash]
-      def common_text_attrs(svg_attrs, &block)
-        attrs = {font: default_family_if_missing(svg_attrs['font-family']),
-                 size: svg_attrs['font-size'],
-                 color: svg_attrs['fill'],
-                 align: text_align(svg_attrs['text-anchor']),
-                 styles: font_styles(svg_attrs)}
-
-        # The Letter Spacing Property.
-        #
-        # When the version of Layout is
-        #   smaller then 0.6.0:
-        #     Use letter-spacing attribute (normal is none).
-        #   0.6.0 or more:
-        #     Use kerning attribute (auto is none).
-        #
-        spacing = text_letter_spacing(svg_attrs['kerning'] || svg_attrs['letter-spacing'])
-        attrs[:letter_spacing] = spacing if spacing
+      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
 
-        block.call(attrs) if block_given?
-        attrs
+      # @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 [Hash] svg_attrs
+      # @param [Array<String>] styles
       # @return [Array<Symbol>]
-      def font_styles(svg_attrs)
-        styles = []
-        styles << :bold   if svg_attrs['font-weight'] == 'bold'
-        styles << :italic if svg_attrs['font-style'] == 'italic'
-
-        if (deco = svg_attrs['text-decoration']) && deco != 'none'
-          deco = deco.split(' ')
-          styles << :underline     if deco.include?('underline')
-          styles << :strikethrough if deco.include?('line-through')
+      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
-        styles
       end
 
-      # @param [String] space
-      # @return [String, nil]
-      def text_letter_spacing(space)
-        %w( normal auto ).include?(space) ? nil : space
+      # @param [Float, "", nil] spacing
+      # @return [Float, nil]
+      def letter_spacing(spacing)
+        blank_value?(spacing) ? nil : spacing
       end
 
-      # @param [String] svg_align
-      # @return [Symbol]
-      def text_align(svg_align)
-        case svg_align
-        when 'start'  then :left
-        when 'middle' then :center
-        when 'end'    then :right
+      # @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 [String] svg_valign
-      # @return [Symbol]
-      def text_valign(svg_valign)
-        case svg_valign
-        when 'top'    then :top
-        when 'center' then :center
+      # @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 [String] overflow
-      # @return [Symbol]
+      # @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 'fit' then :shrink_to_fit
+        when 'expand' then :expand
+        when '' then :truncate
         else :truncate
         end
       end
 
-      # @param [String] word_wrap
-      # @return [Symbol]
-      def text_word_wrap(word_wrap)
+      # @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 [String] xlink
-      # @return [Array<string>] returns ['image/png', '<base64 data>']
-      def extract_base64_string(xlink)
-        _, type, data = xlink.match(%r|^data:(image/[a-z]+?);base64,(.+)|).to_a
-        [type, data]
+      # @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