thinreports 0.10.3 → 0.11.0

data/test/units/core/shape/page_number/test_format.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::PageNumber::TestFormat < Minitest::Test
-  include Thinreports::TestHelper
-
-  PAGE_NUMBER_FORMAT = {
-    'id' => '',
-    'type' => 'page-number',
-    'display' => true,
-    'x' => 100.0,
-    'y' => 200.0,
-    'width' => 300.0,
-    'height' => 400.0,
-    'format' => '{page} / {total}',
-    'target' => '',
-    'style' => {
-      'overflow' => 'truncate',
-      'letter-spacing' => 'normal',
-      'color' => '#000000',
-      'font-size' => 18,
-      'font-family' => ['Helvetica'],
-      'line-height' => 60,
-      'line-height-ratio' => 1.5,
-      'text-align' => 'left'
-    }
-  }
-
-  PageNumber = Thinreports::Core::Shape::PageNumber
-
-  def test_attribute_readers
-    format = PageNumber::Format.new(PAGE_NUMBER_FORMAT)
-
-    assert_equal 'truncate', format.overflow
-    assert_equal '', format.target
-    assert_equal '{page} / {total}', format.default_format
-  end
-
-  def test_id
-    format = PageNumber::Format.new(PAGE_NUMBER_FORMAT)
-    assert_match(/^__pageno\d+$/, format.id)
-
-    format = PageNumber::Format.new(PAGE_NUMBER_FORMAT.merge('id' => 'foo'))
-    assert_equal 'foo', format.id
-  end
-
-  def test_for_report?
-    format_for_report = PageNumber::Format.new(PAGE_NUMBER_FORMAT)
-    assert_equal true, format_for_report.for_report?
-
-    format_for_list = PageNumber::Format.new(PAGE_NUMBER_FORMAT.merge('target' => 'target_list_id'))
-    assert_equal false, format_for_list.for_report?
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::PageNumber::TestInterface < Minitest::Test
-  include Thinreports::TestHelper
-
-  PageNumber = Thinreports::Core::Shape::PageNumber
-
-  def create_pageno(format = {})
-    report = Thinreports::Report.new layout: layout_file.path
-    parent = report.start_new_page
-
-    PageNumber::Interface.new parent, PageNumber::Format.new(format)
-  end
-
-  def test_format
-    pageno = create_pageno 'format' => '{page}'
-
-    assert_equal pageno.format, '{page}'
-    pageno.format('{page} / {total}')
-    assert_equal pageno.format, '{page} / {total}'
-  end
-
-  def test_reset_format
-    pageno = create_pageno 'format' => '{page}'
-
-    pageno.format('-- {page} --')
-    pageno.reset_format
-
-    assert_equal pageno.format, '{page}'
-  end
-end

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::PageNumber::TestInternal < Minitest::Test
-  include Thinreports::TestHelper
-
-  PageNumber = Thinreports::Core::Shape::PageNumber
-
-  def setup
-    @report = Thinreports::Report.new layout: layout_file.path
-    @report.start_new_page
-  end
-
-  def init_pageno(format = {})
-    PageNumber::Internal.new(@report.page, PageNumber::Format.new(format))
-  end
-
-  def test_read_format
-    pageno = init_pageno('format' => 'Page {page}')
-
-    assert_equal pageno.read_format, 'Page {page}'
-  end
-
-  def test_write_format
-    pageno = init_pageno('format' => 'Page {page}')
-    pageno.write_format('{page}')
-
-    assert_equal pageno.read_format, '{page}'
-  end
-
-  def test_reset_format
-    pageno = init_pageno('format' => '{page}')
-    pageno.write_format('Page {page}')
-    pageno.reset_format
-
-    assert_equal pageno.read_format, '{page}'
-  end
-
-  def test_build_format
-    pageno = init_pageno('format' => '{page} / {total}')
-    assert_equal pageno.build_format(1, 100), '1 / 100'
-
-    pageno.write_format('{page}')
-    assert_equal pageno.build_format(1, 100), '1'
-
-    @report.start_page_number_from 5
-    pageno = init_pageno('format' => '{page} / {total}')
-    assert_equal pageno.build_format(1, 100), '5 / 104'
-
-    # if counted target is a List shape
-    pageno = init_pageno('format' => '{page} / {total}',
-                         'target' => 'list-id')
-    assert_equal pageno.build_format(1, 100), '1 / 100'
-  end
-
-  def test_type_of
-    pageno = init_pageno
-    assert pageno.type_of?('page-number')
-  end
-
-  def test_style
-    pageno = init_pageno
-    style = pageno.style
-
-    assert_instance_of PageNumber::Style, style
-    assert_same pageno.style, style
-  end
-
-  def test_for_report
-    pageno = init_pageno('target' => '')
-    assert_equal pageno.for_report?, true
-
-    pageno = init_pageno('target' => 'list-id')
-    assert_equal pageno.for_report?, false
-  end
-
-  def test_Style_class
-    refute_includes PageNumber::Style.accessible_styles, :valign
-  end
-end

data/test/units/core/shape/styles/test_base.rb

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Style::TestBase < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  Style = Thinreports::Core::Shape::Style::Base
-
-  def create_basic_format(base_style = {})
-    Thinreports::Core::Shape::Basic::Format.new('style' => base_style)
-  end
-
-  def create_style(base_style = {})
-    Style.new(create_basic_format(base_style))
-  end
-
-  def create_new_style(base_style = {}, &block)
-    klass = ::Class.new(Style, &block)
-    klass.new(create_basic_format(base_style))
-  end
-
-  def test_self_style_reader_should_properly_define_a_reading_method
-    style = create_new_style {
-      style_reader :hoge, 'foo'
-    }
-    assert_respond_to style, :hoge
-  end
-
-  def test_self_style_writer_should_properly_define_a_writing_method
-    style = create_new_style {
-      style_writer :hoge, 'foo'
-    }
-    assert_respond_to style, :hoge=
-  end
-
-  def test_self_style_accessor_should_properly_defines_reading_and_writing_methods
-    style = create_new_style {
-      style_accessor :hoge, 'foo'
-    }
-    assert_respond_to style, :hoge
-    assert_respond_to style, :hoge=
-  end
-
-  def test_self_style_accessible_should_add_specified_styles_to_the_accessible_styles_variable
-    style = create_new_style {
-      style_accessible :hoge
-      style_accessible :foo, :bar
-    }
-    assert_equal style.class.accessible_styles, [:hoge, :foo, :bar]
-  end
-
-  def test_self_accessible_styles_variable_should_not_be_shared_each_SubClasses
-    style1 = create_new_style {
-      style_accessible :hoge, :foo
-    }
-    assert_equal style1.class.accessible_styles, [:hoge, :foo]
-  end
-
-  def test_self_accessible_styles_variable_should_be_inherited_to_SubClass
-    super_klass = ::Class.new(Style) {
-      style_accessible :hoge, :foo
-    }
-    sub_klass = ::Class.new(super_klass)
-
-    assert_equal sub_klass.accessible_styles, super_klass.accessible_styles
-  end
-
-  def test_self_accessible_styles_variables_of_SubClass_should_not_interfere_mutually
-    super_klass = ::Class.new(Style) {
-      style_accessible :foo, :bar
-    }
-    sub_klass1 = ::Class.new(super_klass)
-    sub_klass2 = ::Class.new(super_klass)
-
-    refute_same sub_klass1.accessible_styles, sub_klass2.accessible_styles
-  end
-
-  def test_read_internal_style_should_return_style_of_styles_when_style_is_found_in_styles
-    style = create_style('hoge' => 'base_style')
-    style.write_internal_style('hoge', 'new_style')
-
-    assert_equal style.read_internal_style('hoge'), 'new_style'
-  end
-
-  def test_read_internal_style_should_return_style_of_base_when_style_is_not_found_in_styles
-    style = create_style('hoge' => 'base_style')
-    assert_equal style.read_internal_style('hoge'), 'base_style'
-  end
-
-  def test_write_internal_style_should_properly_set_style_to_the_styles
-    style = create_style({})
-    style.write_internal_style('hoge', 'hoge_style')
-
-    assert_equal style.styles['hoge'], 'hoge_style'
-  end
-
-  def test_has_style_asker_should_return_true_when_specified_style_method_is_accessible
-    style = create_new_style {
-      style_accessible :hoge, :foo
-    }
-    assert_equal style.has_style?(:foo), true
-  end
-
-  def test_has_style_asker_should_return_false_when_specified_style_method_is_not_accessible
-    style = create_new_style {
-      style_accessible :foo
-    }
-    assert_equal style.has_style?(:hoge), false
-  end
-
-  def test_verify_style_value_should_raise_when_value_is_not_included_in_list
-    assert_raises ArgumentError do
-      create_style.send(:verify_style_value, :invalid, [:hoge, :foo, :bar])
-    end
-  end
-
-  def test_verify_style_value_should_not_raise_when_value_is_found_in_list
-    create_style.send(:verify_style_value, :valid, [:hoge, :valid, :foo])
-  rescue ArgumentError
-    flunk
-  end
-
-  def test_reader_method_caller_should_properly_delegate_to_real_method
-    style = create_new_style('hoge_style' => 'hoge_style_value') {
-      style_accessible :hoge
-      style_reader :hoge, 'hoge_style'
-    }
-    assert_equal style[:hoge], 'hoge_style_value'
-  end
-
-  def test_writer_method_caller_should_properly_delegate_to_real_method
-    style = create_new_style {
-      style_accessible :hoge
-      style_accessor :hoge, 'hoge_style'
-    }
-    style[:hoge] = 'hoge_style_value'
-    assert_equal style.hoge, 'hoge_style_value'
-  end
-
-  def test_reader_method_caller_should_raise_when_style_is_not_accessible
-    assert_raises Thinreports::Errors::UnknownShapeStyleName do
-      create_new_style[:unknown]
-    end
-  end
-
-  def test_writer_method_caller_should_raise_when_style_is_not_accessible
-    assert_raises Thinreports::Errors::UnknownShapeStyleName do
-      create_new_style[:unknown] = 'value'
-    end
-  end
-
-  def test_copy_should_return_the_instance_of_the_same_class_as_itself
-    style = create_style
-    assert_instance_of Style, style.copy
-  end
-
-  def test_styles_of_copied_style_should_not_same_the_styles_of_original
-    style = create_style
-    refute_same style.styles, style.copy.styles
-  end
-
-  def test_styles_of_copied_style_should_equal_the_style_of_original
-    style = create_style
-    style.write_internal_style('foo', 'foo_value')
-    assert_equal style.styles['foo'], style.copy.styles['foo']
-  end
-
-  def test_identifier_should_return_empty_string_when_the_style_is_not_set
-    style = create_style
-    assert_equal style.identifier, ''
-  end
-
-  def test_identifier_should_return_the_same_as_hash_value_of_styles_when_style_is_set_something
-    style = create_style
-    style.write_internal_style('foo', 'foo_value')
-
-    assert_equal style.identifier, style.styles.hash.to_s
-  end
-
-  def test_finalized_styles
-    base_styles = { 'foo' => 'default foo', 'bar' => 'default bar' }
-
-    style = create_style(base_styles)
-    style.write_internal_style('foo', 'new foo')
-
-    assert_equal({ 'foo' => 'new foo', 'bar' => 'default bar' }, style.finalized_styles)
-    assert_same style.finalized_styles, style.finalized_styles
-  end
-end

data/test/units/core/shape/styles/test_basic.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Style::TestBasic < Minitest::Test
-  include Thinreports::TestHelper
-
-  def create_basic_style(format_config = {})
-    format = Thinreports::Core::Shape::Basic::Format.new(format_config)
-    Thinreports::Core::Shape::Style::Basic.new(format)
-  end
-
-  def test_visible_should_return_visibility_of_format_as_default
-    style = create_basic_style('display' => false)
-    assert_equal style.visible, false
-  end
-
-  def test_visible_should_properly_set_visibility
-    style = create_basic_style('display' => false)
-    style.visible = true
-
-    assert_equal style.visible, true
-  end
-end

data/test/units/core/shape/styles/test_graphic.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Style::TestGraphic < Minitest::Test
-  include Thinreports::TestHelper
-
-  def test_border_color
-    style = create_graphic_style('border-color' => 'red')
-    assert_equal 'red', style.border_color
-
-    style.border_color = '#ff0000'
-    assert_equal '#ff0000', style.styles['border-color']
-    assert_equal '#ff0000', style.border_color
-  end
-
-  def test_border_width
-    style = create_graphic_style('border-width' => 2.0)
-    assert_equal 2.0, style.border_width
-
-    style.border_width = 10.9
-    assert_equal 10.9, style.styles['border-width']
-    assert_equal 10.9, style.border_width
-  end
-
-  def test_fill_color
-    style = create_graphic_style('fill-color' => '#0000ff')
-    assert_equal '#0000ff', style.fill_color
-
-    style.fill_color = 'blue'
-    assert_equal 'blue', style.styles['fill-color']
-    assert_equal 'blue', style.fill_color
-  end
-
-  def test_border
-    style = create_graphic_style('border-color' => 'red', 'border-width' => 1)
-    assert_equal [1, 'red'], style.border
-
-    style.border = [2.0, '#ff0000']
-    assert_equal 2.0, style.styles['border-width']
-    assert_equal '#ff0000', style.styles['border-color']
-  end
-
-  private
-
-  def create_graphic_style(default_style = {})
-    format = Thinreports::Core::Shape::Basic::Format.new('style' => default_style)
-    Thinreports::Core::Shape::Style::Graphic.new(format)
-  end
-end

data/test/units/core/shape/styles/test_text.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Style::TestText < Minitest::Test
-  include Thinreports::TestHelper
-
-  def test_color
-    style = create_text_style('color' => 'red')
-    assert_equal 'red', style.color
-
-    style.color = 'blue'
-    assert_equal 'blue', style.styles['color']
-    assert_equal 'blue', style.color
-  end
-
-  def test_font_size
-    style = create_text_style('font-size' => 18.0)
-    assert_equal 18.0, style.font_size
-
-    style.font_size = 19
-    assert_equal 19, style.styles['font-size']
-    assert_equal 19, style.font_size
-  end
-
-  def test_initialize_font_style
-    default_font_style = ['bold', 'italic']
-    style = create_text_style('font-style' => default_font_style)
-
-    refute_same default_font_style, style.styles['font-style']
-    assert_equal default_font_style, style.styles['font-style']
-  end
-
-  def test_bold
-    style = create_text_style('font-style' => ['bold'])
-    assert_equal true, style.bold
-
-    style.bold = false
-    assert_equal [], style.styles['font-style']
-    assert_equal false, style.bold
-  end
-
-  def test_italic
-    style = create_text_style('font-style' => ['italic'])
-    assert_equal true, style.italic
-
-    style.italic = false
-    assert_equal [], style.styles['font-style']
-    assert_equal false, style.italic
-  end
-
-  def test_underline
-    style = create_text_style('font-style' => ['underline'])
-    assert_equal true, style.underline
-
-    style.underline = false
-    assert_equal [], style.styles['font-style']
-    assert_equal false, style.underline
-  end
-
-  def test_linethrough
-    style = create_text_style('font-style' => ['linethrough'])
-    assert_equal true, style.linethrough
-
-    style.linethrough = false
-    assert_equal [], style.styles['font-style']
-    assert_equal false, style.linethrough
-  end
-
-  def test_align
-    style = create_text_style('text-align' => 'center')
-    assert_equal :center, style.align
-
-    style.align = :right
-    assert_equal 'right', style.styles['text-align']
-    assert_equal :right, style.align
-  end
-
-  def test_valign
-    style = create_text_style('vertical-align' => '')
-    assert_equal :top, style.valign
-
-    style.valign = :middle
-    assert_equal 'middle', style.styles['vertical-align']
-    assert_equal :middle, style.valign
-
-    assert_deprecated { style.valign = :center }
-    assert_equal :middle, style.valign
-  end
-
-  private
-
-  def create_text_style(default_style = {})
-    format = Thinreports::Core::Shape::Text::Format.new('style' => default_style)
-    Thinreports::Core::Shape::Style::Text.new(format)
-  end
-end