thinreports 0.8.2 → 0.9.0

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

@@ -6,7 +6,7 @@ class Thinreports::Core::Shape::Base::TestInternal < Minitest::Test
   include Thinreports::TestHelper
 
   def setup
-    @report = Thinreports::Report.new layout: data_file('layout_text1.tlf')
+    @report = Thinreports::Report.new layout: layout_file.path
     @report.start_new_page
   end
 

data/test/unit/core/shape/basic/test_block_format.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+require 'test_helper'
+
+class Thinreports::Core::Shape::Basic::TestBlockFormat < Minitest::Test
+  include Thinreports::TestHelper
+
+  BLOCK_FORMAT = {
+    'value' => 'default value',
+    'x' => 100.0,
+    'y' => 200.0,
+    'width' => 300.0,
+    'height' => 400.0
+  }
+
+  Basic = Thinreports::Core::Shape::Basic
+
+  def test_attribute_readers
+    format = Basic::BlockFormat.new(BLOCK_FORMAT)
+
+    assert_equal 'default value', format.value
+  end
+end

data/test/unit/core/shape/basic/{test_basic_interface.rb → test_block_interface.rb}

@@ -8,7 +8,7 @@ class Thinreports::Core::Shape::Basic::TestBlockInterface < Minitest::Test
   Basic = Thinreports::Core::Shape::Basic
 
   def setup
-    report = Thinreports::Report.new layout: data_file('layout_text1')
+    report = Thinreports::Report.new layout: layout_file.path
     parent = report.start_new_page
 
     format = Basic::BlockFormat.new({})

data/test/unit/core/shape/basic/{test_basic_internal.rb → test_block_internal.rb}

@@ -7,11 +7,6 @@ class Thinreports::Core::Shape::Basic::TestBlockInternal < Minitest::Test
 
   Basic = Thinreports::Core::Shape::Basic
 
-  def test_box_should_return_value_of_format
-    internal = init_internal('box' => 'box of format')
-    assert_equal internal.box, 'box of format'
-  end
-
   def test_read_value_should_return_value_from_format
     internal = init_internal('value' => 'default value')
     assert_equal internal.read_value, 'default value'
@@ -46,11 +41,13 @@ class Thinreports::Core::Shape::Basic::TestBlockInternal < Minitest::Test
   end
 
   def test_type_of_asker_should_return_false_otherwise
-    assert_equal [:iblock, :tblock, :text, :list].all? {|t| !init_internal.type_of?(t)}, true
+    assert_equal %w( image-block text-block text list ).all? {|t| !init_internal.type_of?(t)}, true
   end
 
+  private
+
   def init_internal(format = {})
-    report = Thinreports::Report.new layout: data_file('layout_text1')
+    report = Thinreports::Report.new layout: layout_file.path
     parent = report.start_new_page
 
     Basic::BlockInternal.new(parent, Basic::BlockFormat.new(format))

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

@@ -5,55 +5,33 @@ require 'test_helper'
 class Thinreports::Core::Shape::Basic::TestFormat < Minitest::Test
   include Thinreports::TestHelper
 
-  TEST_BASIC_FORMAT = {
-    "type" => "s-rect",
-    "id" => "rect_1",
-    "display" => "true",
-    "svg" => {
-      "tag" => "rect",
-      "attrs" => {
-        "stroke" => "#000000",
-        "stroke-width" => "1",
-        "fill" => "#ff0000",
-        "fill-opacity" => "1",
-        "stroke-dasharray" => "none",
-        "rx" => "0",
-        "ry" => "0",
-        "width" => "196.1",
-        "height" => "135.1",
-        "x" => "85",
-        "y" => "82"
-      }
+  RECT_FORMAT = {
+    "id" => "",
+    "type" => "rect",
+    "x" => 100.0,
+    "y" => 200.0,
+    "width" => 300.0,
+    "height" => 400.0,
+    "description" => "Description for rect",
+    "display" => true,
+    "rx" => 1.0,
+    "ry" => 1.0,
+    "style" => {
+      "border-width" => 1,
+      "border-color" => "#000000",
+      "border-style" => "dashed",
+      "fill-color" => "#ff0000"
     }
   }
 
-  # Alias
-  Format = Thinreports::Core::Shape::Basic::Format
+  Basic = Thinreports::Core::Shape::Basic
 
-  def test_build_basic_format
-    build_basic_format
-  rescue => e
-    flunk exception_details(e, 'Building failed.')
-  end
-  
-  def test_basic_config_readers
-    format = Format.new(TEST_BASIC_FORMAT)
-    
-    assert_equal format.id, 'rect_1'
-    assert_equal format.type, 's-rect'
-    assert_equal format.svg_tag, 'rect'
-    assert_equal format.display?, true
-    assert_equal format.svg_attrs['stroke'], '#000000'
-    assert_equal format.svg_attrs['stroke-dasharray'], 'none'
-  end
-  
-  def test_display?
-    format = Format.new('display' => 'false')
-    
-    assert_equal format.display?, false
-  end
-  
-  def build_basic_format
-    Format.build(TEST_BASIC_FORMAT)
+  def test_attribute_readers
+    format = Basic::Format.new(RECT_FORMAT)
+
+    assert_equal '', format.id
+    assert_equal 'rect', format.type
+    assert_equal RECT_FORMAT['style'], format.style
+    assert_equal true, format.display?
   end
-end
+end

data/test/unit/core/shape/basic/test_interface.rb

@@ -9,7 +9,7 @@ class Thinreports::Core::Shape::Basic::TestInterface < Minitest::Test
   Basic = Thinreports::Core::Shape::Basic
 
   def create_interface(format_config = {})
-    report = Thinreports::Report.new layout: data_file('layout_text1')
+    report = Thinreports::Report.new layout: layout_file.path
     parent = report.start_new_page
 
     Basic::Interface.new parent, Basic::Format.new(format_config)
@@ -26,24 +26,24 @@ class Thinreports::Core::Shape::Basic::TestInterface < Minitest::Test
   end
 
   def test_type_should_operate_as_delegator_of_internal
-    basic = create_interface('type' => 's-rect')
+    basic = create_interface('type' => 'rect')
     assert_same basic.type, basic.internal.type
   end
 
   def test_visible_asker_should_return_result_with_reference_to_style_of_internal
-    basic = create_interface('display' => 'false')
+    basic = create_interface('display' => false)
     assert_equal basic.visible?, basic.internal.style.visible
   end
 
   def test_visible_should_properly_set_visibility_to_style_of_internal
-    basic = create_interface('display' => 'false')
+    basic = create_interface('display' => false)
     basic.visible(true)
 
     assert_equal basic.internal.style.visible, true
   end
 
   def test_style_should_operate_as_reader_when_one_argument_is_given
-    basic = create_interface('svg' => {'attrs' => {'fill' => '#ff0000'}})
+    basic = create_interface('style' => { 'fill-color' => '#ff0000' })
 
     assert_equal basic.style(:fill_color), '#ff0000'
   end

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

@@ -9,7 +9,7 @@ class Thinreports::Core::Shape::Basic::TestInternal < Minitest::Test
   Basic = Thinreports::Core::Shape::Basic
 
   def create_internal(format_config = {})
-    report = Thinreports::Report.new layout: data_file('layout_text1')
+    report = Thinreports::Report.new layout: layout_file.path
 
     Basic::Internal.new report.page, Basic::Format.new(format_config)
   end
@@ -19,13 +19,8 @@ class Thinreports::Core::Shape::Basic::TestInternal < Minitest::Test
     assert_same basic.id, basic.format.id
   end
 
-  def test_svg_tag_should_operate_as_delegator_of_format
-    basic = create_internal('svg' => {'tag' => 'rect'})
-    assert_same basic.svg_tag, basic.format.svg_tag
-  end
-
   def test_type_should_operate_as_delegator_of_format
-    basic = create_internal('type' => 's-ellipse')
+    basic = create_internal('type' => 'ellipse')
     assert_same basic.type, basic.format.type
   end
 
@@ -41,10 +36,10 @@ class Thinreports::Core::Shape::Basic::TestInternal < Minitest::Test
   def test_type_of_asker_should_return_true_when_the_specified_type_equal_self_type_name
     result = []
 
-    result << create_internal('type' => 's-rect').type_of?(:rect)
-    result << create_internal('type' => 's-ellipse').type_of?(:ellipse)
-    result << create_internal('type' => 's-line').type_of?(:line)
-    result << create_internal('type' => 's-image').type_of?(:image)
+    result << create_internal('type' => 'rect').type_of?('rect')
+    result << create_internal('type' => 'ellipse').type_of?('ellipse')
+    result << create_internal('type' => 'line').type_of?('line')
+    result << create_internal('type' => 'image').type_of?('image')
 
     assert_equal result.all?, true
   end

data/test/unit/core/shape/image_block/test_interface.rb

@@ -8,17 +8,17 @@ class Thinreports::Core::Shape::ImageBlock::TestInterface < Minitest::Test
   ImageBlock = Thinreports::Core::Shape::ImageBlock
 
   def setup
-    @report = new_report 'layout_block.tlf'
+    @report = Thinreports::Report.new layout: layout_file.path
     @page = @report.start_new_page
   end
 
   def test_src
-    @page.item(:image_block1).src('/path/to/image.png')
-    assert_equal '/path/to/image.png', @page.item(:image_block1).src
+    @page.item(:image_block).src('/path/to/image.png')
+    assert_equal '/path/to/image.png', @page.item(:image_block).src
   end
 
   def test_src=
-    @page.item(:image_block1).src = '/path/to/image.png'
-    assert_equal '/path/to/image.png', @page.item(:image_block1).src
+    @page.item(:image_block).src = '/path/to/image.png'
+    assert_equal '/path/to/image.png', @page.item(:image_block).src
   end
 end

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

@@ -15,7 +15,7 @@ class Thinreports::Core::Shape::ImageBlock::TestInternal < Minitest::Test
   end
 
   def test_type_of_asker_should_return_true_when_iblock_value_is_given
-    assert_equal create_internal.type_of?(:iblock), true
+    assert_equal create_internal.type_of?('image-block'), true
   end
 
   def test_type_of_asker_should_return_true_when_block_value_is_given
@@ -23,7 +23,7 @@ class Thinreports::Core::Shape::ImageBlock::TestInternal < Minitest::Test
   end
 
   def create_internal
-    report = new_report 'layout_text1'
+    report = Thinreports::Report.new layout: layout_file.path
     parent = report.start_new_page
 
     ImageBlock::Internal.new parent, ImageBlock::Format.new({})

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

@@ -5,65 +5,107 @@ require 'test_helper'
 class Thinreports::Core::Shape::List::TestFormat < Minitest::Test
   include Thinreports::TestHelper
 
-  TEST_LIST_FORMAT = {
-    "type" => "s-list",
-    "id" => "List",
-    "display" => "true",
-    "page-footer-enabled" => "true",
-    "footer-enabled" => "true",
-    "header-enabled" => "true",
-    "page-break" => "true",
-    "content-height" => 255,
-    "detail" => {},
-    "footer" => {},
-    "page-footer" => {},
-    "header" => {},
-    "svg" => {
-      "tag" => "g",
-      "attrs" => {}
+  LIST_FORMAT = {
+    'type' => 'list',
+    'id' => 'list',
+    'display' => true,
+    'x' => 10.0,
+    'y' => 20.0,
+    'width' => 30.0,
+    'height' => 40.0,
+    'content-height' => 255,
+    'auto-page-break' => true,
+    'header' => {
+      'enabled' => true,
+      'height' => 10.0,
+      'translate' => { 'x' => 210.0, 'y' => 310.0 },
+      'items' => []
+    },
+    'detail' => {
+      'height' => 20.0,
+      'translate' => { 'x' => 220.0, 'y' => 320.0 },
+      'items' => []
+    },
+    'page-footer' => {
+      'enabled' => true,
+      'height' => 30.0,
+      'translate' => { 'x' => 230.0, 'y' => 330.0 },
+      'items' => []
+    },
+    'footer' => {
+      'enabled' => false,
+      'height' => 40.0,
+      'translate' => { 'x' => 240.0, 'y' => 340.0 },
+      'items' => []
     }
   }
 
   List = Thinreports::Core::Shape::List
 
-  def test_build_when_all_sections_enabled
-    List::SectionFormat.expects(:build).returns({}).times(4)
+  def test_has_section?
+    format = List::Format.new(LIST_FORMAT)
 
-    begin
-      format = build_format
-    rescue => e
-      flunk exception_details(e, 'Building failed.')
-    end
+    assert_equal true, format.has_section?(:detail)
+    assert_equal true, format.has_section?(:page_footer)
+    assert_equal false, format.has_section?(:footer)
+  end
+
+  def test_section_height
+    format = List::Format.new(LIST_FORMAT)
+
+    assert_equal 10.0, format.section_height(:header)
+  end
+
+  def test_attribute_readers
+    format = List::Format.new(LIST_FORMAT)
 
-    assert_equal format.sections.size, 4
-    [:detail, :header, :footer, :page_footer].each do |sec|
-      assert_includes format.sections.keys, sec
-    end
+    assert_equal 255, format.height
+    assert_equal true, format.auto_page_break?
+    assert_equal true, format.has_header?
+    assert_equal true, format.has_page_footer?
+    assert_equal false, format.has_footer?
+    assert_equal 20.0, format.detail_height
+    assert_equal 30.0, format.page_footer_height
+    assert_equal 40.0, format.footer_height
+    assert_equal 10.0, format.header_height
   end
 
-  def test_build_when_page_footer_and_footer_disabled
-    List::SectionFormat.expects(:build).returns({}).times(2)
+  def test_section_base_position_top
+    page_footer_disabled = LIST_FORMAT
+
+    format = List::Format.new(page_footer_disabled)
+    assert_equal 310.0, format.section_base_position_top(:header)
+    assert_equal 320.0, format.section_base_position_top(:detail)
+    assert_equal 310.0, format.section_base_position_top(:page_footer)
+    assert_equal 0, format.section_base_position_top(:footer)
 
-    format = build_format('page-footer-enabled' => 'false',
-                          'footer-enabled'      => 'false')
+    format_footer_enabled = format_section_enabled(true, 'footer', LIST_FORMAT)
 
-    assert_equal format.sections.size, 2
-    [:detail, :header].each do |sec|
-      assert_includes format.sections.keys, sec
-    end
+    format = List::Format.new(format_footer_enabled)
+    assert_equal 290.0, format.section_base_position_top(:footer)
+
+    format_footer_enabld_and_page_footer_disabled = format_section_enabled(false, 'page-footer', format_footer_enabled)
+
+    format = List::Format.new(format_footer_enabld_and_page_footer_disabled)
+    assert_equal 320.0, format.section_base_position_top(:footer)
   end
 
-  def test_config_readers
-    format = List::Format.new(TEST_LIST_FORMAT)
+  def test_initialize_sections
+    format = List::Format.new(LIST_FORMAT)
+
+    assert_instance_of List::SectionFormat, format.sections[:header]
+    assert_instance_of List::SectionFormat, format.sections[:detail]
+    assert_instance_of List::SectionFormat, format.sections[:page_footer]
 
-    assert_equal format.height, 255
-    assert_equal format.auto_page_break?, true
-    assert_equal format.has_header?, true
-    assert_equal format.has_footer?, true
-    assert_equal format.has_page_footer?, true
+    assert_nil format.sections[:footer]
   end
 
-  def build_format(data = {})
-    List::Format.build(TEST_LIST_FORMAT.merge(data))
+  private
+
+  def format_section_enabled(enable, section, list_format)
+    section_format = list_format[section].dup
+    section_format['enabled'] = enable
+
+    list_format.merge(section => section_format)
   end
 end

data/test/unit/core/shape/list/test_manager.rb

@@ -9,16 +9,14 @@ class Thinreports::Core::Shape::List::TestManager < Minitest::Test
   List = Thinreports::Core::Shape::List
 
   def create_report(&block)
-    new_report('layout_list.tlf', &block)
+    report = Thinreports::Report.new layout: layout_file.path
+    block.call(report) if block_given?
+    report
   end
 
   def list_manager
     report = create_report {|r| r.start_new_page }
-    report.page.list(:list).manager
-  end
-
-  def test_config_should_return_the_instance_of_ListConfiguration
-    assert_same list_manager.config.class, List::Configuration
+    report.page.list.manager
   end
 
   def test_current_page_should_return_the_instance_of_ListPage
@@ -31,7 +29,7 @@ class Thinreports::Core::Shape::List::TestManager < Minitest::Test
 
   def test_switch_current_should_replace_own_current_page_property_by_the_given_page
     report = create_report {|r| r.start_new_page }
-    list   = report.page.list(:list)
+    list   = report.page.list
     new_page = List::Page.new(report.page, list.internal.format)
 
     list.manager.switch_current!(new_page)
@@ -41,7 +39,7 @@ class Thinreports::Core::Shape::List::TestManager < Minitest::Test
 
   def test_switch_current_should_replace_own_current_page_state_property_by_internal_property_of_the_given_page
     report = create_report {|r| r.start_new_page }
-    list   = report.page.list(:list)
+    list   = report.page.list
     new_page = List::Page.new(report.page, list.internal.format)
 
     list.manager.switch_current!(new_page)
@@ -51,72 +49,19 @@ class Thinreports::Core::Shape::List::TestManager < Minitest::Test
 
   def test_switch_current_should_return_the_self
     report = create_report {|r| r.start_new_page }
-    list   = report.page.list(:list)
+    list   = report.page.list
     new_page = List::Page.new(report.page, list.internal.format)
 
     assert_same list.manager.switch_current!(new_page), list.manager
   end
 
-  def test_finalize_page_should_dispatch_page_finalize_event
-    flag = false
-
-    report = create_report do |r|
-      r.layout.config.list(:list) do
-        events.on :page_finalize do
-          flag = true
-        end
-      end
-    end
-
-    report.start_new_page do |page|
-      page.list(:list).manager.finalize_page
-    end
-
-    assert flag, 'The :page_finalize event was not dispatched.'
-  end
-
-  def test_page_property_which_dispatcher_of_finalize_page_event_should_return_the_current_page
-    page_used_in_event = nil
-
-    report = create_report do |r|
-      r.layout.config.list(:list) do
-        events.on :page_finalize do |e|
-          page_used_in_event = e.page
-        end
-      end
-    end
-
-    current_page = report.start_new_page
-    current_page.list(:list).manager.finalize_page
-
-    assert_same page_used_in_event, current_page
-  end
-
-  def test_list_property_which_dispatcher_of_finalize_event_should_return_the_current_page_of_list
-    list_used_in_event = nil
-
-    report = create_report do |r|
-      r.layout.config.list(:list) do
-        events.on :page_finalize do |e|
-          list_used_in_event = e.list
-        end
-      end
-    end
-
-    report.start_new_page
-    current_list = report.page.list(:list)
-    current_list.manager.finalize_page
-
-    assert_same list_used_in_event, current_list
-  end
-
   def test_page_count
     report = create_report
     assert_equal report.page_count, 0
 
-    report.list(:list).page_break
-    report.list(:list).page_break
+    report.list.page_break
+    report.list.page_break
 
-    assert_equal report.list(:list).manager.page_count, 2
+    assert_equal report.list.manager.page_count, 2
   end
 end