thinreports 0.10.2 → 0.12.1

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

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::TextBlock::TestFormat < Minitest::Test
-  include Thinreports::TestHelper
-
-  TEXT_BLOCK_FORMAT = {
-    'id' => 'text_block',
-    'reference-id' => 'referenced_text_block',
-    'type' => 'text-block',
-    'display' => true,
-    'multiple-line' => false,
-    'x' => 100.0,
-    'y' => 200.0,
-    'width' => 300.0,
-    'height' => 400.0,
-    'value' => 'default value',
-    'format' => {
-      'base' => 'Price: {value}',
-      'type' => 'number',
-      'number' => {
-        'delimiter' => ',',
-        'precision' => 1
-      }
-    },
-    'description' => 'Description for item',
-    'style' => {
-      'word-wrap' => 'break-word',
-      'overflow' => 'truncate',
-      'text-align' => 'right',
-      'vertical-align' => 'middle',
-      'color' => '#000000',
-      'font-size' => 12,
-      'font-family' => ['Helvetica'],
-      'font-style' => ['bold', 'italic', 'linethrough', 'underline'],
-      'letter-spacing' => 'normal',
-      'line-height' => 30,
-      'line-height-ratio' => 1.5
-    }
-  }
-
-  TextBlock = Thinreports::Core::Shape::TextBlock
-
-  def test_attribute_readers
-    format = TextBlock::Format.new(TEXT_BLOCK_FORMAT)
-
-    assert_equal 'referenced_text_block', format.ref_id
-    assert_equal 'middle', format.valign
-    assert_equal 'truncate', format.overflow
-    assert_equal 30, format.line_height
-    assert_equal false, format.multiple?
-    assert_equal 'Price: {value}', format.format_base
-    assert_equal 'number', format.format_type
-  end
-
-  def test_has_reference?
-    format_has_reference = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge('reference-id' => 'other'))
-    assert_equal true, format_has_reference.has_reference?
-
-    format_has_no_reference = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge('reference-id' => ''))
-    assert_equal false, format_has_no_reference.has_reference?
-  end
-
-  def test_has_format?
-    format_has_text_format = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => { 'type' => 'datetime' }
-    ))
-    assert_equal true, format_has_text_format.has_format?
-
-    format_has_no_text_format = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => { 'type' => '' }
-    ))
-    assert_equal false, format_has_no_text_format.has_format?
-  end
-
-  def test_number_format_attribute_readers
-    format = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => {
-        'type' => 'number',
-        'number' => {
-          'delimiter' => ',',
-          'precision' => 1
-        }
-      }
-    ))
-    assert_equal ',', format.format_number_delimiter
-    assert_equal 1, format.format_number_precision
-  end
-
-  def test_datetime_format_attribute_readers
-    format = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => {
-        'type' => 'datetime',
-        'datetime' => {
-          'format' => '%Y-%m-%d'
-        }
-      }
-    ))
-    assert_equal '%Y-%m-%d', format.format_datetime_format
-  end
-
-  def test_padding_format_attribute_readers
-    format = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => {
-        'type' => 'padding',
-        'padding' => {
-          'char' => '0',
-          'length' => 10,
-          'direction' => 'L'
-        }
-      }
-    ))
-    assert_equal '0', format.format_padding_char
-    assert_equal 'L', format.format_padding_dir
-  end
-
-  def test_format_padding_length
-    format = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => {
-        'type' => 'padding',
-        'padding' => {
-          'char' => '0',
-          'length' => 10,
-          'direction' => 'L'
-        }
-      }
-    ))
-    assert_equal 10, format.format_padding_length
-
-    format = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => {
-        'type' => 'padding',
-        'padding' => {
-          'char' => '0',
-          'length' => '',
-          'direction' => 'L'
-        }
-      }
-    ))
-    assert_equal 0, format.format_padding_length
-  end
-
-  def test_format_padding_rdir?
-    format_direction_left = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => {
-        'type' => 'padding',
-        'padding' => {
-          'char' => '0',
-          'length' => 10,
-          'direction' => 'L'
-        }
-      }
-    ))
-    assert_equal false, format_direction_left.format_padding_rdir?
-
-    format_direction_right = TextBlock::Format.new(TEXT_BLOCK_FORMAT.merge(
-      'format' => {
-        'type' => 'padding',
-        'padding' => {
-          'char' => '0',
-          'length' => 10,
-          'direction' => 'R'
-        }
-      }
-    ))
-    assert_equal true, format_direction_right.format_padding_rdir?
-  end
-end

data/test/unit/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/unit/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/unit/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/unit/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/unit/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/unit/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

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

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