thinreports 0.7.7 → 0.8.0

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

@@ -1,28 +1,28 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::List::TestPageState < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::List::TestPageState < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  List = ThinReports::Core::Shape::List
-  
+  List = Thinreports::Core::Shape::List
+
   def setup
-    parent = flexmock('parent')
-    format = flexmock('format')
-    
+    parent = mock('parent')
+    format = mock('format')
+
     @state = List::PageState.new(parent, format)
   end
-  
+
   def test_alias_class
     assert_same List::PageState, List::Internal
   end
-  
+
   def test_type_of?
     assert_equal @state.type_of?(:list), true
   end
-  
+
   def test_finalized!
     assert_equal @state.finalized?, false
     @state.finalized!

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

@@ -1,10 +1,10 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::List::TestSectionFormat < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::List::TestSectionFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   TEST_LIST_SECTION_FORMAT = {
     "height" => 47.7,
     "translate" => {"x" => 0, "y" => -64.2},
@@ -15,32 +15,31 @@ class ThinReports::Core::Shape::List::TestSectionFormat < MiniTest::Unit::TestCa
                    "<!---SHAPE{\"type\":\"s-tblock\",\"id\":\"t2\"}SHAPE--->"
     }
   }
-  
-  Shape = ThinReports::Core::Shape
-  
+
+  Shape = Thinreports::Core::Shape
+
   def test_build
-    shape_format = flexmock(:id => 'mock')
-    
-    flexmock(Shape::TextBlock::Format).
-        should_receive(:build).times(2).and_return(shape_format)
-    flexmock(Shape::Basic::Format).
-        should_receive(:build).times(1).and_return(shape_format)
+    shape_format = stub(id: 'mock')
+
+    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
   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 build_format
     Shape::List::SectionFormat.build(TEST_LIST_SECTION_FORMAT.dup)
   end
-end
+end

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

@@ -1,59 +1,67 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::List::TestSectionInterface < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::List::TestSectionInterface < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  List = ThinReports::Core::Shape::List
-  
+  List = Thinreports::Core::Shape::List
+
+  def setup
+    @report = new_report 'layout_text1'
+  end
+
   def create_interface(format_config = {})
-    List::SectionInterface.new(flexmock('parent'),
+    parent = @report.start_new_page
+
+    List::SectionInterface.new parent,
                                List::SectionFormat.new(format_config),
-                               :section)
+                               :section
   end
-  
+
   def test_internal_should_return_instance_of_SectionInternal
     assert_instance_of List::SectionInternal, create_interface.internal
   end
-  
+
   def test_initialize_should_properly_set_the_specified_section_name_to_internal
     assert_equal create_interface.internal.section_name, :section
   end
-  
+
   def test_initialize_should_properly_initialize_manager
-    assert_instance_of ThinReports::Core::Shape::Manager::Internal,
+    assert_instance_of Thinreports::Core::Shape::Manager::Internal,
                        create_interface.manager
   end
-  
+
   def test_height_should_operate_as_delegator_of_internal
     list = create_interface('height' => 100)
     assert_same list.height, list.internal.height
   end
-  
+
   def test_copied_interface_should_succeed_an_section_name_of_original
     list = create_interface
-    assert_same list.copy(flexmock('new_parent')).internal.section_name,
+    new_parent = @report.start_new_page
+
+    assert_same list.copy(new_parent).internal.section_name,
                 list.internal.section_name
   end
-  
+
   def test_copied_interface_should_have_all_the_copies_of_Shape_which_original_holds
     list = create_interface
     copied_list(list) do |new_list|
       assert_equal new_list.manager.shapes.size, 3
     end
   end
-  
+
   def copied_list(list, &block)
-    tblock     = ThinReports::Core::Shape::TextBlock
-    new_parent = flexmock('new_parent')
-    
+    tblock     = Thinreports::Core::Shape::TextBlock
+    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.item(id).value(10)
     end
-    
+
     block.call(list.copy(new_parent))
   end
-end
+end

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

@@ -1,55 +1,57 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::List::TestSectionInternal < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::List::TestSectionInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  List = ThinReports::Core::Shape::List
-  
+  List = Thinreports::Core::Shape::List
+
   def create_internal(format_config = {})
-    List::SectionInternal.new(flexmock('parent'),
-                              List::SectionFormat.new(format_config))
+    report = new_report 'layout_text1'
+    parent = report.start_new_page
+
+    List::SectionInternal.new report, List::SectionFormat.new(format_config)
   end
-  
+
   def test_height_should_operate_as_delegator_of_format
     list = create_internal('height' => 100)
     assert_same list.height, list.format.height
   end
-  
+
   def test_relative_left_should_operate_as_delegator_of_format
     list = create_internal('translate' => {'x' => 10})
     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)
-    
+
     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)
-    
+
     assert_equal list.relative_position.last, 150
   end
-end
+end

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

@@ -1,14 +1,14 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::List::TestStore < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::List::TestStore < Minitest::Test
+  include Thinreports::TestHelper
   
-  List = ThinReports::Core::Shape::List
+  List = Thinreports::Core::Shape::List
   
   def test_new
-    klass = List::Store.new(:foo => 'foo', :hoge => 0)
+    klass = List::Store.new(foo: 'foo', hoge: 0)
     
     assert_instance_of ::Class, klass
     
@@ -21,7 +21,7 @@ class ThinReports::Core::Shape::List::TestStore < MiniTest::Unit::TestCase
   end
   
   def test_init
-    store = List::Store.init(:foo => 0, :hoge => 'hoge')
+    store = List::Store.init(foo: 0, hoge: 'hoge')
     
     assert_respond_to store, :foo
     assert_respond_to store, :hoge
@@ -31,7 +31,7 @@ class ThinReports::Core::Shape::List::TestStore < MiniTest::Unit::TestCase
   end
   
   def test_copy
-    store = List::Store.init(:foo => Time.now)
+    store = List::Store.init(foo: Time.now)
     
     copied = store.copy
     

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

@@ -1,34 +1,30 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::Manager::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
+
+  class TestFormat < Thinreports::Core::Shape::Manager::Format; end
 
-class ThinReports::Core::Shape::Manager::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  class TestFormat < ThinReports::Core::Shape::Manager::Format; end
-  
   def test_identifier_should_return_the_same_as_object_id_when_id_is_not_given
     format = TestFormat.new({})
     assert_equal format.identifier, format.object_id
   end
-  
+
   def test_identifier_should_return_the_specified_id_when_id_is_given
     assert_equal TestFormat.new({}, :any_id).identifier, :any_id
   end
-  
-  def test_shapes_should_return_instance_of_OrderedHash
-    assert_instance_of ThinReports::Core::OrderedHash, TestFormat.new({}).shapes
-  end
-  
+
   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',
+      f.shapes[:foo] = Thinreports::Core::Shape::TextBlock::Format.new('id'   => 'foo',
                                                                        'type' => 's-tblock')
     end
     assert_equal format.find_shape(:foo).id, 'foo'
   end
-  
+
   def test_find_shape_should_return_nil_when_shape_is_not_found
     assert_nil TestFormat.new({}).find_shape(:unknown)
   end
-end
+end

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

@@ -1,12 +1,12 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Manager::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Manager::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
   
   # Alias
-  Shape = ThinReports::Core::Shape
+  Shape = Thinreports::Core::Shape
   
   def create_shape_format(type, id, other_config = {})
     Shape::Format(type).new({'id'      => id,
@@ -15,7 +15,7 @@ class ThinReports::Core::Shape::Manager::TestInternal < MiniTest::Unit::TestCase
   end
   
   def create_internal(&block)
-    report = create_basic_report('basic_layout1.tlf')
+    report = new_report('layout_text1.tlf')
     format = report.layout.format
     
     # Add to default dummy shapes.
@@ -53,22 +53,22 @@ class ThinReports::Core::Shape::Manager::TestInternal < MiniTest::Unit::TestCase
   
   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(:t1, only: 's-tblock').id, 't1'
   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(:t1, only: 's-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(:ls, except: 's-tblock').id, 'ls'
   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(:ls, except: 's-list')
   end
   
   def test_final_shape_should_return_nil_when_shape_is_not_found

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

@@ -1,121 +1,149 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::Manager::TestTarget < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::Manager::TestTarget < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Shape = ThinReports::Core::Shape
-  
+  Shape = Thinreports::Core::Shape
+
   class TestManager
     include Shape::Manager::Target
-    
+
     attr_reader :layout, :report
-    
+
     def initialize(report, layout)
       @report = report
       @layout = layout
-      
+
       initialize_manager(layout.format) do |f|
         Shape::Interface(self, f)
       end
     end
   end
-  
+
   def create_shape_format(type, id)
     Shape::Format(type).new('id' => id, 'type' => type)
   end
-  
+
   def create_manager
-    report = create_basic_report('basic_layout1.tlf')
+    report = new_report('layout_text1.tlf')
     layout = report.layout
-    
-    # Add to dummy shapes.
-    layout.format.shapes[:t1] = create_shape_format('s-tblock', 't1')
-    layout.format.shapes[:t2] = create_shape_format('s-tblock', 't2')
-    layout.format.shapes[:ls] = create_shape_format('s-list', 'ls')
+
+    layout.format.shapes[:text_block1] = create_shape_format('s-tblock', 'text_block1')
+    layout.format.shapes[:text_block2] = create_shape_format('s-tblock', 'text_block2')
+    layout.format.shapes[:image_block] = create_shape_format('s-iblock', 'image_block')
+    layout.format.shapes[:rectangle] = create_shape_format('s-rect', 'rectangle')
+    layout.format.shapes[:line] = create_shape_format('s-line', 'line')
+    layout.format.shapes[:list1] = create_shape_format('s-list', 'list1')
+    layout.format.shapes[:list2] = create_shape_format('s-list', 'list2')
     layout.format.shapes[:default] = create_shape_format('s-list', 'default')
-    
+
     TestManager.new(report, layout)
   end
-  
+
+  def test_shorthand_for_finding_item
+    manager = create_manager
+
+    text_block1 = manager[:text_block1]
+    text_block1.value = 'block1'
+
+    assert_instance_of Shape::TextBlock::Interface, manager[:text_block1]
+    assert_instance_of Shape::ImageBlock::Interface, manager[:image_block]
+    assert_instance_of Shape::Basic::Interface, manager[:rectangle]
+
+    assert_raises Thinreports::Errors::UnknownItemId do
+      manager[:unknown_id]
+    end
+
+    assert_raises Thinreports::Errors::UnknownItemId do
+      manager[:list1]
+    end
+  end
+
+  def test_shorthand_for_setting_value_to_block
+    manager = create_manager
+
+    manager[:text_block1] = 'value of text block1'
+    assert_equal 'value of text block1', manager.item(:text_block1).value
+
+    manager[:image_block] = '/path/to/image.png'
+    assert_equal '/path/to/image.png', manager.item(:image_block).src
+
+    assert_raises(NoMethodError) { manager[:rectangle] = 'value' }
+    assert_raises(Thinreports::Errors::UnknownItemId) { manager[:list1] = 'value' }
+  end
+
   def test_manager_should_return_instance_of_ManagerInternal
     assert_instance_of Shape::Manager::Internal, create_manager.manager
   end
-  
+
   def test_item_should_properly_return_shape_with_the_specified_Symbol_id
-    assert_equal create_manager.item(:t1).id, 't1'
+    assert_equal create_manager.item(:text_block1).id, 'text_block1'
   end
-  
+
   def test_item_should_properly_return_shape_with_the_specified_String_id
-    assert_equal create_manager.item('t2').id, 't2'
+    assert_equal create_manager.item('text_block2').id, 'text_block2'
   end
-  
+
   def test_item_should_raise_when_the_shape_with_the_specified_id_is_not_found
-    assert_raises ThinReports::Errors::UnknownItemId do
+    assert_raises Thinreports::Errors::UnknownItemId do
       create_manager.item(:unknown)
     end
   end
-  
+
   def test_item_should_set_an_shape_as_argument_when_a_block_is_given
     id = nil
-    create_manager.item(:t1) {|s| id = s.id }
-    assert_equal id, 't1'
+    create_manager.item(:text_block1) {|s| id = s.id }
+    assert_equal id, 'text_block1'
   end
-  
+
   def test_item_should_raise_when_type_of_shape_with_the_specified_id_is_list
-    assert_raises ThinReports::Errors::UnknownItemId do
-      create_manager.item(:ls)
+    assert_raises Thinreports::Errors::UnknownItemId do
+      create_manager.item(:list1)
     end
   end
-  
+
   def test_list_should_properly_return_list_with_the_specified_Symbol_id
-    assert_equal create_manager.list(:ls).id, 'ls'
+    assert_equal create_manager.list(:list1).id, 'list1'
   end
-  
+
   def test_list_should_properly_return_list_with_the_specified_String_id
-    assert_equal create_manager.list('ls').id, 'ls'
+    assert_equal create_manager.list('list1').id, 'list1'
   end
-  
+
   def test_list_should_raise_when_type_of_shape_with_the_specified_id_is_not_list
-    assert_raises ThinReports::Errors::UnknownItemId do
-      create_manager.list(:t1)
+    assert_raises Thinreports::Errors::UnknownItemId do
+      create_manager.list(:text_block1)
     end
   end
-  
+
   def test_list_should_use_default_as_id_when_id_is_omitted
     assert_equal create_manager.list.id, 'default'
   end
-  
+
   def test_values_should_properly_set_values_to_shapes_with_specified_id
     manager = create_manager
-    manager.values(:t1 => 1000, 't2' => 'value')
-    
-    assert_equal [manager.item(:t1).value, manager.item(:t2).value], [1000, 'value']
-  end
-  
-  def test_items_should_show_deprecation_warning
-    out, err = capture_io do
-      create_manager.items(:t1 => 1000)
-    end
-    assert_match %r!DEPRECATION!, err
+    manager.values(text_block1: 1000, 'text_block2' => 'value')
+
+    assert_equal [manager.item(:text_block1).value, manager.item(:text_block2).value], [1000, 'value']
   end
-  
+
   def test_item_exists_asker_should_return_true_when_shape_with_specified_Symbol_id_is_found
-    assert_equal create_manager.item_exists?(:t1), true
+    assert_equal create_manager.item_exists?(:text_block1), true
   end
-  
+
   def test_item_exists_asker_should_return_true_when_shape_with_specified_String_id_is_found
-    assert_equal create_manager.item_exists?('t2'), true
+    assert_equal create_manager.item_exists?('text_block2'), true
   end
-  
+
   def test_item_exists_asker_should_return_false_when_shape_with_specified_id_not_found
     assert_equal create_manager.item_exists?('unknown'), false
   end
-  
+
   def test_exists_asker_should_operate_like_as_item_exists_asker
     manager = create_manager
     assert_equal manager.exists?(:unknown), manager.item_exists?(:unknown)
   end
-end
+end