thinreports 0.9.1 → 0.11.0

data/test/unit/core/shape/text_block/formatter/test_datetime.rb

@@ -1,49 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::TextBlock::Formatter::TestDatetime < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Aliases
-  TextBlock = Thinreports::Core::Shape::TextBlock
-  Formatter = TextBlock::Formatter::Datetime
-
-  def setup
-    @datetime_format = '%Y/%m/%d %H:%M:%S'
-    @time = Time.now
-  end
-
-  def text_block_format(format = {})
-    default = {'base' => '', 'datetime' => {'format' => '%Y/%m/%d %H:%M:%S'}}
-    TextBlock::Format.new('format' => default.merge(format))
-  end
-
-  def test_apply_datetime_format_without_basic_format
-    formatter = Formatter.new(text_block_format)
-
-    assert_equal @time.strftime(@datetime_format),
-                 formatter.apply(@time)
-  end
-
-  def test_apply_datetime_format_with_basic_format
-    formatter = Formatter.new(text_block_format('base' => 'Now: {value}'))
-
-    assert_equal "Now: #{@time.strftime(@datetime_format)}",
-                 formatter.apply(@time)
-
-  end
-
-  def test_not_apply_datetime_format_and_return_raw_value
-    # When value is invalid
-    formatter = Formatter.new(text_block_format)
-
-    assert_same formatter.apply(val = 'invalid value'), val
-    assert_same formatter.apply(val = 123456), val
-
-    # When format is empty
-    formatter = Formatter.new(text_block_format('datetime' => {'format' => ''}))
-
-    assert_same formatter.apply(@time), @time
-  end
-end

data/test/unit/core/shape/text_block/formatter/test_number.rb

@@ -1,76 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::TextBlock::Formatter::TestNumber < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  Formatter = Thinreports::Core::Shape::TextBlock::Formatter::Number
-
-  def init_formatter(expect_formats)
-    format = stub({ format_base: '',
-                    format_number_precision: nil,
-                    format_number_delimiter: nil }.merge(expect_formats))
-    Formatter.new(format)
-  end
-
-  def test_apply_precision_formats
-    # When precision is 2
-    formatter = init_formatter(format_number_precision: 2)
-
-    assert_equal formatter.apply(1.005), '1.01'
-    assert_equal formatter.apply(1.004), '1.00'
-    assert_equal formatter.apply(1), '1.00'
-    # With String value
-    assert_equal formatter.apply('999.999'), '1000.00'
-    assert_equal formatter.apply('-999.999'), '-1000.00'
-    assert_equal formatter.apply('9'), '9.00'
-    # Cannot apply, Return the raw value
-    assert_equal formatter.apply('invalid value'), 'invalid value'
-
-    # When precision is 0
-    formatter = init_formatter(format_number_precision: 0)
-
-    assert_equal formatter.apply(1.5), '2'
-  end
-
-  def test_apply_precision_format_with_basic_format
-    formatter = init_formatter(format_base: '$ {value}',
-                               format_number_precision: 0)
-
-    assert_equal formatter.apply(199.5), '$ 200'
-  end
-
-  def test_apply_delimiter_formats
-    # When delimiter is ','
-    formatter = init_formatter(format_number_delimiter: ',')
-
-    assert_equal formatter.apply(1000000), '1,000,000'
-    assert_equal formatter.apply(-1000000), '-1,000,000'
-    assert_equal formatter.apply('1000.0'), '1,000.0'
-    assert_equal formatter.apply('-1000.0'), '-1,000.0'
-    # Cannot apply, Return the raw value
-    assert_equal formatter.apply('invalid value'), 'invalid value'
-
-    # When delimiter is whitespace
-    formatter = init_formatter(format_number_delimiter: ' ')
-
-    assert_equal formatter.apply(99999), '99 999'
-  end
-
-  def test_apply_delimiter_format_with_basic_format
-    formatter = init_formatter(format_base: '￥{value}',
-                               format_number_delimiter: ',')
-
-    assert_equal formatter.apply(199800), '￥199,800'
-  end
-
-  def test_apply_all_format
-    formatter = init_formatter(format_base: '-- {value} --',
-                               format_number_delimiter: ',',
-                               format_number_precision: 2)
-
-    assert_equal formatter.apply(95618.88567), '-- 95,618.89 --'
-  end
-end

data/test/unit/core/shape/text_block/formatter/test_padding.rb

@@ -1,77 +0,0 @@
-# coding: utf-8
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::TextBlock::Formatter::TestPadding < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  Formatter = Thinreports::Core::Shape::TextBlock::Formatter::Padding
-
-  def init_formatter(expect_formats)
-    format = stub({ format_base: nil,
-                    format_padding_length: 0,
-                    format_padding_char: nil,
-                    format_padding_rdir?: false }.merge(expect_formats))
-    Formatter.new(format)
-  end
-
-  def test_apply_padding_formats_with_left_direction
-    formatter = init_formatter(format_padding_length: 5,
-                               format_padding_char: '0')
-
-    assert_equal formatter.apply(1), '00001'
-    assert_equal formatter.apply('日本語'), '00日本語'
-  end
-
-  def test_apply_padding_formats_should_not_apply_when_character_length_is_short
-    formatter = init_formatter(format_padding_length: 5,
-                               format_padding_char: '0')
-
-    assert_equal formatter.apply('1234567'), '1234567'
-  end
-
-  def test_apply_padding_formats_with_right_direction
-    formatter = init_formatter(format_padding_length: 5,
-                               format_padding_char: '0',
-                               :format_padding_rdir?  => true)
-
-    assert_equal formatter.apply(123), '12300'
-  end
-
-  def test_apply_padding_format_with_basic_format
-    formatter = init_formatter(format_base: '[{value}]',
-                               format_padding_length: 10,
-                               format_padding_char: ' ')
-
-    assert_equal formatter.apply('ABC'), '[       ABC]'
-  end
-
-  def test_return_raw_value_when_length_is_0
-    formatter = init_formatter(format_padding_length: 0,
-                               format_padding_char: '0')
-
-    assert_same formatter.apply(v = 123), v
-
-    # But apply only basic format if have basic-format.
-    formatter = init_formatter(format_base: '<{value}>',
-                               format_padding_length: 0,
-                               format_padding_char: '0')
-
-    assert_equal formatter.apply(123), '<123>'
-  end
-
-  def test_return_raw_value_when_char_is_empty
-    formatter = init_formatter(format_padding_length: 10,
-                               format_padding_char: '')
-
-    assert_same formatter.apply(v = '1'), v
-
-    # But apply only basic format if have basic-format.
-    formatter = init_formatter(format_base: '<{value}>',
-                               format_padding_length: 0,
-                               format_padding_char: '0')
-
-    assert_equal formatter.apply('1'), '<1>'
-  end
-end

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

@@ -1,169 +0,0 @@
-# coding: utf-8
-
-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 @@
-# coding: utf-8
-
-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 @@
-# coding: utf-8
-
-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