thinreports 0.8.2 → 0.9.0

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

@@ -9,27 +9,14 @@ class Thinreports::Core::Shape::List::TestPage < Minitest::Test
   List = Thinreports::Core::Shape::List
 
   def create_report(&block)
-    new_report('layout_list.tlf', &block)
-  end
-
-  def create_report_for_checking_dispatched_event(event)
-    @target_event  = event
-    @is_dispatched = false
-
-    create_report do |r|
-      r.layout.config.list(:list) do |list|
-        list.events.on(event) { @is_dispatched = true }
-      end
-    end
-  end
-
-  def assert_dispatched_event
-    assert @is_dispatched, "The :#{@target_event} event was not dispatched."
+    report = Thinreports::Report.new layout: layout_file.path
+    block.call(report) if block_given?
+    report
   end
 
   def test_on_page_finalize_callback
     report = create_report
-    list = report.list(:list)
+    list = report.list
 
     counter = 0
     callback = -> { counter += 1 }
@@ -39,13 +26,13 @@ class Thinreports::Core::Shape::List::TestPage < Minitest::Test
     5.times { list.add_row }
     assert_equal 1, counter
 
-    report.generate
+    report.finalize
     assert_equal 2, counter
   end
 
   def test_on_page_footer_insert_callback
     report = create_report
-    list = report.list(:list)
+    list = report.list
 
     tester = 0
     callback = -> footer {
@@ -60,13 +47,13 @@ class Thinreports::Core::Shape::List::TestPage < Minitest::Test
     5.times { list.add_row }
     assert_equal 1, tester
 
-    report.generate
+    report.finalize
     assert_equal 2, tester
   end
 
   def test_on_footer_insert_callback
     report = create_report
-    list = report.list(:list)
+    list = report.list
 
     tester = 0
     callback = -> footer {
@@ -81,50 +68,12 @@ class Thinreports::Core::Shape::List::TestPage < Minitest::Test
     5.times { list.add_row }
     assert_equal 0, tester
 
-    report.generate
-    assert_equal 1, tester
-  end
-
-  def test_page_finalize_event_should_be_dispatched_when_page_break_is_called
-    report = create_report_for_checking_dispatched_event :page_finalize
-    report.start_new_page do
-      list(:list).page_break
-    end
-
-    assert_dispatched_event
-  end
-
-  def test_page_finalize_event_should_be_dispatched_when_list_was_overflowed
-    report = create_report_for_checking_dispatched_event :page_finalize
-    report.start_new_page do
-      6.times { list(:list).add_row }
-    end
-
-    assert_dispatched_event
-  end
-
-  def test_page_finalize_event_should_be_dispatched_when_a_new_page_is_created
-    report = create_report_for_checking_dispatched_event :page_finalize
-    report.start_new_page do
-      list(:list).add_row
-    end
-    report.start_new_page
-
-    assert_dispatched_event
-  end
-
-  def test_page_finalize_event_should_be_dispatched_when_report_is_finalized
-    report = create_report_for_checking_dispatched_event :page_finalize
-    report.start_new_page do
-      list(:list).add_row
-    end
     report.finalize
-
-    assert_dispatched_event
+    assert_equal 1, tester
   end
 
   def test_copy_should_properly_work_when_list_has_not_header
-    report = new_report('layout_list_noheader.tlf')
+    report = Thinreports::Report.new layout: layout_file(schema: LIST_NO_HEADER_SCHEMA_JSON).path
 
     10.times { report.list.add_row }
   rescue => e

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

@@ -20,7 +20,7 @@ class Thinreports::Core::Shape::List::TestPageState < Minitest::Test
   end
 
   def test_type_of?
-    assert_equal @state.type_of?(:list), true
+    assert_equal @state.type_of?('list'), true
   end
 
   def test_finalized!

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

@@ -5,41 +5,32 @@ require 'test_helper'
 class Thinreports::Core::Shape::List::TestSectionFormat < Minitest::Test
   include Thinreports::TestHelper
 
-  TEST_LIST_SECTION_FORMAT = {
-    "height" => 47.7,
-    "translate" => {"x" => 0, "y" => -64.2},
-    "svg" => {
-      "tag" => "g",
-      "content" => "<!---SHAPE{\"type\":\"s-tblock\",\"id\":\"t1\"}SHAPE--->" +
-                   "<!---SHAPE{\"type\":\"s-rect\",\"id\":\"r1\"}SHAPE--->" +
-                   "<!---SHAPE{\"type\":\"s-tblock\",\"id\":\"t2\"}SHAPE--->"
-    }
+  LIST_SECTION_FORMAT = {
+    'enabled' => true,
+    'height' => 47.7,
+    'translate' => { 'x' => 0, 'y' => -64.2 },
+    'items' => [
+      { 'type' => 'rect', 'id' => '' },
+      { 'type' => 'text-block', 'id' => 'text_block' }
+    ]
   }
 
   Shape = Thinreports::Core::Shape
+  List = Thinreports::Core::Shape::List
 
-  def test_build
-    shape_format = stub(id: 'mock')
+  def test_attribute_readers
+    format = List::SectionFormat.new(LIST_SECTION_FORMAT)
 
-    Shape::TextBlock::Format.expects(:build).returns(shape_format).times(2)
-    Shape::Basic::Format.expects(:build).returns(shape_format).times(1)
-
-    begin
-      build_format
-    rescue => e
-      flunk exception_details(e, 'Building failed.')
-    end
+    assert_equal 47.7, format.height
+    assert_equal 0, format.relative_left
+    assert_equal(-64.2, format.relative_top)
+    assert_equal true, format.display?
   end
 
-  def test_config_readers
-    format = Shape::List::SectionFormat.new(TEST_LIST_SECTION_FORMAT)
-
-    assert_equal format.height, 47.7
-    assert_equal format.relative_left, 0
-    assert_equal format.relative_top, -64.2
-  end
+  def test_initialize_items
+    format = List::SectionFormat.new(LIST_SECTION_FORMAT)
 
-  def build_format
-    Shape::List::SectionFormat.build(TEST_LIST_SECTION_FORMAT.dup)
+    assert_equal 1, format.shapes.count
+    assert_instance_of Shape::TextBlock::Format, format.shapes[:text_block]
   end
 end

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

@@ -5,19 +5,27 @@ require 'test_helper'
 class Thinreports::Core::Shape::List::TestSectionInterface < Minitest::Test
   include Thinreports::TestHelper
 
+  BASIC_SECTION_SCHEMA = {
+    'height' => 1.0,
+    'enabled' => true,
+    'items' => []
+  }
+
   # Alias
   List = Thinreports::Core::Shape::List
 
   def setup
-    @report = new_report 'layout_text1'
+    @report = Thinreports::Report.new layout: layout_file.path
   end
 
-  def create_interface(format_config = {})
+  def create_interface(extra_section_schema = {})
     parent = @report.start_new_page
 
-    List::SectionInterface.new parent,
-                               List::SectionFormat.new(format_config),
-                               :section
+    List::SectionInterface.new(
+      parent,
+      List::SectionFormat.new(BASIC_SECTION_SCHEMA.merge(extra_section_schema)),
+      :section
+    )
   end
 
   def test_internal_should_return_instance_of_SectionInternal
@@ -58,7 +66,7 @@ class Thinreports::Core::Shape::List::TestSectionInterface < Minitest::Test
     new_parent = @report.start_new_page
 
     %w( foo bar hoge ).each do |id|
-      list.manager.format.shapes[id.to_sym] = tblock::Format.new('type' => 's-tblock', 'id' => id)
+      list.manager.format.shapes[id.to_sym] = tblock::Format.new('type' => 'text-block', 'id' => id)
       list.item(id).value(10)
     end
 

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

@@ -5,13 +5,22 @@ require 'test_helper'
 class Thinreports::Core::Shape::List::TestSectionInternal < Minitest::Test
   include Thinreports::TestHelper
 
+  BASIC_SECTION_SCHEMA = {
+    'height' => 1.0,
+    'enabled' => true,
+    'items' => []
+  }
+
   # Alias
   List = Thinreports::Core::Shape::List
 
-  def create_internal(format_config = {})
-    report = new_report 'layout_text1'
+  def create_internal(extra_section_schema = {})
+    report = Thinreports::Report.new layout: layout_file.path
 
-    List::SectionInternal.new report, List::SectionFormat.new(format_config)
+    List::SectionInternal.new(
+      report,
+      List::SectionFormat.new(BASIC_SECTION_SCHEMA.merge(extra_section_schema))
+    )
   end
 
   def test_height_should_operate_as_delegator_of_format
@@ -24,16 +33,6 @@ class Thinreports::Core::Shape::List::TestSectionInternal < Minitest::Test
     assert_same list.relative_left, list.format.relative_left
   end
 
-  def test_relative_top_should_operate_as_delegator_of_format
-    list = create_internal('translate' => {'y' => 10})
-    assert_same list.relative_top, list.format.relative_top
-  end
-
-  def test_svg_tag_should_operate_as_delegator_of_format
-    list = create_internal('svg' => {'tag' => 'g'})
-    assert_same list.svg_tag, list.format.svg_tag
-  end
-
   def test_move_top_to_should_properly_set_value_to_states_as_relative_top
     list = create_internal
     list.move_top_to(200)
@@ -41,16 +40,11 @@ class Thinreports::Core::Shape::List::TestSectionInternal < Minitest::Test
     assert_equal list.states[:relative_top], 200
   end
 
-  def test_relative_position_should_return_Array_included_coordinates
-    list = create_internal('translate' => {'x' => 100, 'y' => 200})
-
-    assert_equal list.relative_position, [100, 200]
-  end
-
-  def test_Y_coordinate_which_relative_position_returns_should_be_calculated_position_with_relative_top_of_states
-    list = create_internal('translate' => {'x' => 100, 'y' => 100})
-    list.move_top_to(50)
+  def test_relative_top
+    list = create_internal('translate' => { 'y' => 100 })
+    assert_equal 0, list.relative_top
 
-    assert_equal list.relative_position.last, 150
+    list.move_top_to 50
+    assert_equal 50, list.relative_top
   end
 end

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

@@ -27,7 +27,7 @@ class Thinreports::Core::Shape::Manager::TestFormat < Minitest::Test
   def test_find_shape_should_return_format_of_shape_when_shape_is_found
     format = TestFormat.new({}) do |f|
       f.shapes[:foo] = Thinreports::Core::Shape::TextBlock::Format.new('id'   => 'foo',
-                                                                       'type' => 's-tblock')
+                                                                       'type' => 'text-block')
     end
     assert_equal format.find_shape(:foo).id, 'foo'
   end

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

@@ -4,168 +4,129 @@ require 'test_helper'
 
 class Thinreports::Core::Shape::Manager::TestInternal < Minitest::Test
   include Thinreports::TestHelper
-  
+
   # Alias
   Shape = Thinreports::Core::Shape
-  
+
   def create_shape_format(type, id, other_config = {})
     Shape::Format(type).new({'id'      => id,
                              'type'    => type,
-                             'display' => 'true'}.merge(other_config))
+                             'display' => true}.merge(other_config))
   end
-  
+
   def create_internal(&block)
-    report = new_report('layout_text1.tlf')
+    report = Thinreports::Report.new layout: layout_file.path
     format = report.layout.format
-    
-    # Add to default dummy shapes.
-    format.shapes[:t1] = create_shape_format('s-tblock', 't1', 'value' => '')
-    format.shapes[:t2] = create_shape_format('s-tblock', 't2', 'value' => '')
-    format.shapes[:ls] = create_shape_format('s-list', 'ls')
-    
+
     block.call(format) if block_given?
-    
+
     report.start_new_page.manager
   end
-  
+
   def test_find_format_should_return_format_with_the_specified_Symbol_id
-    assert_equal create_internal.find_format(:t1).id, 't1'
+    assert_equal create_internal.find_format(:text_block).id, 'text_block'
   end
-  
+
   def test_find_format_should_return_format_with_the_specified_String_id
-    assert_equal create_internal.find_format('t2').id, 't2'
+    assert_equal create_internal.find_format('text_block').id, 'text_block'
   end
-  
+
   def test_find_format_should_return_nil_when_format_with_specified_id_is_not_found
     assert_nil create_internal.find_format(:unknown)
   end
-  
+
   def test_find_item_should_return_shape_with_the_specified_id
-    assert_instance_of Shape::TextBlock::Interface, create_internal.find_item(:t1)
+    assert_instance_of Shape::TextBlock::Interface, create_internal.find_item(:text_block)
   end
-  
+
   def test_find_item_should_return_shape_in_shapes_registry_when_the_specified_shape_exists_in_registry
     internal = create_internal
-    internal.find_item(:t1)
-    
-    assert_same internal.find_item(:t1), internal.shapes[:t1]
+    internal.find_item(:text_block)
+
+    assert_same internal.find_item(:text_block), internal.shapes[:text_block]
   end
-  
+
   def test_find_item_should_return_shape_when_passing_in_the_specified_only_filter
     internal = create_internal
-    assert_equal internal.find_item(:t1, only: 's-tblock').id, 't1'
+    assert_equal internal.find_item(:text_block, only: 'text-block').id, 'text_block'
   end
-  
+
   def test_find_item_should_return_nil_when_not_passing_in_the_specified_only_filter
     internal = create_internal
-    assert_nil internal.find_item(:t1, only: 's-list')
+    assert_nil internal.find_item(:text_block, only: 'list')
   end
-  
+
   def test_find_item_should_return_shape_when_passing_in_the_specified_except_filter
     internal = create_internal
-    assert_equal internal.find_item(:ls, except: 's-tblock').id, 'ls'
+    assert_equal internal.find_item(:default, except: 'text-block').id, 'default'
   end
-  
+
   def test_find_item_should_return_shape_when_not_passing_in_the_specified_except_filter
     internal = create_internal
-    assert_nil internal.find_item(:ls, except: 's-list')
+    assert_nil internal.find_item(:default, except: 'list')
   end
-  
+
   def test_final_shape_should_return_nil_when_shape_is_not_found
     internal = create_internal
     assert_nil internal.final_shape(:unknown)
   end
-  
+
   def test_final_shape_should_return_nil_when_shape_is_stored_in_shapes_and_hidden
     internal = create_internal
-    internal.find_item(:t1).hide
-    
-    assert_nil internal.final_shape(:t1)
-  end
-  
-  def test_final_shape_should_return_shape_when_shape_is_stored_in_shapes_and_not_Block
-    internal = create_internal do |f|
-      f.shapes[:rect] = create_shape_format('s-rect', 'rect')
-    end
-    internal.find_item(:rect)
-    
-    assert_equal internal.final_shape(:rect).id, 'rect'
+    internal.find_item(:text_block).hide
+
+    assert_nil internal.final_shape(:text_block)
   end
-  
+
   def test_final_shape_should_return_shape_when_shape_is_stored_in_shapes_and_TextBlock_with_value
     internal = create_internal
-    internal.find_item(:t1).value('value')
-    
-    assert_equal internal.final_shape(:t1).id, 't1'
+    internal.find_item(:text_block).value('value')
+
+    assert_equal internal.final_shape(:text_block).id, 'text_block'
   end
-  
+
   def test_final_shape_should_return_nil_when_shape_is_stored_in_shapes_and_TextBlock_with_no_value
     internal = create_internal
-    internal.find_item(:t2)
-    
-    assert_nil internal.final_shape(:t2)
+    internal.find_item(:text_block)
+
+    assert_nil internal.final_shape(:text_block)
   end
-  
+
   def test_final_shape_should_return_shape_when_shape_is_stored_in_shapes_and_ImageBlock_with_src
-    internal = create_internal do |f|
-      f.shapes[:iblock] = create_shape_format('s-iblock', 'iblock')
-    end
-    internal.find_item(:iblock).src('/path/to/image.png')
-    
-    assert_equal internal.final_shape(:iblock).id, 'iblock'
+    internal = create_internal
+    internal.find_item(:image_block).src('/path/to/image.png')
+
+    assert_equal internal.final_shape(:image_block).id, 'image_block'
   end
-  
+
   def test_final_shape_should_return_nil_when_shape_is_stored_in_shapes_and_ImageBlock_with_no_src
-    internal = create_internal do |f|
-      f.shapes[:iblock] = create_shape_format('s-iblock', 'iblock')
-    end
-    
-    assert_nil internal.final_shape(:iblock)
+    internal = create_internal
+    assert_nil internal.final_shape(:image_block)
   end
-  
+
   def test_final_shape_should_return_nil_when_shape_isnot_stored_in_shapes_and_hidden
-    internal = create_internal do |f|
-      f.shapes[:t3] = create_shape_format('s-tblock', 't3', 'display' => 'false')
-    end
-    
-    assert_nil internal.final_shape(:t3)
+    assert_nil create_internal.final_shape(:text_block_hidden)
   end
-  
+
   def test_final_shape_should_return_shape_when_shape_isnot_stored_in_shapes_and_not_Block
-    internal = create_internal do |f|
-      f.shapes[:rect] = create_shape_format('s-rect', 'rect')
-    end
-    
-    assert_equal internal.final_shape(:rect).id, 'rect'
+    assert_equal create_internal.final_shape(:rect_with_id).id, 'rect_with_id'
   end
-  
+
   def test_final_shape_should_return_nil_when_shape_isnot_stored_in_shapes_and_ImageBlock
     internal = create_internal do |f|
-      f.shapes[:iblock] = create_shape_format('s-iblock', 'iblock')
+      f.shapes[:iblock] = create_shape_format('image-block', 'iblock')
     end
-    
+
     assert_nil internal.final_shape(:iblock)
   end
-  
-  def test_final_shape_should_return_shape_when_shape_isnot_stored_in_shapes_and_TextBlock_with_value
-    internal = create_internal do |f|
-      f.shapes[:t3] = create_shape_format('s-tblock', 't3', 'value' => 'default value')
-    end
-    
-    assert_equal internal.final_shape(:t3).id, 't3'
-  end
-  
+
   def test_final_shape_should_return_shape_when_shape_isnot_stored_in_shapes_and_TextBlock_with_reference
-    internal = create_internal do |f|
-      f.shapes[:t3] = create_shape_format('s-tblock', 't3', 'ref-id' => 't1')
-    end
-    
-    assert_equal internal.final_shape(:t3).id, 't3'
+    assert_equal create_internal.final_shape(:text_block_referenced).id, 'text_block_referenced'
   end
-  
+
   def test_final_shape_should_return_nil_when_shape_isnot_stored_in_shapes_and_TextBlock_with_no_value_no_reference
     internal = create_internal
-    
+
     assert_nil internal.final_shape(:t1)
   end
-end
+end