thinreports 0.9.1 → 0.11.0

data/test/unit/core/shape/text_block/test_internal.rb

@@ -1,128 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::TextBlock::TestInternal < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  TextBlock = Thinreports::Core::Shape::TextBlock
-
-  def create_parent
-    report = Thinreports::Report.new layout: layout_file.path
-    report.start_new_page do |page|
-      # Add to force TextBlock shape.
-      page.manager.format.shapes[:foo] = TextBlock::Format.new('type' => 'text-block',
-                                                               'id'   => 'foo')
-      # Set value to TextBlock.
-      page.item(:foo).value('foo value')
-    end
-  end
-
-  def create_internal(format_config = {})
-    TextBlock::Internal.new(create_parent, TextBlock::Format.new(format_config))
-  end
-
-  def test_multiple_asker_should_operate_as_delegator_of_format
-    tblock = create_internal('multiple-line' => true)
-    assert_equal tblock.multiple?, tblock.format.multiple?
-  end
-
-  def test_style_should_return_the_instance_of_Style_Text
-    assert_instance_of Thinreports::Core::Shape::Style::Text, create_internal.style
-  end
-
-  def test_read_value_should_return_the_format_value_as_default
-    tblock = create_internal('value' => 'default value')
-    assert_equal tblock.read_value, 'default value'
-  end
-
-  def test_read_value_should_return_the_value_of_referenced_shape
-    tblock = create_internal('reference-id' => 'foo', 'value' => '')
-    assert_equal tblock.read_value, 'foo value'
-  end
-
-  def test_read_value_should_return_the_value_stored_in_states
-    tblock = create_internal
-    tblock.states[:value] = 'value in states'
-
-    assert_equal tblock.read_value, 'value in states'
-  end
-
-  def test_write_value_should_properly_set_the_specified_value_to_states
-    tblock = create_internal
-    tblock.write_value(1000)
-
-    assert_equal tblock.states[:value], 1000
-  end
-
-  def test_write_value_should_show_warnings_when_tblock_has_reference
-    tblock = create_internal('id' => 'bar', 'reference-id' => 'foo')
-    _out, err = capture_io do
-      tblock.write_value('value')
-    end
-    assert_equal err.chomp, 'The set value was not saved, ' +
-                            "Because 'bar' has reference to 'foo'."
-  end
-
-  def test_real_value_should_return_the_formatted_value_when_tblock_has_any_format
-    tblock = create_internal('format' => {'type'     => 'datetime',
-                                          'datetime' => {'format' => '%Y/%m/%d'}})
-    tblock.write_value(value = Time.now)
-
-    assert_equal tblock.real_value, value.strftime('%Y/%m/%d')
-  end
-
-  def test_real_value_should_return_the_raw_value_when_tblock_has_no_format
-    tblock = create_internal
-    tblock.write_value('any value')
-
-    assert_equal tblock.real_value, 'any value'
-  end
-
-  def test_format_enabled_should_properly_set_value_to_states_as_format_enabled
-    tblock = create_internal
-    tblock.format_enabled(false)
-
-    assert_equal tblock.states[:format_enabled], false
-  end
-
-  def test_format_enabled_asker_should_return_true_when_format_has_any_type
-    tblock = create_internal('format' => {'type' => 'datetime'})
-
-    assert_equal tblock.format_enabled?, true
-  end
-
-  def test_format_enabled_asker_should_return_true_when_base_of_format_has_any_value
-    tblock = create_internal('format' => {'base' => '{value}'})
-
-    assert_equal tblock.format_enabled?, true
-  end
-
-  def test_format_enabled_asker_should_return_false_when_format_has_no_type_and_base_has_not_value
-    assert_equal create_internal.format_enabled?, false
-  end
-
-  def test_format_enabled_asker_should_return_false_constantly_when_tblock_is_multiple_mode
-    tblock = create_internal('multiple-line' => true,
-                             'format' => {'base' => '{value}',
-                                          'type' => 'number'})
-    tblock.format_enabled(true)
-
-    assert_equal tblock.format_enabled?, false
-  end
-
-  def test_type_of_asker_should_return_true_when_value_is_tblock
-    assert_equal create_internal.type_of?('text-block'), true
-  end
-
-  def test_type_of_asker_should_return_true_when_value_is_block
-    assert_equal create_internal.type_of?(:block), true
-  end
-
-  def test_formatter_should_return_instance_of_FormatterBasic_when_format_is_enable
-    tblock = create_internal('format' => {'type' => 'datetime'})
-
-    assert_kind_of TextBlock::Formatter::Basic, tblock.send(:formatter)
-  end
-end

data/test/unit/core/test_shape.rb

@@ -1,52 +0,0 @@
-# coding: utf-8
-
-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('page-number'), ShapeModule::PageNumber
-  end
-
-  def test_find_by_type_should_return_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('text-block'), ShapeModule::TextBlock
-  end
-
-  def test_find_by_type_should_return_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('text'), ShapeModule::Text
-  end
-
-  def test_find_by_type_should_return_Basic_as_Image
-    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('line'), ShapeModule::Basic
-  end
-
-  def test_find_by_type_should_return_Basic_as_Rect
-    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('ellipse'), ShapeModule::Basic
-  end
-
-  def test_find_by_type_should_raise
-    assert_raises Thinreports::Errors::UnknownShapeType do
-      ShapeModule.find_by_type('unknown')
-    end
-  end
-end

data/test/unit/core/test_utils.rb

@@ -1,68 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Core::TestShape < Minitest::Test
-  include Thinreports::TestHelper
-  include Thinreports::Utils
-
-  def test_call_block_in
-    expected = '123'
-    assert_same expected, call_block_in(expected)
-
-    assert_equal '321', call_block_in('123', &proc { reverse! })
-    assert_equal [1, 2, 3], call_block_in([2, 1, 3], &proc { |a| a.sort! })
-  end
-
-  def test_deep_copy_in_unsupported_object
-    [123, nil, Struct.new(:foo).new].each do |unsupported_value|
-      assert_raises ArgumentError do
-        deep_copy(unsupported_value)
-      end
-    end
-  end
-
-  def test_deep_copy_in_Array
-    src = ['string', Time.now]
-    dup = deep_copy(src)
-
-    refute_same dup, src
-
-    src.each_with_index do |e, i|
-      assert_equal dup[i], e
-      refute_same dup[i], e
-    end
-  end
-
-  def test_deep_copy_in_Hash
-    src = { a: 'string', b: Time.now }
-    dup = deep_copy(src)
-
-    refute_same dup, src
-
-    src.each do |k, v|
-      assert_equal dup[k], v
-      refute_same dup[k], v
-    end
-  end
-
-  def test_blank_value_in_String
-    ["", ''].each do |val|
-      assert_equal true, blank_value?(val)
-    end
-
-    [' ', '　', 'abc', 'あいう'].each do |val|
-      assert_equal false, blank_value?(val)
-    end
-  end
-
-  def test_blank_value_in_NilClass
-    assert_equal true, blank_value?(nil)
-  end
-
-  def test_blank_value_in_other_classes
-    [0, 1, -1, 9.99, true, false, Time.now].each do |val|
-      assert_equal false, blank_value?(val)
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Generator::PDF::Graphics::TestAttributes < Minitest::Test
-  include Thinreports::TestHelper
-
-  def setup
-    @pdf = Thinreports::Generator::PDF::Document.new
-  end
-
-  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_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_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_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_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_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

@@ -1,45 +0,0 @@
-# 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

@@ -1,150 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-require 'base64'
-require 'digest/md5'
-
-class Thinreports::Generator::PDF::Graphics::TestImage < Minitest::Test
-  include Thinreports::TestHelper
-
-  class TestImage
-    include Thinreports::Generator::PDF::Graphics
-  end
-
-  def test_normalize_image_from_base64_in_disabled
-    Thinreports.config.convert_palleted_transparency_png = false
-
-    test_image = TestImage.new
-    base64_image = Base64.encode64(read_data_file('image_normal.png'))
-
-    # Should not be normalized
-    TestImage::PNGNormalizer.stubs(:load_blob).never
-    test_image.normalize_image_from_base64('image/png', base64_image)
-
-    image_registry = test_image.temp_image_registry
-    assert_equal 1, image_registry.count
-  end
-
-  def test_normalize_image_from_file_in_disabled
-    Thinreports.config.convert_palleted_transparency_png = false
-
-    original_image_path = data_file('image_pallete_based.png')
-
-    test_image = TestImage.new
-    returned_image_path = test_image.normalize_image_from_file(original_image_path)
-
-    # Should not be normalized
-    assert_empty test_image.temp_image_registry
-    assert_same original_image_path, returned_image_path
-  end
-
-  def test_normalize_image_from_base64_with_normal_images
-    Thinreports.config.convert_palleted_transparency_png = true
-
-    [
-      ['image/png',  'image_normal.png'],
-      ['image/jpeg', 'image_normal.jpg']
-    ]
-    .each do |(image_type, image_file)|
-      base64_normal_image = Base64.encode64(read_data_file(image_file))
-
-      test_image = TestImage.new
-
-      normalized_image_path = test_image.normalize_image_from_base64(image_type, base64_normal_image)
-
-      image_registry = test_image.temp_image_registry
-      assert_equal 1, image_registry.count
-
-      image_id = Digest::MD5.hexdigest(base64_normal_image)
-      assert_includes image_registry.keys, image_id
-      assert_equal normalized_image_path, image_registry[image_id].path
-
-      assert equal_image(data_file(image_file), normalized_image_path)
-
-      assert_equal normalized_image_path,
-        test_image.normalize_image_from_base64(image_type, base64_normal_image)
-    end
-  end
-
-  def test_normalize_image_from_base64_with_palette_transparency_png
-    Thinreports.config.convert_palleted_transparency_png = true
-
-    base64_palleted_png = Base64.encode64(read_data_file('image_pallete_based.png'))
-
-    test_image = TestImage.new
-
-    normalized_image_path = test_image.normalize_image_from_base64('image/png', base64_palleted_png)
-
-    image_registry = test_image.temp_image_registry
-    assert_equal 1, image_registry.count
-
-    image_id = Digest::MD5.hexdigest(base64_palleted_png)
-    assert_includes image_registry.keys, 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_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
-
-  def test_normalize_image_from_file_with_normal_images
-    Thinreports.config.convert_palleted_transparency_png = true
-
-    [
-      data_file('image_normal.png'),
-      data_file('iamge_normal.jpg'),
-      data_file('image_normal_png_noext'),
-      data_file('image_normal_jpg_noext')
-    ]
-    .each do |original_image_path|
-      test_image = TestImage.new
-      image_path = test_image.normalize_image_from_file(original_image_path)
-
-      assert_equal original_image_path, image_path
-      assert_empty test_image.temp_image_registry
-    end
-  end
-
-  def test_normalize_image_from_file_with_palette_transparency_png
-    Thinreports.config.convert_palleted_transparency_png = true
-
-    original_image_path = data_file('image_pallete_based.png')
-
-    test_image = TestImage.new
-
-    normalized_image_path = test_image.normalize_image_from_file(original_image_path)
-    image_registry = test_image.temp_image_registry
-
-    assert_equal 1, image_registry.count
-    assert_includes image_registry.keys, original_image_path
-
-    refute equal_image(original_image_path, normalized_image_path)
-
-    assert_not_palette_based_transparency_png File.read(normalized_image_path)
-
-    # It should never called in 2nd time or subsequent.
-    TestImage::PNGNormalizer.stubs(:load_file).never
-    assert_equal normalized_image_path,
-      test_image.normalize_image_from_file(original_image_path)
-  end
-
-  def assert_not_palette_based_transparency_png(data)
-    image_data = ChunkyPNG::Image.from_blob(data)
-    datastream = ChunkyPNG::Datastream.from_blob(data)
-
-    assert_equal ChunkyPNG::COLOR_INDEXED, image_data.palette.best_color_settings.first
-    assert_equal nil, datastream.transparency_chunk
-  end
-
-  def equal_image(expect_path, actual_path)
-    expect_image = File.binread(expect_path)
-    actual_image = File.binread(actual_path)
-    expect_image == actual_image
-  end
-end