ndr_support 3.1.1

data/ndr_support.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ndr_support/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ndr_support'
+  spec.version       = NdrSupport::VERSION
+  spec.authors       = ['NCRS Development Team']
+  spec.email         = []
+  spec.summary       = 'NDR Support library'
+  spec.description   = 'Provides NDR classes and class extensions'
+  spec.homepage      = 'https://github.com/PublicHealthEngland/ndr_support'
+  spec.license       = 'MIT'
+
+  # Exclude older versions of this gem from the package.
+  spec.files         = `git ls-files -z`.split("\x0").reject { |s| s =~ /^pkg\// }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', '>= 3.2.18', '< 5.0.0'
+  spec.add_dependency 'activesupport', '>= 3.2.18', '< 5.0.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  # Avoid std-lib minitest (which has different namespace)
+  spec.add_development_dependency 'minitest', '>= 5.0.0'
+  spec.add_development_dependency 'mocha', '~> 1.1'
+
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rubocop'
+  spec.add_development_dependency 'guard-minitest'
+  spec.add_development_dependency 'terminal-notifier-guard' if RUBY_PLATFORM =~ /darwin/
+  spec.add_development_dependency 'simplecov'
+end

data/test/array_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+# This tests our Array extension
+class ArrayTest < Minitest::Test
+  test 'Arrays should be extended with #permutations' do
+    assert [].respond_to?(:permutations)
+  end
+
+  test 'Array#permutations should calculate permutations correctly' do
+    array = [1, 2, 3]
+    permutations = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
+    assert_equal array.length.factorial, array.permutations.length
+    assert_equal permutations.sort, array.permutations.sort
+  end
+
+  test 'Array#permutations should permute duplicates' do
+    array = [1, 1]
+    assert_equal [[1, 1], [1, 1]], array.permutations
+  end
+end

data/test/concerns/working_days_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+# This tests our WorkingDays Time/Date/DateTime extension
+class WorkingDaysTest < Minitest::Test
+  def setup
+    @normal_date      = Date.parse('2015-02-02')          # Monday 2nd Feb 2015
+    @normal_time      = Time.parse('2015-02-02 2pm')      # Monday 2nd Feb 2015
+    @normal_date_time = DateTime.parse('2015-02-02 11am') # Monday 2nd Feb 2015
+
+    @easter_date      = Date.parse('2015-04-06')          # Easter Monday, 2015
+    @easter_time      = Time.parse('2015-04-06 2pm')      # Easter Monday, 2015
+    @easter_date_time = DateTime.parse('2015-04-06 11am') # Easter Monday, 2015
+  end
+
+  test 'should identify weekdays' do
+    assert Date.parse('2015-12-25').weekday?
+    assert Time.parse('2015-12-25 3pm').weekday?
+    assert DateTime.parse('2015-12-25 3pm').weekday?
+
+    refute Date.parse('2015-12-26').weekday?
+    refute Time.parse('2015-12-26 3pm').weekday?
+    refute DateTime.parse('2015-12-26 3pm').weekday?
+  end
+
+  test 'should identify bank holidays' do
+    assert Date.parse('2015-12-25').public_holiday?
+    assert Time.parse('2015-12-25 3pm').public_holiday?
+    assert DateTime.parse('2015-12-25 3pm').public_holiday?
+
+    # Boxing Day 2015 is a Saturday; the bank holiday a
+    # substitute day, on the following Monday:
+    refute Date.parse('2015-12-26').public_holiday?
+    refute Time.parse('2015-12-26 3pm').public_holiday?
+    refute DateTime.parse('2015-12-26 3pm').public_holiday?
+
+    assert Date.parse('2015-12-28').public_holiday?
+    assert Time.parse('2015-12-28 3pm').public_holiday?
+    assert DateTime.parse('2015-12-28 3pm').public_holiday?
+  end
+
+  test 'should allow comparison of Time and DateTime' do
+    @normal_time.working_days_until(@normal_date_time)
+    @normal_date_time.working_days_until(@normal_time)
+  end
+
+  test 'should allow comparison of DateTime and Date' do
+    @normal_date_time.working_days_until(@normal_date)
+    @normal_date.working_days_until(@normal_date_time)
+  end
+
+  test 'should be zero working days between same normal day' do
+    assert_equal 0, @normal_date.working_days_until(@normal_date)
+    assert_equal 0, @normal_time.working_days_until(@normal_time + 6.hours)
+    assert_equal 0, @normal_date_time.working_days_until(@normal_date_time + 6.hours)
+  end
+
+  test 'Monday -> Friday should be 4 working days' do
+    assert_equal 4, @normal_date.working_days_until(@normal_date + 4.days)
+    assert_equal 4, @normal_time.working_days_until(@normal_time + 4.days)
+    assert_equal 4, @normal_date_time.working_days_until(@normal_date_time + 4.days)
+  end
+
+  test 'Friday <- Monday should be -4 working days' do
+    assert_equal(-4, (@normal_date + 4.days).working_days_until(@normal_date))
+    assert_equal(-4, (@normal_time + 4.days).working_days_until(@normal_time))
+    assert_equal(-4, (@normal_date_time + 4.days).working_days_until(@normal_date_time))
+  end
+
+  test 'Saturday -> Sunday should be 0 working days' do
+    assert_equal 0, (@normal_date - 2.days).working_days_until(@normal_date - 1.day)
+    assert_equal 0, (@normal_time - 2.days).working_days_until(@normal_time - 1.day)
+    assert_equal 0, (@normal_date_time - 2.days).working_days_until(@normal_date_time - 1.day)
+  end
+
+  test 'Sunday <- Saturday should be 0 working days' do
+    assert_equal 0, (@normal_date - 1.day).working_days_until(@normal_date - 2.days)
+    assert_equal 0, (@normal_time - 1.day).working_days_until(@normal_time - 2.days)
+    assert_equal 0, (@normal_date_time - 1.day).working_days_until(@normal_date_time - 2.days)
+  end
+
+  test 'Monday -> next Monday should be 5 working days' do
+    assert_equal 5, @normal_date.working_days_until(@normal_date + 7.days)
+    assert_equal 5, @normal_time.working_days_until(@normal_time + 7.days)
+    assert_equal 5, @normal_date_time.working_days_until(@normal_date_time + 7.days)
+  end
+
+  test 'Monday -> Easter Monday should be 3 working days' do
+    assert_equal 3, (@easter_date - 7.days).working_days_until(@easter_date)
+    assert_equal 3, (@easter_time - 7.days).working_days_until(@easter_time)
+    assert_equal 3, (@easter_date_time - 7.days).working_days_until(@easter_date_time)
+  end
+
+  test 'Tuesday -> Tuesday over Easter should be 3 working days' do
+    assert_equal 3, (@easter_date - 6.days).working_days_until(@easter_date + 1.day)
+    assert_equal 3, (@easter_time - 6.days).working_days_until(@easter_time + 1.day)
+    assert_equal 3, (@easter_date_time - 6.days).working_days_until(@easter_date_time + 1.day)
+  end
+
+  test 'Good Friday -> Friday should be 4 working days' do
+    assert_equal 4, (@easter_date - 3.days).working_days_until(@easter_date + 4.day)
+    assert_equal 4, (@easter_time - 3.days).working_days_until(@easter_time + 4.day)
+    assert_equal 4, (@easter_date_time - 3.days).working_days_until(@easter_date_time + 4.day)
+  end
+
+  test 'Friday -> Monday should be 1 working day' do
+    assert_equal 1, (@normal_date - 3.days).working_days_until(@normal_date)
+    assert_equal 1, (@normal_time - 3.days).working_days_until(@normal_time)
+    assert_equal 1, (@normal_date_time - 3.days).working_days_until(@normal_date_time)
+  end
+
+  test 'A year of week days' do
+    assert_equal 261, @normal_date.weekdays_until(@normal_date + 1.year)
+    assert_equal 261, @normal_time.weekdays_until(@normal_time + 1.year)
+    assert_equal 261, @normal_date_time.weekdays_until(@normal_date_time + 1.year)
+  end
+
+  test 'A year of working days' do
+    assert_equal 253, @normal_date.working_days_until(@normal_date + 1.year)
+    assert_equal 253, @normal_time.working_days_until(@normal_time + 1.year)
+    assert_equal 253, @normal_date_time.working_days_until(@normal_date_time + 1.year)
+  end
+end

data/test/daterange_test.rb

@@ -0,0 +1,194 @@
+require 'test_helper'
+
+# This tests our Daterange class
+class DaterangeTest < Minitest::Test
+  def test_basic_creation
+    dr = Daterange.new
+    assert_equal '', dr.to_s
+    assert_nil dr.date1
+    assert_nil dr.date2
+    assert dr.empty?
+    assert dr.blank?  # delegates to dr.empty?
+  end
+
+  def test_creation_from_dates
+    d = Date.today
+    dr = Daterange.new d, d
+    assert_nil dr.source
+    refute_nil dr.date1
+    refute_nil dr.date2
+    refute dr.empty?
+    assert_equal d.to_s, dr.to_s # because just one day
+    # assert_match(/\d\d\.\d\d\.\d\d\d\d/, dr.to_s) # default format
+    # dr = Daterange.new d, d + 1
+    # assert_match(/\d\d\.\d\d\.\d\d\d\d to \d\d.\d\d.\d\d\d\d/, dr.to_s)
+  end
+
+  def test_dates_in_reverse_order
+    d = Date.today
+    dr = Daterange.new d, d + 1
+    dr2 = Daterange.new d + 1, d
+    assert_equal(dr.to_s, dr2.to_s)
+  end
+
+  def test_illegal_strings
+    dr = Daterange.new('01/o1/2000')
+    assert_equal '', dr.to_s
+    assert_nil dr.date1
+    assert_nil dr.date2
+    refute dr.empty?  # Illegal dates do not count as empty / blank,
+    refute_nil dr.source # but the illegal string is preserved
+  end
+
+  def test_out_of_range
+    dr = Daterange.new('31/12/1879')
+    assert_equal '', dr.to_s
+    assert_nil dr.date1
+    assert_nil dr.date2
+  end
+
+  def test_year_attributes
+    dr = Daterange.new('2000')
+    assert_equal '2000', dr.source
+    assert_equal '2000', dr.to_s
+    assert_equal '01.01.2000', dr.date1.to_s
+    assert_equal '31.12.2000', dr.date2.to_s
+  end
+
+  def test_year_range_attributes
+    dr = Daterange.new('1880 2020')
+    assert_equal '01.01.1880 to 31.12.2020', dr.to_s
+    assert_equal '01.01.1880', dr.date1.to_s
+    assert_equal '31.12.2020', dr.date2.to_s
+    assert_equal '1880 2020', dr.source
+  end
+
+  def test_hyphen_month_input_style
+    dr = Daterange.new('2000-05')
+    assert_equal '05.2000', dr.to_s
+  end
+
+  def test_dot_month_input_style
+    dr = Daterange.new('06.2000')
+    assert_equal '01.06.2000', dr.date1.to_s
+    assert_equal '30.06.2000', dr.date2.to_s
+    assert_equal '06.2000', dr.to_s
+  end
+
+  def test_forwardslash_month_input_style
+    dr = Daterange.new('07/2000')
+    assert_equal '07.2000', dr.to_s
+    assert_equal '01.07.2000', dr.date1.to_s
+    assert_equal '31.07.2000', dr.date2.to_s
+  end
+
+  def test_noseparator_month_input_style
+    dr = Daterange.new('082000')
+    assert_equal '08.2000', dr.to_s
+    assert_equal '01.08.2000', dr.date1.to_s
+    assert_equal '31.08.2000', dr.date2.to_s
+  end
+
+  def test_date_to_date_input_style
+    dr = Daterange.new('01.05.2000 to 31.05.2000')
+    assert_equal '05.2000', dr.to_s
+    assert_equal '01.05.2000', dr.date1.to_s
+    assert_equal '31.05.2000', dr.date2.to_s
+    dr = Daterange.new('2000 TO 2001')
+    assert_equal '01.01.2000 to 31.12.2001', dr.to_s
+  end
+
+  def test_hyphen_date_input_style
+    dr = Daterange.new('2000-09-12')
+    assert_equal '12.09.2000', dr.to_s
+  end
+
+  def test_forwardslash_date_input_style
+    dr = Daterange.new('13/09/2000')
+    assert_equal '13.09.2000', dr.to_s
+  end
+
+  def test_dot_date_input_style
+    dr = Daterange.new('14.09.2000')
+    assert_equal '14.09.2000', dr.to_s
+  end
+
+  def test_noseparator_date_input_style
+    dr = Daterange.new('15092000')
+    assert_equal '15.09.2000', dr.to_s
+  end
+
+  def test_spen_daylight_saving
+    dr = Daterange.new('03.2010') # Span time zones (daylight saving)
+    assert_equal '03.2010', dr.to_s # Ideally '03.2010'
+  end
+
+  def test_year_intersection
+    dr1 = Daterange.new('2001')
+    dr2 = Daterange.new('2002')
+    refute dr1.intersects?(dr2)
+    refute dr2.intersects?(dr1)
+
+    dr1 = Daterange.new('2001')
+    dr2 = Daterange.new('2001')
+    assert dr1.intersects?(dr2)
+    assert dr2.intersects?(dr1)
+  end
+
+  def test_year_range_intersection
+    dr1 = Daterange.new('2001 to 2003')
+    dr2 = Daterange.new('2002 to 2004')
+    assert dr1.intersects?(dr2)
+    assert dr2.intersects?(dr1)
+  end
+
+  def test_subset_intersection
+    dr1 = Daterange.new('01.05.2000 to 31.05.2000')
+    dr2 = Daterange.new('02.05.2000 to 30.05.2000')
+    assert dr1.intersects?(dr2)
+    assert dr2.intersects?(dr1)
+  end
+
+  def test_smallest_inhabited_intersection
+    dr1 = Daterange.new('01.05.2000 to 31.05.2000')
+    dr2 = Daterange.new('01.04.2000 to 01.05.2000')
+    assert dr1.intersects?(dr2)
+    assert dr2.intersects?(dr1)
+
+    dr1 = Daterange.new('01.05.2000 to 31.05.2000')
+    dr2 = Daterange.new('31.05.2000 to 01.06.2000')
+    assert dr1.intersects?(dr2)
+    assert dr2.intersects?(dr1)
+  end
+
+  def test_disjointed_intersection
+    dr1 = Daterange.new('02.05.2000 to 31.05.2000')
+    dr2 = Daterange.new('01.04.2000 to 01.05.2000')
+    refute dr1.intersects?(dr2)
+    refute dr2.intersects?(dr1)
+  end
+
+  def test_real_empty_intersection
+    dr1 = Daterange.new
+    dr2 = Daterange.new('01.04.2000 to 01.05.2000')
+    refute dr1.intersects?(dr2)
+    refute dr2.intersects?(dr1)
+
+    dr1 = Daterange.new('01.04.2000 to 01.05.2000')
+    dr2 = Daterange.new
+    refute dr1.intersects?(dr2)
+    refute dr2.intersects?(dr1)
+  end
+
+  def test_empty_empty_intersection
+    dr1 = Daterange.new
+    dr2 = Daterange.new
+    refute dr1.intersects?(dr2)
+    refute dr2.intersects?(dr1)
+  end
+
+  def test_merge
+    dr = Daterange.merge('2001, 30.04.2005, 2003,,')
+    assert_equal '01.01.2001 to 30.04.2005', dr.to_s
+  end
+end

data/test/fixnum/calculations_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+# This tests our Fixnum calculations extension
+class Fixnum::CalculationsTest < Minitest::Test
+  test 'Fixnums should be extended with #factorial' do
+    assert 1.respond_to?(:factorial)
+  end
+
+  test 'Fixnums#factorial should behave correctly' do
+    assert_equal 1, 0.factorial
+    assert_equal 24, 4.factorial
+    assert_raises(RuntimeError) { -1.factorial }
+  end
+
+  test 'Fixnums should be extended with #choose' do
+    assert 1.respond_to?(:choose)
+  end
+
+  test 'Fixnum#choose should behave correctly' do
+    pascal_row = [1, 5, 10, 10, 5, 1]
+    pascal_row.each_with_index do |target, index|
+      assert_equal target, 5.choose(index)
+    end
+
+    assert_raises(ArgumentError) { 10.choose(11) }
+    assert_raises(ArgumentError) { 10.choose(-1) }
+  end
+end

data/test/hash_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+# This tests our Hash extension
+class HashTest < Minitest::Test
+  test 'value_by_path' do
+    my_hash = { 'one' => '1', 'two' => { 'twopointone' => '2.1', 'twopointtwo' => '2.2' } }
+    assert_equal my_hash['one'], my_hash.value_by_path('one')
+    assert_equal my_hash['two']['twopointone'], my_hash.value_by_path('two', 'twopointone')
+  end
+
+  test 'intersection' do
+    my_hash = { :a => 1, :b => :two, 'c' => '3' }
+    assert_equal({ :a => 1, 'c' => '3' }, my_hash & [:a, :c])
+    assert_equal({ :b => :two }, my_hash & [:b])
+    assert_equal({}, my_hash & [:d, :e])
+  end
+
+  test 'rawtext_merge without prevent_overwrite' do
+    first_hash = { :a => 1, :b => :two, :rawtext => { 'x' => 'apples', 'y' => 'pears' } }
+    second_hash = { :b => 2, 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }
+    assert_equal(
+      {
+        :a => 1, :b => 2, 'c' => '3',
+        :rawtext => { 'x' => 'apples', 'y' => 'pears', 'z' => 'oranges' }
+      },
+      first_hash.rawtext_merge(second_hash, false)
+    )
+    # Ensure original hashes are preserved
+    assert_equal(
+      { :a => 1, :b => :two, :rawtext => { 'x' => 'apples', 'y' => 'pears' } }, first_hash
+    )
+    assert_equal(
+      { :b => 2, 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }, second_hash
+    )
+  end
+
+  test 'rawtext_merge with prevent_overwrite on rawtext' do
+    first_hash = { :a => 1, :b => :two, :rawtext => { 'x' => 'apples', 'y' => 'pears' } }
+    second_hash = { 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }
+    assert_raises RuntimeError do
+      first_hash.rawtext_merge(second_hash, true)
+    end
+    # Ensure original hashes are preserved
+    assert_equal(
+      { :a => 1, :b => :two, :rawtext => { 'x' => 'apples', 'y' => 'pears' } }, first_hash
+    )
+    assert_equal({ 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }, second_hash)
+  end
+
+  test 'rawtext_merge with prevent_overwrite on non-rawtext' do
+    first_hash = { :a => 1, :b => :two, :rawtext => { 'x' => 'apples' } }
+    second_hash = { :b => 2, 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }
+    assert_raises RuntimeError do
+      first_hash.rawtext_merge(second_hash, true)
+    end
+    # Ensure original hashes are preserved
+    assert_equal({ :a => 1, :b => :two, :rawtext => { 'x' => 'apples' } }, first_hash)
+    assert_equal(
+      { :b => 2, 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }, second_hash
+    )
+  end
+
+  test 'rawtext_merge with one rawtext missing' do
+    first_hash = { :a => 1, :b => :two }
+    second_hash = { 'c' => '3', :rawtext => { 'x' => 'apples' } }
+    assert_equal({ :a => 1, :b => :two, 'c' => '3', :rawtext => { 'x' => 'apples' } },
+                 first_hash.rawtext_merge(second_hash, false))
+    assert_equal({ :a => 1, :b => :two, 'c' => '3', :rawtext => { 'x' => 'apples' } },
+                 second_hash.rawtext_merge(first_hash, false))
+    # Ensure original hashes are preserved
+    assert_equal({ :a => 1, :b => :two }, first_hash)
+    assert_equal({ 'c' => '3', :rawtext => { 'x' => 'apples' } }, second_hash)
+  end
+
+  test 'rawtext_merge with rawtext missing' do
+    first_hash = { :a => 1, :b => :two }
+    second_hash = { 'c' => '3' }
+    assert_equal({ :a => 1, :b => :two, 'c' => '3', :rawtext => {} },
+                 first_hash.rawtext_merge(second_hash, false))
+    # Ensure original hashes are preserved
+    assert_equal({ :a => 1, :b => :two }, first_hash)
+    assert_equal({ 'c' => '3' }, second_hash)
+  end
+end