thinreports 0.8.2 → 0.9.0

data/test/unit/core/test_shape.rb

@@ -4,61 +4,49 @@ require 'test_helper'
 
 class Thinreports::Core::TestShape < Minitest::Test
   include Thinreports::TestHelper
-  
+
   # Alias
   ShapeModule = Thinreports::Core::Shape
-  
+
   def test_find_by_type_should_return_PageNumber
-    assert_same ShapeModule.find_by_type('s-pageno'), ShapeModule::PageNumber
+    assert_same ShapeModule.find_by_type('page-number'), ShapeModule::PageNumber
   end
 
   def test_find_by_type_should_return_ImageBlock
-    assert_same ShapeModule.find_by_type('s-iblock'), ShapeModule::ImageBlock
+    assert_same ShapeModule.find_by_type('image-block'), ShapeModule::ImageBlock
   end
-  
+
   def test_find_by_type_should_return_TextBlock
-    assert_same ShapeModule.find_by_type('s-tblock'), ShapeModule::TextBlock
+    assert_same ShapeModule.find_by_type('text-block'), ShapeModule::TextBlock
   end
-  
+
   def test_find_by_type_should_return_List
-    assert_same ShapeModule.find_by_type('s-list'), ShapeModule::List
+    assert_same ShapeModule.find_by_type('list'), ShapeModule::List
   end
-  
+
   def test_find_by_type_should_return_Text
-    assert_same ShapeModule.find_by_type('s-text'), ShapeModule::Text
+    assert_same ShapeModule.find_by_type('text'), ShapeModule::Text
   end
-  
+
   def test_find_by_type_should_return_Basic_as_Image
-    assert_same ShapeModule.find_by_type('s-image'), ShapeModule::Basic
+    assert_same ShapeModule.find_by_type('image'), ShapeModule::Basic
   end
-  
+
   def test_find_by_type_should_return_Basic_as_Line
-    assert_same ShapeModule.find_by_type('s-line'), ShapeModule::Basic
+    assert_same ShapeModule.find_by_type('line'), ShapeModule::Basic
   end
-  
+
   def test_find_by_type_should_return_Basic_as_Rect
-    assert_same ShapeModule.find_by_type('s-rect'), ShapeModule::Basic
+    assert_same ShapeModule.find_by_type('rect'), ShapeModule::Basic
   end
-  
+
   def test_find_by_type_should_return_Basic_as_Ellipse
-    assert_same ShapeModule.find_by_type('s-ellipse'), ShapeModule::Basic
+    assert_same ShapeModule.find_by_type('ellipse'), ShapeModule::Basic
   end
-  
+
   def test_find_by_type_should_raise
     assert_raises Thinreports::Errors::UnknownShapeType do
       ShapeModule.find_by_type('unknown')
     end
   end
-  
-  def test_Configuration_should_return_Configuration_of_List
-    assert_same ShapeModule::Configuration('s-list'),
-                ShapeModule::List::Configuration
-  end
-  
-  def test_Configuration_should_raise
-    # When shape don't have a Configuration
-    assert_raises Thinreports::Errors::NoConfigurationFound do
-      ShapeModule::Configuration('s-line')
-    end
-  end
 end

data/test/unit/generator/pdf/document/graphics/test_attributes.rb

@@ -9,137 +9,127 @@ class Thinreports::Generator::PDF::Graphics::TestAttributes < Minitest::Test
     @pdf = Thinreports::Generator::PDF::Document.new
   end
 
-  def test_common_graphic_attrs_should_return_converted_Hash_as_attributes
-    result = @pdf.common_graphic_attrs('stroke'       => '#ff0000',
-                                       'stroke-width' => '1',
-                                       'fill'         => '#0000ff')
-    assert_equal result.values_at(:stroke, :stroke_width, :fill),
-                 ['#ff0000', '1', '#0000ff']
+  def test_build_graphic_attributes
+    graphic_styles = {
+      'border-color' => '#ff0000',
+      'border-width' => 2.0,
+      'border-style' => 'solid',
+      'fill-color' => '#000000'
+    }
+
+    assert_equal(
+      {
+        stroke: '#ff0000',
+        stroke_width: 2.0,
+        stroke_type: 'solid',
+        fill: '#000000'
+      },
+      @pdf.build_graphic_attributes(graphic_styles)
+    )
+
+    customized_attributes = @pdf.build_graphic_attributes(graphic_styles) { |attrs| attrs[:stroke] = 'blue' }
+    assert_equal 'blue', customized_attributes[:stroke]
+  end
+
+  def test_build_text_attributes
+    text_styles = {
+      'font-family' => %w( Helvetica IPAMincho ),
+      'font-size' => 18.0,
+      'color' => 'red',
+      'text-align' => 'right',
+      'vertical-align' => 'bottom',
+      'font-style' => %w( bold italic ),
+      'letter-spacing' => 2.0,
+      'line-height' => 20.0,
+      'overflow' => 'expand',
+      'word-wrap' => 'break-word'
+    }
+
+    assert_equal(
+      {
+        font: 'Helvetica',
+        size: 18.0,
+        color: 'red',
+        align: :right,
+        valign: :bottom,
+        styles: [:bold, :italic],
+        letter_spacing: 2.0,
+        line_height: 20.0,
+        overflow: :expand,
+        word_wrap: :break_word
+      },
+      @pdf.build_text_attributes(text_styles)
+    )
+
+    customized_attributes = @pdf.build_text_attributes(text_styles) { |attrs| attrs[:color] = 'blue' }
+    assert_equal 'blue', customized_attributes[:color]
+  end
+
+  def test_font_family
+    assert_equal 'IPAGothic', @pdf.font_family(%w( IPAGothic Helvetica ))
+    assert_equal 'Helvetica', @pdf.font_family(%w( Unknown IPAMincho ))
+  end
+
+  def test_font_styles
+    assert_equal [:bold, :italic, :underline, :strikethrough],
+      @pdf.font_styles(%w( bold italic underline linethrough ))
+  end
+
+  def test_letter_spacing
+    assert_equal 2.0, @pdf.letter_spacing(2.0)
+    assert_nil @pdf.letter_spacing('')
+    assert_nil @pdf.letter_spacing(nil)
+  end
+
+  def test_text_align
+    assert_equal :left, @pdf.text_align('left')
+    assert_equal :center, @pdf.text_align('center')
+    assert_equal :right, @pdf.text_align('right')
+    assert_equal :left, @pdf.text_align('')
+    assert_equal :left, @pdf.text_align(nil)
+  end
+
+  def test_text_valign
+    assert_equal :top, @pdf.text_valign('top')
+    assert_equal :center, @pdf.text_valign('middle')
+    assert_equal :bottom, @pdf.text_valign('bottom')
+    assert_equal :top, @pdf.text_valign('')
+    assert_equal :top, @pdf.text_valign(nil)
   end
 
-  def test_common_graphic_attrs_should_return_the_stroke_dash_attribute_into_an_array
-    result = @pdf.common_graphic_attrs('stroke-dasharray' => '3,5')
-    assert_equal result[:stroke_dash], %w( 3 5 )
-  end
-
-  def test_common_graphic_attrs_should_return_nil_as_a_value_of_stroke_dash_attribute_when_value_is_none
-    result = @pdf.common_graphic_attrs('stroke-dasharray' => 'none')
-    assert_nil result[:stroke_dash]
-  end
-
-  def test_common_graphic_attrs_should_return_nil_as_a_value_of_stroke_dash_attribute_when_value_is_empty
-    result = @pdf.common_graphic_attrs({})
-    assert_nil result[:stroke_dash]
-  end
-
-  def test_common_graphic_attrs_should_set_0_as_a_value_of_stroke_width_attribute_when_opacity_is_0
-    result = @pdf.common_graphic_attrs('stroke-width'   => '1',
-                                       'stroke-opacity' => '0')
-    assert_equal result[:stroke_width], 0
-  end
-
-  def test_common_graphic_attrs_with_block
-    result = @pdf.common_graphic_attrs('stroke' => '#ff0000') do |attrs|
-      attrs[:stroke].gsub!(/0/, 'f')
-    end
-    assert_equal result[:stroke], '#ffffff'
-  end
-
-  def test_text_align_should_return_converted_value_type_of_Symbol
-    aligns = ['start', 'middle', 'end', nil]
-    assert_equal aligns.map {|a| @pdf.text_align(a) },
-                 [:left, :center, :right, :left]
-  end
-
-  def test_text_valign_should_return_converted_value_type_of_Symbol
-    valigns = ['top', 'center', 'bottom', nil]
-    assert_equal valigns.map {|a| @pdf.text_valign(a) },
-                 [:top, :center, :bottom, :top]
-  end
-
-  def test_text_word_wrap
-    assert_equal @pdf.text_word_wrap('break-word'), :break_word
-    assert_equal @pdf.text_word_wrap('none'), :none
-    assert_equal @pdf.text_word_wrap(''), :none
-  end
-
-  def test_extract_base64_string
-    base64 = 'data:image/png;base64,iVBORw0KGg1+/AAy/plYlzil'
-    assert_equal @pdf.extract_base64_string(base64),
-                 ['image/png', 'iVBORw0KGg1+/AAy/plYlzil']
-  end
-
-  def test_font_styles_should_return_bold_style_when_font_weight_is_bold
-    assert_equal @pdf.font_styles('font-weight' => 'bold'), [:bold]
-  end
-
-  def test_font_styles_should_return_italic_style_when_font_style_is_italic
-    assert_equal @pdf.font_styles('font-style' => 'italic'), [:italic]
-  end
-
-  def test_font_styles_should_return_underline_and_strikethrough_style_via_text_decoration
-    assert_equal @pdf.font_styles('text-decoration' => 'underline line-through'),
-                 [:underline, :strikethrough]
-  end
-
-  def test_common_text_attrs_should_return_the_value_of_font_family_as_font
-    result = @pdf.common_text_attrs('font-family' => 'IPAMincho')
-    assert_equal result[:font], 'IPAMincho'
-  end
-
-  def test_common_text_attrs_should_return_the_value_of_font_size_as_size
-    result = @pdf.common_text_attrs('font-size' => '12')
-    assert_equal result[:size], '12'
-  end
-
-  def test_common_text_attrs_should_return_the_value_of_fill_color_as_color
-    result = @pdf.common_text_attrs('fill' => '#000000')
-    assert_equal result[:color], '#000000'
-  end
-
-  def test_common_text_attrs_should_return_the_value_of_text_anchor_as_align
-    result = @pdf.common_text_attrs('text-anchor' => 'middle')
-    assert_equal result[:align], :center
-  end
-
-  def test_common_text_attrs_should_return_the_value_of_text_styles_as_styles
-    result = @pdf.common_text_attrs('font-weight' => 'bold')
-    assert_equal result[:styles], [:bold]
-  end
-
-  def test_common_text_attrs_should_return_the_value_of_letter_spacing_as_letter_spacing
-    result = @pdf.common_text_attrs('letter-spacing' => '5')
-    assert_equal result[:letter_spacing], '5'
-  end
-
-  def test_common_text_attrs_should_return_the_value_of_kerning_as_letter_spacing
-    result = @pdf.common_text_attrs('kerning' => '10')
-    assert_equal result[:letter_spacing], '10'
-  end
-
-  def test_common_text_attrs_with_block
-    result = @pdf.common_text_attrs('fill' => '#000000') do |attrs|
-      attrs[:color].gsub!(/0/, 'f')
-    end
-    assert_equal result[:color], '#ffffff'
+  def test_text_overflow
+    assert_equal :truncate, @pdf.text_overflow('truncate')
+    assert_equal :shrink_to_fit, @pdf.text_overflow('fit')
+    assert_equal :expand, @pdf.text_overflow('expand')
+    assert_equal :truncate, @pdf.text_overflow('')
+    assert_equal :truncate, @pdf.text_overflow(nil)
   end
 
-  def test_text_letter_spacing_should_return_raw_value
-    assert_equal @pdf.text_letter_spacing('10'), '10'
+  def test_word_wrap
+    assert_equal :break_word, @pdf.word_wrap('break-word')
+    assert_equal :none, @pdf.word_wrap('none')
+    assert_equal :none, @pdf.word_wrap(nil)
   end
 
-  def test_text_letter_spacing_should_return_nil_when_value_is_normal
-    assert_nil @pdf.text_letter_spacing('normal')
+  def test_line_height
+    assert_equal 20.9, @pdf.line_height(20.9)
+    assert_nil @pdf.line_height('')
+    assert_nil @pdf.line_height(nil)
   end
 
-  def test_text_letter_spacing_should_return_nil_when_value_is_auto
-    assert_nil @pdf.text_letter_spacing('auto')
+  def test_image_position_x
+    assert_equal :left, @pdf.image_position_x('left')
+    assert_equal :center, @pdf.image_position_x('center')
+    assert_equal :right, @pdf.image_position_x('right')
+    assert_equal :left, @pdf.image_position_x('')
+    assert_equal :left, @pdf.image_position_x(nil)
   end
 
-  def test_text_overflow
-    assert_equal @pdf.text_overflow('truncate'), :truncate
-    assert_equal @pdf.text_overflow('fit'), :shrink_to_fit
-    assert_equal @pdf.text_overflow('expand'), :expand
-    assert_equal @pdf.text_overflow(''), :truncate
+  def test_image_position_y
+    assert_equal :top, @pdf.image_position_y('top')
+    assert_equal :center, @pdf.image_position_y('middle')
+    assert_equal :bottom, @pdf.image_position_y('bottom')
+    assert_equal :top, @pdf.image_position_y('')
+    assert_equal :top, @pdf.image_position_y(nil)
   end
 end

data/test/unit/generator/pdf/document/graphics/test_basic.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+require 'test_helper'
+
+class Thinreports::Generator::PDF::Graphics::TestBasic < Minitest::Test
+  include Thinreports::TestHelper
+
+  def setup
+    @pdf = Thinreports::Generator::PDF::Document.new
+  end
+
+  def test_build_stroke_styles
+    style = {
+      stroke: 'red',
+      stroke_width: 2.0,
+      stroke_type: 'solid'
+    }
+
+    assert_equal(
+      {
+        color: 'ff0000',
+        width: 2.0,
+        dash: nil
+      },
+      @pdf.build_stroke_styles(style)
+    )
+
+    style_stroke_dashed = style.merge(stroke_type: 'dashed')
+    assert_equal [2, 2], @pdf.build_stroke_styles(style_stroke_dashed)[:dash]
+
+    style_stroke_dotted = style.merge(stroke_type: 'dotted')
+    assert_equal [1, 2], @pdf.build_stroke_styles(style_stroke_dotted)[:dash]
+
+    assert_nil @pdf.build_stroke_styles(stroke: nil, stroke_width: 1)
+    assert_nil @pdf.build_stroke_styles(stroke: 'none', stroke_width: 1)
+
+    assert_nil @pdf.build_stroke_styles(stroke_width: nil, stroke: 'red')
+    assert_nil @pdf.build_stroke_styles(stroke_width: 0, stroke: 'red')
+  end
+
+  def test_build_fill_styles
+    assert_equal({ color: 'ff0000' }, @pdf.build_fill_styles(fill: 'red'))
+    assert_nil @pdf.build_fill_styles(fill: nil)
+    assert_nil @pdf.build_fill_styles(fill: 'none')
+  end
+end

data/test/unit/generator/pdf/document/graphics/test_image.rb

@@ -58,11 +58,11 @@ class Thinreports::Generator::PDF::Graphics::TestImage < Minitest::Test
 
       image_id = Digest::MD5.hexdigest(base64_normal_image)
       assert_includes image_registry.keys, image_id
-      assert_equal normalized_image_path, image_registry[image_id]
+      assert_equal normalized_image_path, image_registry[image_id].path
 
       assert equal_image(data_file(image_file), normalized_image_path)
 
-      assert_same normalized_image_path,
+      assert_equal normalized_image_path,
         test_image.normalize_image_from_base64(image_type, base64_normal_image)
     end
   end
@@ -81,14 +81,14 @@ class Thinreports::Generator::PDF::Graphics::TestImage < Minitest::Test
 
     image_id = Digest::MD5.hexdigest(base64_palleted_png)
     assert_includes image_registry.keys, image_id
-    assert_equal normalized_image_path, image_registry[image_id]
+    assert_equal normalized_image_path, image_registry[image_id].path
 
     refute equal_image(data_file('image_pallete_based.png'), normalized_image_path)
 
     assert_not_palette_based_transparency_png File.read(normalized_image_path)
 
     # 2nd time
-    assert_same normalized_image_path,
+    assert_equal normalized_image_path,
       test_image.normalize_image_from_base64('image/png', base64_palleted_png)
     assert_equal 1, test_image.temp_image_registry.count
   end
@@ -130,7 +130,7 @@ class Thinreports::Generator::PDF::Graphics::TestImage < Minitest::Test
 
     # It should never called in 2nd time or subsequent.
     TestImage::PNGNormalizer.stubs(:load_file).never
-    assert_same normalized_image_path,
+    assert_equal normalized_image_path,
       test_image.normalize_image_from_file(original_image_path)
   end
 

data/test/unit/generator/pdf/document/test_font.rb

@@ -11,7 +11,6 @@ class Thinreports::Generator::PDF::TestFont < Minitest::Test
     # Reset font settings
     Thinreports.configure do |c|
       c.fallback_fonts = []
-      c.generator.pdf.eudc_fonts = []
     end
   end
 
@@ -22,7 +21,7 @@ class Thinreports::Generator::PDF::TestFont < Minitest::Test
       assert_equal font, pdf.font_families[name]
     end
 
-    Font::PRAWN_BUINTIN_FONT_ARIASES.each do |alias_font, original_font|
+    Font::PRAWN_BUINTIN_FONT_ALIASES.each do |alias_font, original_font|
       assert_equal pdf.font_families[alias_font],
                    pdf.font_families[original_font]
     end
@@ -33,37 +32,32 @@ class Thinreports::Generator::PDF::TestFont < Minitest::Test
   def test_setup_fonts_with_custom_fallback_fonts
     Thinreports.configure do |c|
       c.fallback_fonts = []
-      c.generator.pdf.eudc_fonts = []
     end
     assert_equal Font::DEFAULT_FALLBACK_FONTS,
                  document.pdf.fallback_fonts
 
     Thinreports.configure do |c|
       c.fallback_fonts = 'IPAGothic'
-      c.generator.pdf.eudc_fonts = []
     end
     assert_equal ['IPAGothic'] + Font::DEFAULT_FALLBACK_FONTS,
                  document.pdf.fallback_fonts
 
     Thinreports.configure do |c|
       c.fallback_fonts = ['IPAMincho']
-      c.generator.pdf.eudc_fonts = [data_file('font.ttf')]
     end
-    assert_equal ['Custom-fallback-font0', 'IPAMincho'] + Font::DEFAULT_FALLBACK_FONTS,
+    assert_equal ['IPAMincho'] + Font::DEFAULT_FALLBACK_FONTS,
                  document.pdf.fallback_fonts
 
     Thinreports.configure do |c|
-      c.generator.pdf.eudc_fonts = [data_file('font.ttf')]
-      c.fallback_fonts = ['IPAMincho', 'IPAMincho', data_file('font.ttf')]
+      c.fallback_fonts = ['IPAMincho', data_file('font.ttf')]
     end
-    assert_equal ['Custom-fallback-font0', 'IPAMincho'] + Font::DEFAULT_FALLBACK_FONTS,
+    assert_equal ['IPAMincho', 'Custom-fallback-font1'] + Font::DEFAULT_FALLBACK_FONTS,
                  document.pdf.fallback_fonts
   end
 
   def test_setup_fonts_with_unknown_custom_fallback_fonts
     Thinreports.configure do |c|
       c.fallback_fonts = ['/path/to/unknown.ttf']
-      c.generator.pdf.eudc_fonts = []
     end
 
     assert_raises Thinreports::Errors::FontFileNotFound do