thinreports 0.10.3 → 0.11.0

data/test/units/core/shape/text_block/test_formatter.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::TextBlock::TestFormatter < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  Formatter = Thinreports::Core::Shape::TextBlock::Formatter
-
-  def test_initialize_formatter_by_type
-    assert_instance_of Formatter::Basic,
-      Formatter.setup( stub(format_type: '') )
-
-    assert_instance_of Formatter::Number,
-      Formatter.setup( stub(format_type: 'number') )
-
-    assert_instance_of Formatter::Datetime,
-      Formatter.setup( stub(format_type: 'datetime') )
-
-    assert_instance_of Formatter::Padding,
-      Formatter.setup( stub(format_type: 'padding') )
-
-    assert_raises Thinreports::Errors::UnknownFormatterType do
-      Formatter.setup( stub(format_type: 'unknown') )
-    end
-  end
-end

data/test/units/core/shape/text_block/test_interface.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::TextBlock::TestInterface < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  TextBlock = Thinreports::Core::Shape::TextBlock
-
-  def create_interface(format_config = {})
-    report = Thinreports::Report.new layout: layout_file.path
-    parent = report.start_new_page
-
-    TextBlock::Interface.new parent, TextBlock::Format.new(format_config)
-  end
-
-  def test_format_enabled_asker_should_operate_as_delegator_of_internal
-    tblock = create_interface('format' => {'type' => 'datetime'})
-    assert_equal tblock.format_enabled?, tblock.internal.format_enabled?
-  end
-
-  def test_format_enabled_should_properly_set_value_to_internal
-    tblock = create_interface('format' => {'type' => 'number'})
-    tblock.format_enabled(false)
-
-    assert_equal tblock.internal.format_enabled?, false
-  end
-
-  def test_set_should_properly_set_a_value
-    tblock = create_interface
-    tblock.set(1000, visible: false)
-
-    assert_equal tblock.value, 1000
-  end
-
-  def test_set_should_properly_set_styles
-    tblock = create_interface
-    tblock.set(1000, color: '#ff0000',
-                     bold: true,
-                     italic: true)
-
-    assert_equal [tblock.style(:color),
-                  tblock.style(:bold),
-                  tblock.style(:italic)],
-                 ['#ff0000', true, true]
-  end
-
-  def test_value=
-    report = Thinreports::Report.new layout: layout_file.path
-    page = report.start_new_page
-
-    page.item(:text_block).value = 'foo'
-    assert_equal 'foo', page.item(:text_block).value
-
-    page.item(:text_block).value += 'bar'
-    assert_equal 'foobar', page.item(:text_block).value
-
-    page.item(:text_block).value = 1000
-    page.item(:text_block).value += 999
-    assert_equal 1999, page.item(:text_block).value
-  end
-end

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

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-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/units/core/test_shape.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-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/units/core/test_utils.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-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 [1, 2, 3], call_block_in([2, 1, 3], &proc { sort! })
-    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/units/generator/pdf/document/graphics/test_attributes.rb

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