thinreports 0.10.3 → 0.11.0

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::List::TestPageState < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  List = Thinreports::Core::Shape::List
-
-  def setup
-    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!
-    assert_equal @state.finalized?, true
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::List::TestSectionFormat < Minitest::Test
-  include Thinreports::TestHelper
-
-  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_attribute_readers
-    format = List::SectionFormat.new(LIST_SECTION_FORMAT)
-
-    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_initialize_items
-    format = List::SectionFormat.new(LIST_SECTION_FORMAT)
-
-    assert_equal 1, format.shapes.count
-    assert_instance_of Shape::TextBlock::Format, format.shapes[:text_block]
-  end
-end

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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-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 = Thinreports::Report.new layout: layout_file.path
-  end
-
-  def create_interface(extra_section_schema = {})
-    parent = @report.start_new_page
-
-    List::SectionInterface.new(
-      parent,
-      List::SectionFormat.new(BASIC_SECTION_SCHEMA.merge(extra_section_schema)),
-      :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,
-                       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
-    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 = @report.start_new_page
-
-    %w( foo bar hoge ).each do |id|
-      list.manager.format.shapes[id.to_sym] = tblock::Format.new('type' => 'text-block', 'id' => id)
-      list.item(id).value(10)
-    end
-
-    block.call(list.copy(new_parent))
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-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(extra_section_schema = {})
-    report = Thinreports::Report.new layout: layout_file.path
-
-    List::SectionInternal.new(
-      report,
-      List::SectionFormat.new(BASIC_SECTION_SCHEMA.merge(extra_section_schema))
-    )
-  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_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_top
-    list = create_internal('translate' => { 'y' => 100 })
-    assert_equal 0, list.relative_top
-
-    list.move_top_to 50
-    assert_equal 50, list.relative_top
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Manager::TestFormat < Minitest::Test
-  include Thinreports::TestHelper
-
-  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_has_shape
-    format = TestFormat.new({}) do |f|
-      f.shapes[:foo] = 1
-    end
-    assert format.has_shape?(:foo)
-    refute format.has_shape?(:unknown)
-  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',
-                                                                       'type' => 'text-block')
-    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

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

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-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))
-  end
-
-  def create_internal(&block)
-    report = Thinreports::Report.new layout: layout_file.path
-    format = report.layout.format
-
-    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(:text_block).id, 'text_block'
-  end
-
-  def test_find_format_should_return_format_with_the_specified_String_id
-    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(: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(: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(: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(: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(: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(: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(: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(: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(: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
-    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
-    assert_nil internal.final_shape(:image_block)
-  end
-
-  def test_final_shape_should_return_nil_when_shape_isnot_stored_in_shapes_and_hidden
-    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
-    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('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_reference
-    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

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

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Manager::TestTarget < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  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 = Thinreports::Report.new layout: layout_file.path
-    layout = report.layout
-
-    TestManager.new(report, layout)
-  end
-
-  def test_shorthand_for_finding_item
-    manager = create_manager
-
-    text_block1 = manager[:text_block]
-    text_block1.value = 'block1'
-
-    assert_instance_of Shape::TextBlock::Interface, manager[:text_block]
-    assert_instance_of Shape::ImageBlock::Interface, manager[:image_block]
-    assert_instance_of Shape::Basic::Interface, manager[:rect_with_id]
-
-    assert_raises Thinreports::Errors::UnknownItemId do
-      manager[:unknown_id]
-    end
-
-    assert_raises Thinreports::Errors::UnknownItemId do
-      manager[:default]
-    end
-  end
-
-  def test_shorthand_for_setting_value_to_block
-    manager = create_manager
-
-    manager[:text_block] = 'value of text block1'
-    assert_equal 'value of text block1', manager.item(:text_block).value
-
-    manager[:image_block] = '/path/to/image.png'
-    assert_equal '/path/to/image.png', manager.item(:image_block).src
-
-    assert_raises(NoMethodError) { manager[:rect_with_id] = 'value' }
-    assert_raises(Thinreports::Errors::UnknownItemId) { manager[:default] = '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(:text_block).id, 'text_block'
-  end
-
-  def test_item_should_properly_return_shape_with_the_specified_String_id
-    assert_equal create_manager.item('text_block').id, 'text_block'
-  end
-
-  def test_item_should_raise_when_the_shape_with_the_specified_id_is_not_found
-    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(:text_block) {|s| id = s.id }
-    assert_equal id, 'text_block'
-  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(:default)
-    end
-  end
-
-  def test_list_should_properly_return_list_with_the_specified_Symbol_id
-    assert_equal create_manager.list(:default).id, 'default'
-  end
-
-  def test_list_should_properly_return_list_with_the_specified_String_id
-    assert_equal create_manager.list('default').id, 'default'
-  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(:text_block)
-    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(text_block: 1000)
-
-    assert_equal manager.item(:text_block).value, 1000
-  end
-
-  def test_item_exists_asker_should_return_true_when_shape_with_specified_Symbol_id_is_found
-    assert_equal create_manager.item_exists?(:text_block), true
-  end
-
-  def test_item_exists_asker_should_return_true_when_shape_with_specified_String_id_is_found
-    assert_equal create_manager.item_exists?('text_block'), 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