thinreports 0.10.3 → 0.11.0

data/test/test_helper.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'minitest/spec'
-require 'minitest/unit'
-require 'mocha/minitest'
-require 'pdf/inspector'
-
-require 'digest/sha1'
-require 'pathname'
-require 'thinreports'
-
-require 'schema_helper'
-
-module Thinreports::TestHelper
-  ROOT = Pathname.new(File.expand_path('..', __FILE__))
-
-  include Thinreports::SchemaHelper
-
-  def assert_deprecated(&block)
-    _out, err = capture_io { block.call }
-    assert err.to_s.include?('[DEPRECATION]')
-  end
-
-  def data_file(*paths)
-    ROOT.join('data', *paths).to_s
-  end
-
-  def read_data_file(*paths)
-    File.read(data_file(*paths))
-  end
-
-  def analyze_pdf_images(pdf_data)
-    analyzer = PDF::Inspector::XObject.analyze(pdf_data)
-    analyzer.page_xobjects
-      .reduce(:merge).values
-      .select { |o| o.hash[:Subtype] == :Image }
-  end
-end

data/test/units/core/format/test_base.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Format::BaseTest < Minitest::Test
-  TEST_FORMAT_CONFIG = {
-    'c1' => 'c1',
-    'c2' => {
-      'c2_1' => 'c2_1'
-    },
-    'c3' => {
-      'c3_1' => {
-        'c3_1_1' => 'c3_1_1',
-        'c3_1_2' => 'c3_1_2'
-      }
-    },
-    'c4' => 'c4',
-    'c5' => 'c5',
-    'c6' => 9999,
-    'c7' => true,
-    'c8' => false,
-    'c9' => {
-      'c9_1' => true,
-      'c9_2' => false
-    },
-    'c10' => 'c10',
-    'c11' => {
-      'c11_1' => 'c11_1'
-    },
-    'c20' => 'c20',
-    'c21' => 'c21'
-  }
-
-  class TestFormat < Thinreports::Core::Format::Base
-    # For testing
-    attr_reader :config
-
-    # Basic methods
-    config_reader :c1
-    config_reader c2_1: %w( c2 c2_1 ),
-                  c3_1_1: %w( c3 c3_1 c3_1_1 )
-    config_reader :c4, :c5
-    config_reader 'c6'
-
-    # Alias methods
-    config_reader c1_alias: %w( c1 ),
-                  c2_1_alias: %w( c2 c2_1 )
-
-    # Invalid methods
-    config_reader c3_invalid: %w( c3 c3_1 not_exist_key )
-
-    # Customized methods
-    config_reader c2_1_customized: %w( c2 c2_1 ) do |val|
-      "Customized #{val}"
-    end
-
-    # Checker methods
-    config_checker true, :c7, :c8
-    config_checker true, c9_1: %w( c9 c9_1 ),
-                         c9_2: %w( c9 c9_2 )
-
-    # Writer methods
-    config_writer :c10
-    config_writer c10_alias: %w( c10 )
-    config_writer c11_1: %w( c11 c11_1 )
-    # Writer for not exist config on default
-    config_writer c11_2: %w( c11 c11_2 )
-
-    # Accessor methods
-    config_accessor :c20
-    config_accessor :c21 do |val|
-      "Customized #{val}"
-    end
-  end
-
-  def setup
-    @format = TestFormat.new(TEST_FORMAT_CONFIG)
-  end
-
-  def test_definition_of_all_config_methods
-    methods = [:c1, :c2_1, :c3_1_1, :c4, :c5, :c6,
-               :c1_alias, :c2_1_alias,
-               :c3_invalid,
-               :c2_1_customized,
-               :c7?, :c8?, :c9_1?, :c9_2?,
-               :c10=, :c10_alias=, :c11_1=, :c11_2=,
-               :c20, :c20=, :c21, :c21=]
-    assert methods.all? {|m| TestFormat.method_defined?(m) }
-  end
-
-  def test_readers
-    # Basic
-    assert_equal @format.c1, 'c1'
-    assert_equal @format.c2_1, 'c2_1'
-    assert_equal @format.c3_1_1, 'c3_1_1'
-    assert_equal @format.c4, 'c4'
-    assert_equal @format.c5, 'c5'
-    assert_equal @format.c6, 9999
-    # Alias
-    assert_equal @format.c1_alias, @format.c1
-    assert_equal @format.c2_1_alias, @format.c2_1
-    # Invalid location
-    assert_nil @format.c3_invalid
-    # Customized
-    assert_equal @format.c2_1_customized, 'Customized c2_1'
-  end
-
-  def test_checkers
-    assert_equal @format.c7?, true
-    assert_equal @format.c8?, false
-    assert_equal @format.c9_1?, true
-    assert_equal @format.c9_2?, false
-  end
-
-  def test_reader_cannot_write_value
-    assert_raises NoMethodError do
-      @format.c1 = 'write'
-    end
-    # Alias method
-    assert_raises NoMethodError do
-      @format.c1_alias = 'write'
-    end
-  end
-
-  def test_writers
-    config = @format.config
-
-    @format.c10 = 'c1_changed'
-    assert_equal config['c10'], 'c1_changed'
-
-    @format.c10_alias = 'c10_changed_by_alias'
-    assert_equal config['c10'], 'c10_changed_by_alias'
-
-    @format.c11_1 = 'c11_1_changed'
-    assert_equal config['c11']['c11_1'], 'c11_1_changed'
-
-    @format.c11_2 = 'c11_2_created'
-    assert_equal config['c11']['c11_2'], 'c11_2_created'
-  end
-
-  def test_accessors
-    @format.c20 = 'c20_changed'
-    assert_equal @format.c20, 'c20_changed'
-
-    @format.c21 = 'c21_changed'
-    assert_equal @format.c21, 'Customized c21_changed'
-  end
-
-  def test_attributes
-    assert_same @format.config, @format.attributes
-  end
-end

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Base::TestInternal < Minitest::Test
-  include Thinreports::TestHelper
-
-  def setup
-    @report = Thinreports::Report.new layout: layout_file.path
-    @report.start_new_page
-  end
-
-  def create_internal(format_config = {}, &block)
-    format =
-      unless format_config.empty?
-        format_klass = Class.new(Thinreports::Core::Shape::Basic::Format) {
-          config_reader(*format_config.keys.map {|k| k.to_sym })
-        }
-        format_klass.new(format_config)
-      else
-        Thinreports::Core::Shape::Basic::Format.new({})
-      end
-
-    klass = Class.new(Thinreports::Core::Shape::Base::Internal, &block)
-    klass.new(@report.page, format)
-  end
-
-  def test_self_format_delegators_should_defines_method_delegated_from_format
-    internal = create_internal('m1' => 'm1_value') {
-      format_delegators :m1
-    }
-    assert_respond_to internal, :m1
-  end
-
-  def test_method_delegated_from_format_should_return_same_value_as_an_format
-    internal = create_internal('m1' => 'm1 value') {
-      format_delegators :m1
-    }
-    assert_same internal.m1, internal.format.m1
-  end
-
-  def test_copied_internal_should_have_the_new_value_specified_as_a_parent_property
-    new_page = @report.start_new_page
-    internal = create_internal {
-      def style
-        @style ||= Thinreports::Core::Shape::Style::Base.new(format)
-      end
-    }
-
-    assert_same internal.copy(new_page).parent, new_page
-  end
-
-  def test_copied_internal_should_have_style_copied_from_original
-    internal = create_internal {
-      def style
-        @style ||= Thinreports::Core::Shape::Style::Base.new(format)
-      end
-    }
-    internal.style.write_internal_style(:foo, 'bar')
-    new_internal = internal.copy(@report.start_new_page)
-
-    assert_equal new_internal.style.read_internal_style(:foo), 'bar'
-  end
-
-  def test_copied_internal_should_have_states_property_copied_from_original
-    internal = create_internal {
-      def style
-        @style ||= Thinreports::Core::Shape::Style::Base.new(format)
-      end
-    }
-    internal.states[:foo] = 'bar'
-    new_internal = internal.copy(@report.start_new_page)
-
-    assert_equal new_internal.states[:foo], 'bar'
-  end
-
-  def test_copy_should_execute_block_with_new_internal_as_argument
-    internal = create_internal {
-      def style
-        @style ||= Thinreports::Core::Shape::Style::Base.new(format)
-      end
-    }
-    internal.copy(@report.start_new_page) do |new_internal|
-      assert_equal new_internal.is_a?(Thinreports::Core::Shape::Base::Internal), true
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-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/units/core/shape/basic/test_block_interface.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Basic::TestBlockInterface < Minitest::Test
-  include Thinreports::TestHelper
-
-  Basic = Thinreports::Core::Shape::Basic
-
-  def setup
-    report = Thinreports::Report.new layout: layout_file.path
-    parent = report.start_new_page
-
-    format = Basic::BlockFormat.new({})
-    internal = Basic::BlockInternal.new parent, format
-
-    @interface = Basic::BlockInterface.new parent, format, internal
-  end
-
-  def test_value_should_work_as_reader_with_no_arguments
-    @interface.internal.write_value('new value')
-    assert_equal @interface.value, 'new value'
-  end
-
-  def test_value_should_work_as_writer_with_arguments
-    @interface.value('new value')
-    assert_equal @interface.internal.read_value, 'new value'
-  end
-end

data/test/units/core/shape/basic/test_block_internal.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Basic::TestBlockInternal < Minitest::Test
-  include Thinreports::TestHelper
-
-  Basic = Thinreports::Core::Shape::Basic
-
-  def test_read_value_should_return_value_from_format
-    internal = init_internal('value' => 'default value')
-    assert_equal internal.read_value, 'default value'
-  end
-
-  def test_read_value_should_return_value_from_state_with_value_key
-    internal = init_internal
-    internal.states[:value] = 'new value'
-    assert_equal internal.read_value, 'new value'
-  end
-
-  def test_real_value_should_return_the_same_value_as_a_read_value_method
-    internal = init_internal
-    internal.states[:value] = 'foo'
-    assert_same internal.real_value, internal.read_value
-  end
-
-  def test_write_value_should_save_value_to_states_store_as_value
-    internal = init_internal
-    internal.write_value('new value')
-    assert_equal internal.states[:value], 'new value'
-  end
-
-  def test_type_of_asker_should_return_true_when_given_the_block_value
-    assert_equal init_internal.type_of?(:block), true
-  end
-
-  def test_value_should_works_the_same_as_read_value_method
-    internal = init_internal
-    internal.write_value('new value')
-    assert_same internal.read_value, internal.value
-  end
-
-  def test_type_of_asker_should_return_false_otherwise
-    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: layout_file.path
-    parent = report.start_new_page
-
-    Basic::BlockInternal.new(parent, Basic::BlockFormat.new(format))
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Basic::TestFormat < Minitest::Test
-  include Thinreports::TestHelper
-
-  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"
-    }
-  }
-
-  Basic = Thinreports::Core::Shape::Basic
-
-  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

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Core::Shape::Basic::TestInterface < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  Basic = Thinreports::Core::Shape::Basic
-
-  def create_interface(format_config = {})
-    report = Thinreports::Report.new layout: layout_file.path
-    parent = report.start_new_page
-
-    Basic::Interface.new parent, Basic::Format.new(format_config)
-  end
-
-  def test_id_should_return_id_with_reference_to_internal
-    basic = create_interface('id' => 'foo')
-    assert_equal basic.id, basic.internal.id
-  end
-
-  def test_id_should_return_cloned_id
-    basic = create_interface('id' => 'basic-id')
-    refute_same basic.id, basic.internal.id
-  end
-
-  def test_type_should_operate_as_delegator_of_internal
-    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)
-    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.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('style' => { 'fill-color' => '#ff0000' })
-
-    assert_equal basic.style(:fill_color), '#ff0000'
-  end
-
-  def test_style_should_operate_as_writer_when_two_arguments_are_given
-    basic = create_interface
-    basic.style(:border_color, '#000000')
-
-    assert_equal basic.style(:border_color), '#000000'
-  end
-
-  def test_style_should_operate_as_writer_for_border_style_when_three_arguments_are_given
-    basic = create_interface
-    basic.style(:border, 1, '#ffffff')
-
-    assert_equal basic.style(:border), [1, '#ffffff']
-  end
-
-  def test_style_should_return_self_when_two_arguments_are_given
-    assert_instance_of Basic::Interface, create_interface.style(:border_width, 1)
-  end
-
-  def test_style_should_return_self_when_three_arguments_are_given
-    assert_instance_of Basic::Interface, create_interface.style(:border, 1, '#000000')
-  end
-
-  def test_styles_should_properly_set_the_specified_styles_as_Hash
-    basic = create_interface
-    basic.styles(fill_color: '#ff0000',
-                 border_color: '#000000',
-                 border_width: 5,
-                 visible: false)
-
-    assert_equal [basic.style(:fill_color),
-                  basic.style(:border_color),
-                  basic.style(:border_width),
-                  basic.style(:visible)],
-                 ['#ff0000', '#000000', 5, false]
-  end
-
-  def test_hide_should_properly_set_false_to_visibility
-    basic = create_interface
-    basic.hide
-
-    assert_equal basic.visible?, false
-  end
-
-  def test_hide_should_return_self
-    assert_instance_of Basic::Interface, create_interface.hide
-  end
-
-  def test_show_should_properly_set_true_to_visibility
-    basic = create_interface
-    basic.show
-
-    assert_equal basic.visible?, true
-  end
-
-  def test_show_should_return_self
-    assert_instance_of Basic::Interface, create_interface.show
-  end
-end