thinreports 0.7.6 → 0.8.0

data/test/unit/report/test_internal.rb

@@ -1,27 +1,31 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Report::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Report = ThinReports::Report
-  
+  Report = Thinreports::Report
+
   def report
     Report::Base.new
   end
 
   def sample_layout1
-    data_file('basic_layout1.tlf')
+    data_file('layout_text1.tlf')
   end
 
   def sample_layout2
-    data_file('basic_layout2.tlf')
+    data_file('layout_text2.tlf')
+  end
+
+  def sample_list_layout
+    data_file('layout_list.tlf')
   end
 
   def test_layout_specified_in_new_method_should_be_defined_as_default_layout
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     assert_equal internal.default_layout.filename, sample_layout1
   end
 
@@ -31,89 +35,98 @@ class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
 
     assert_equal internal.default_layout.filename, sample_layout1
   end
-  
+
   def test_register_layout_should_be_set_as_default_layout_when_default_option_is_true
     internal = Report::Internal.new(report, {})
-    internal.register_layout(sample_layout1, :default => true)
-    
+    internal.register_layout(sample_layout1, default: true)
+
     assert_equal internal.default_layout.filename, sample_layout1
   end
-  
+
   def test_register_layout_should_be_able_to_change_the_default_layout
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.register_layout(sample_layout2, :default => true)
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal.register_layout(sample_layout2, default: true)
 
     assert_equal internal.default_layout.filename, sample_layout2
   end
-  
+
   def test_register_layout_should_be_set_as_with_id_when_id_option_is_set
     internal = Report::Internal.new(report, {})
-    internal.register_layout(sample_layout1, :id => :foo)
+    internal.register_layout(sample_layout1, id: :foo)
 
     assert_equal internal.layout_registry[:foo].filename, sample_layout1
   end
-  
+
   def test_register_layout_should_raise_an_error_when_id_is_already_registered
     internal = Report::Internal.new(report, {})
-    internal.register_layout(sample_layout2, :id => :foo)
-    
+    internal.register_layout(sample_layout2, id: :foo)
+
     assert_raises ArgumentError do
-      internal.register_layout(sample_layout1, :id => :foo)
+      internal.register_layout(sample_layout1, id: :foo)
     end
   end
-  
+
   def test_register_layout_should_return_the_instance_of_LayoutConfiguration
     internal = Report::Internal.new(report, {})
 
-    assert_instance_of ThinReports::Layout::Configuration, 
+    assert_instance_of Thinreports::Layout::Configuration,
                        internal.register_layout(sample_layout1)
   end
-  
+
+  def test_register_layout_should_be_able_to_set_list_configuration_without_errors
+    internal = Report::Internal.new(report, {})
+    internal.register_layout(sample_list_layout) do |config|
+      config.list(:list).use_stores foo: 0
+      config.list(:list).use_stores bar: 1000
+    end
+    pass
+  end
+
   def test_add_page_should_finalize_the_current_page
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    page = internal.add_page(ThinReports::Core::Page.new(report, layout))
-    internal.add_page(ThinReports::Core::Page.new(report, layout))
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    page = internal.add_page(Thinreports::Report::Page.new(report, layout))
+    internal.add_page(Thinreports::Report::Page.new(report, layout))
 
     assert_equal page.finalized?, true
   end
 
   def test_add_page_should_return_the_current_page
-    layout = ThinReports::Layout.new(sample_layout1)
-    new_page = ThinReports::Core::Page.new(report, layout)
+    layout = Thinreports::Layout.new(sample_layout1)
+    new_page = Thinreports::Report::Page.new(report, layout)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
 
     assert_same new_page, internal.add_page(new_page)
   end
 
   def test_add_page_should_add_the_initialized_page
-    layout = ThinReports::Layout.new(sample_layout1)
-    new_page = ThinReports::Core::Page.new(report, layout)
+    layout = Thinreports::Layout.new(sample_layout1)
+    new_page = Thinreports::Report::Page.new(report, layout)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.add_page(new_page)
 
     assert_same new_page, internal.pages.last
   end
 
   def test_add_page_should_count_up_the_total_page_count
-    layout = ThinReports::Layout.new(sample_layout1)
-    
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(ThinReports::Core::Page.new(report, layout))
+    layout = Thinreports::Layout.new(sample_layout1)
+
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal.add_page(Thinreports::Report::Page.new(report, layout))
 
     assert_equal internal.page_count, 1
   end
-  
+
   def test_add_page_should_switch_to_a_reference_to_the_current_page
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
     new_pages = (1..2).inject([]) do |pages, i|
-      pages << ThinReports::Core::Page.new(report, layout)
+      pages << Thinreports::Report::Page.new(report, layout)
     end
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.add_page(new_pages[0])
 
     assert_same internal.page, new_pages[0]
@@ -122,51 +135,51 @@ class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
 
     assert_same internal.page, new_pages[1]
   end
-    
+
   def test_add_page_should_dispatch_the_event_page_creation
     dispatched = false
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.events.on(:page_create) {|e| dispatched = true }
-    internal.add_page(ThinReports::Core::Page.new(report, layout))
+    internal.add_page(Thinreports::Report::Page.new(report, layout))
 
     assert dispatched
   end
 
   def test_add_blank_page_should_not_dispatch_the_event_page_creation
     dispatched = false
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.events.on(:page_create) {|e| dispatched = true }
-    internal.add_page(ThinReports::Core::BlankPage.new)
+    internal.add_page(Thinreports::Report::BlankPage.new)
 
     refute dispatched
   end
-  
+
   def test_add_blank_page_should_not_count_up_the_total_page_count_when_count_is_disabled
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(ThinReports::Core::BlankPage.new(false))
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal.add_page(Thinreports::Report::BlankPage.new(false))
 
     assert_equal internal.page_count, 0
   end
 
   def test_add_blank_page_should_count_up_the_total_page_count_when_count_is_enabled
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(ThinReports::Core::BlankPage.new)
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal.add_page(Thinreports::Report::BlankPage.new)
 
     assert_equal internal.page_count, 1
   end
-  
+
   def test_finalize_should_dispatch_the_event_report_generation
     dispatched = false
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.events.on(:generate) {|e| dispatched = true }
     internal.finalize
 
@@ -174,72 +187,79 @@ class ThinReports::Report::TestInternal < MiniTest::Unit::TestCase
   end
 
   def test_finalize_should_finalize_the_report
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.finalize
 
     assert internal.finalized?
   end
 
   def test_finalize_should_not_work_when_report_is_already_finalized
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-
-    flexmock(internal).
-      should_receive(:finalize_current_page).once
-
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.finalize
+
+    # #finalize_current_page must never be called
+    internal.expects(:finalize_current_page).never
     internal.finalize
   end
 
   def test_finalized_should_return_true_when_report_is_already_finalized
-    internal = Report::Internal.new(report, :layout => sample_layout1)
+    internal = Report::Internal.new(report, layout: sample_layout1)
     internal.finalize
 
     assert internal.finalized?
   end
-  
+
   def test_load_layout_with_String
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    
-    assert_equal internal.load_layout(sample_layout2).filename, 
+    internal = Report::Internal.new(report, layout: sample_layout1)
+
+    assert_equal internal.load_layout(sample_layout2).filename,
                  sample_layout2
   end
-  
+
   def test_load_layout_with_id
     internal = Report::Internal.new(report, {})
-    internal.register_layout(sample_layout1, :id => :sample)
+    internal.register_layout(sample_layout1, id: :sample)
 
-    assert_equal internal.load_layout(:sample).filename, 
+    assert_equal internal.load_layout(:sample).filename,
                  sample_layout1
   end
-  
+
   def test_load_layout_with_unknown_id
     internal = Report::Internal.new(report, {})
     assert_nil internal.load_layout(:unknown)
   end
-  
+
+  def test_load_layout_should_set_default_layout_when_default_layout_is_nil
+    internal = Report::Internal.new(report, {})
+    internal.load_layout(sample_layout1)
+
+    assert_equal internal.default_layout.filename,
+                 sample_layout1
+  end
+
   def test_load_layout_should_raise_error_when_invalid_value_set
     internal = Report::Internal.new(report, {})
 
-    assert_raises ThinReports::Errors::LayoutFileNotFound do
+    assert_raises Thinreports::Errors::LayoutFileNotFound do
       internal.load_layout('/path/to/unkown.tlf')
     end
   end
-  
+
   def test_copy_page_should_finalize_current_page
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(page = ThinReports::Core::Page.new(report, layout))
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal.add_page(page = Thinreports::Report::Page.new(report, layout))
     internal.copy_page
 
     assert page.finalized?
   end
 
   def test_copy_page_should_add_the_copied_page
-    layout = ThinReports::Layout.new(sample_layout1)
+    layout = Thinreports::Layout.new(sample_layout1)
 
-    internal = Report::Internal.new(report, :layout => sample_layout1)
-    internal.add_page(page = ThinReports::Core::Page.new(report, layout))
+    internal = Report::Internal.new(report, layout: sample_layout1)
+    internal.add_page(page = Thinreports::Report::Page.new(report, layout))
     internal.copy_page
 
     assert_equal internal.page_count, 2

data/test/unit/test_config.rb

@@ -1,22 +1,41 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::TestConfig < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::TestConfig < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   def test_generator_of_Configuration_should_return_configuration_of_generator
-    config = ThinReports::Configuration.new
-    assert_instance_of ThinReports::Generator::Configuration, config.generator
+    config = Thinreports::Configuration.new
+    assert_instance_of Thinreports::Generator::Configuration, config.generator
   end
-  
+
   def test_config_should_return_configuration_of_thinreports
-    assert_instance_of ThinReports::Configuration, ThinReports.config
+    assert_instance_of Thinreports::Configuration, Thinreports.config
   end
-  
+
   def test_configure_should_exec_an_given_block_with_config_which_instance_of_Configuration
-    ThinReports.configure do |config|
-      assert_instance_of ThinReports::Configuration, config
+    Thinreports.configure do |config|
+      assert_instance_of Thinreports::Configuration, config
     end
   end
-end
+
+  def test_fallback_fonts
+    config = Thinreports::Configuration.new
+
+    # should be empty by default
+    assert_empty config.fallback_fonts
+
+    config.fallback_fonts = 'Helvetica'
+    assert_equal config.fallback_fonts, ['Helvetica']
+
+    config.fallback_fonts = ['/path/to/font.ttf', 'Courier New']
+    assert_equal config.fallback_fonts, ['/path/to/font.ttf', 'Courier New']
+
+    config.fallback_fonts = []
+    config.fallback_fonts << 'Helvetica'
+    config.fallback_fonts << 'IPAMincho'
+    config.fallback_fonts.unshift 'Times New Roman'
+    assert_equal config.fallback_fonts, ['Times New Roman', 'Helvetica', 'IPAMincho']
+  end
+end

data/test/unit/test_layout.rb

@@ -1,12 +1,12 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::TestLayout < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::TestLayout < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   def test_new
-    flexmock(ThinReports::Layout::Base).should_receive(:new).once
-    ThinReports::Layout.new('layout.tlf')
+    assert_instance_of Thinreports::Layout::Base,
+                       Thinreports::Layout.new(data_file('layout_text1.tlf'))
   end
-end
+end

data/test/unit/test_report.rb

@@ -1,30 +1,18 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::TestReport < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::TestReport < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Report = ThinReports::Report
-  
-  def test_new_should_delegate_to_Base_new
-    flexmock(Report::Base).should_receive(:new).once
-    Report.new
-  end
-  
-  def test_create_should_delegate_to_Base_create
-    flexmock(Report::Base).should_receive(:create).once
-    Report.create
-  end
-  
-  def test_generate_should_delegate_to_Base_generate
-    flexmock(Report::Base).should_receive(:generate).once
-    Report.generate
+  Report = Thinreports::Report
+
+  def test_new
+    assert_instance_of Report::Base, Report.new
   end
-  
-  def test_generate_file_should_delegate_to_Base_generate_file
-    flexmock(Report::Base).should_receive(:generate_file).once
-    Report.generate_file
+
+  def test_create
+    assert_instance_of Report::Base, Report.create {}
   end
-end
+end

data/thinreports.gemspec

@@ -5,32 +5,29 @@ require 'thinreports/version'
 
 Gem::Specification.new do |s|
   s.name        = 'thinreports'
-  s.version     = ThinReports::VERSION
+  s.version     = Thinreports::VERSION
   s.author      = 'Matsukei Co.,Ltd.'
-  s.email       = 'thinreports@matsukei.co.jp'
-  
-  s.summary     = 'Reporting solution for Ruby and Rails.'
-  s.description = 'ThinReports is Open Source Reporting Solution for Ruby. ' +
-                  'It provides a GUI Designer and a Library for Ruby.'
-  s.homepage    = 'http://www.thinreports.org/'
-  
-  s.platform                  = Gem::Platform::RUBY
-  s.required_ruby_version     = '>= 1.8.7'
-  s.required_rubygems_version = '>= 1.3.6'
-  
-  s.rdoc_options     = ['--main', 'README.rdoc']
-  s.extra_rdoc_files = ['README.rdoc']
-  
+  s.email       = 'thinreports@gmail.com'
+  s.summary     = 'An open source report generation tool for Ruby.'
+  s.description = 'Thinreports is an open source report generation tool for Ruby.'
+  s.homepage    = 'http://www.thinreports.org'
+  s.licenses    = ['MIT']
+
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.rdoc_options     = ['--main', 'README.md']
+  s.extra_rdoc_files = ['README.md']
+
   s.files         = `git ls-files`.split($\)
-  s.test_files    = s.files.grep(%r{^test/})
-  s.require_path  = 'lib'
-  
-  s.add_dependency('prawn', '>= 0.12.0', '<= 0.12.0')
-  
-  s.add_development_dependency('bundler', ['>= 1.0.0'])
-  s.add_development_dependency('flexmock', ['~> 0.9.0'])
-  s.add_development_dependency('yard', ['>= 0'])
-  s.add_development_dependency('rake', ['>=0'])
-  s.add_development_dependency('turn', ['>=0'])
-  s.add_development_dependency('simplecov', ['>=0'])
+  s.test_files    = s.files.grep %r{^test/}
+  s.require_paths = ['lib']
+
+  s.add_dependency 'prawn', '1.3.0'
+
+  s.add_development_dependency 'bundler', ['>= 1.0.0']
+  s.add_development_dependency 'minitest', ['>= 5.0.0']
+  s.add_development_dependency 'mocha', ['>= 0']
+  s.add_development_dependency 'rake', ['>= 0']
+  s.add_development_dependency 'yard'
 end