scripref 0.12.0 → 0.13.0

data/test/test_parser.rb

@@ -12,21 +12,21 @@ class TestParser < Test::Unit::TestCase
 
   def test_only_book
     text = 'Ruth'
-    assert_parsed_ast_for_text [pass(text, 8, nil, nil, 8, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, b2: 8)], text
   end
 
   def test_book_abbrev
     text = 'Ru'
-    assert_parsed_ast_for_text [pass(text, 8, nil, nil, 8, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, b2: 8)], text
     text = 'Offb'
-    assert_parsed_ast_for_text [pass(text, 66, nil, nil, 66, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 66, b2: 66)], text
   end
 
   def test_book_abbrev_with_period
     text = 'Ru.'
-    assert_parsed_ast_for_text [pass(text, 8, nil, nil, 8, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, b2: 8)], text
     text = 'Offb.'
-    assert_parsed_ast_for_text [pass(text, 66, nil, nil, 66, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 66, b2: 66)], text
   end
 
   def test_ambiguous_book
@@ -38,115 +38,115 @@ class TestParser < Test::Unit::TestCase
 
   def test_book_and_chapter
     text = 'Ruth 2'
-    assert_parsed_ast_for_text [pass(text, 8, 2, nil, 8, 2, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, b2: 8, c2: 2)], text
   end
 
   def test_book_chapter_and_verse
     text = 'Ruth 2,5'
-    assert_parsed_ast_for_text [pass(text, 8, 2, 5, 8, 2, 5)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 5)], text
   end
 
   def test_verse_range
     text = 'Ruth 2,5-11'
-    assert_parsed_ast_for_text [pass(text, 8, 2, 5, 8, 2, 11)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 11)], text
   end
 
   def test_chapter_verse_range
     text = 'Ruth 2,5-3,7'
-    assert_parsed_ast_for_text [pass(text, 8, 2, 5, 8, 3, 7)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, v1: 5, b2: 8, c2: 3, v2: 7)], text
   end
 
   def test_chapter_range
     text = 'Ruth 2-3'
-    assert_parsed_ast_for_text [pass(text, 8, 2, nil, 8, 3, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, b2: 8, c2: 3)], text
   end
 
   def test_book_range
     text = '1. Mose - Offenbarung'
-    assert_parsed_ast_for_text [pass(text, 1, nil, nil, 66, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 1, b2: 66)], text
   end
 
   def test_book_chapter_range
     text = '1. Mose 1 - Offenbarung 22'
-    assert_parsed_ast_for_text [pass(text, 1, 1, nil, 66, 22, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 1, c1: 1, b2: 66, c2: 22)], text
   end
 
   def test_book_chapter_verse_range
     text = '1. Mose 1,1-Offenbarung 22,21'
-    assert_parsed_ast_for_text [pass(text, 1, 1, 1, 66, 22, 21)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 1, c1: 1, v1: 1, b2: 66, c2: 22, v2: 21)], text
   end
 
   def test_one_following_verse
     text = 'Ruth 2,5f'
-    assert_parsed_ast_for_text [pass(text, 8, 2, 5, 8, 2, :f)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: :f)], text
   end
 
   def test_more_following_verse
     text = 'Ruth 2,5ff'
-    assert_parsed_ast_for_text [pass(text, 8, 2, 5, 8, 2, :ff)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: :ff)], text
   end
 
   def test_first_addon
     text = 'Ruth 2,5a'
-    assert_parsed_ast_for_text [pass(text, 8, 2, 5, 8, 2, 5, a1: :a)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 5, a1: :a)], text
   end
 
   def test_second_addon
     text = 'Ruth 2,5-7a'
-    assert_parsed_ast_for_text [pass(text, 8, 2, 5, 8, 2, 7, a2: :a)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 7, a2: :a)], text
   end
 
   def test_both_addons
     text = 'Ruth 2,5b-7a'
-    assert_parsed_ast_for_text [pass(text, 8, 2, 5, 8, 2, 7, a1: :b, a2: :a)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 7, a1: :b, a2: :a)], text
   end
 
   def test_reset_addons
     @parser.parse 'Ruth 2,5b-7a'
     text = 'Ruth'
-    assert_parsed_ast_for_text [pass(text, 8, nil, nil, 8, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 8, b2: 8)], text
   end
 
   def test_book_with_only_one_chapter
     text = 'Obad 3'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 3, 31, 1, 3)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 3, b2: 31, c2: 1, v2: 3)], text
     text = 'Obad 1,3'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 3, 31, 1, 3)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 3, b2: 31, c2: 1, v2: 3)], text
     text = 'Obad 1'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 1, 31, 1, 1)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 1, b2: 31, c2: 1, v2: 1)], text
     text = 'Obad 1,1'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 1, 31, 1, 1)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 1, b2: 31, c2: 1, v2: 1)], text
   end
 
   def test_book_with_only_one_chapter_range
     text = 'Obad 3-5'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 3, 31, 1, 5)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 3, b2: 31, c2: 1, v2: 5)], text
     text = 'Obad 1,3-5'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 3, 31, 1, 5)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 3, b2: 31, c2: 1, v2: 5)], text
     text = 'Obad 1-4'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 1, 31, 1, 4)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 1, b2: 31, c2: 1, v2: 4)], text
     text = 'Obad 1,1-4'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 1, 31, 1, 4)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 1, b2: 31, c2: 1, v2: 4)], text
   end
 
   def test_book_with_only_one_chapter_at_begin_of_range
     text = 'Obad - Jona'
-    assert_parsed_ast_for_text [pass(text, 31, 1, nil, 32, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, b2: 32)], text
     text = 'Obad 3 - Jona 2,4'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 3, 32, 2, 4)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 3, b2: 32, c2: 2, v2: 4)], text
     text = 'Obad 1,3 - Jona 2,4'
-    assert_parsed_ast_for_text [pass(text, 31, 1, 3, 32, 2, 4)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 31, c1: 1, v1: 3, b2: 32, c2: 2, v2: 4)], text
   end
 
   def test_book_with_only_one_chapter_at_end_of_range
     text = 'Amos 2,4 - Obad 3'
-    assert_parsed_ast_for_text [pass(text, 30, 2, 4, 31, 1, 3)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 30, c1: 2, v1: 4, b2: 31, c2: 1, v2: 3)], text
     text = 'Amos 2,4 - Obad 1,3'
-    assert_parsed_ast_for_text [pass(text, 30, 2, 4, 31, 1, 3)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 30, c1: 2, v1: 4, b2: 31, c2: 1, v2: 3)], text
     text = 'Amos 2,4 - Obad 1'
-    assert_parsed_ast_for_text [pass(text, 30, 2, 4, 31, 1, 1)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 30, c1: 2, v1: 4, b2: 31, c2: 1, v2: 1)], text
     text = 'Amos 2,4 - Obad 1,1'
-    assert_parsed_ast_for_text [pass(text, 30, 2, 4, 31, 1, 1)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 30, c1: 2, v1: 4, b2: 31, c2: 1, v2: 1)], text
   end
 
   ######################################################################
@@ -156,49 +156,49 @@ class TestParser < Test::Unit::TestCase
   def test_two_books
     text = 'Ruth; Markus'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, nil, nil, 8, nil, nil), semi, pass(t2, 41, nil, nil, 41, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, b2: 8), semi, pass(text: t2, b1: 41, b2: 41)], text
   end
 
   def test_two_complete_refs
     text = 'Ruth 2,1; Markus 4,8'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 1, 8, 2, 1), semi, pass(t2, 41, 4, 8, 41, 4, 8)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 1, b2: 8, c2: 2, v2: 1), semi, pass(text: t2, b1: 41, c1: 4, v1: 8, b2: 41, c2: 4, v2: 8)], text
   end
 
   def test_two_refs_same_book
     text = 'Ruth 2,1; 5,4'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 1, 8, 2, 1), semi, pass(t2, 8, 5, 4, 8, 5, 4)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 1, b2: 8, c2: 2, v2: 1), semi, pass(text: t2, b1: 8, c1: 5, v1: 4, b2: 8, c2: 5, v2: 4)], text
   end
 
   def test_two_chapters_same_book
     text = 'Ruth 2; 5'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, nil, 8, 2, nil), semi, pass(t2, 8, 5, nil, 8, 5, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, b2: 8, c2: 2), semi, pass(text: t2, b1: 8, c1: 5, b2: 8, c2: 5)], text
   end
 
   def test_two_chapters_different_book
     text = 'Ruth 2; Markus 4'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, nil, 8, 2, nil), semi, pass(t2, 41, 4, nil, 41, 4, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, b2: 8, c2: 2), semi, pass(text: t2, b1: 41, c1: 4, b2: 41, c2: 4)], text
   end
 
   def test_two_verses
     text = 'Ruth 2,5.11'
     t1, t2 = text.split(dot)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 5, 8, 2, 5), dot, pass(t2, 8, 2, 11, 8, 2, 11)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 5), dot, pass(text: t2, b1: 8, c1: 2, v1: 11, b2: 8, c2: 2, v2: 11)], text
   end
 
   def test_partial_passage_after_full_passage
     text = 'Ruth 2,5; 4'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 5, 8, 2, 5), semi, pass(t2, 8, 4, nil, 8, 4, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 5), semi, pass(text: t2, b1: 8, c1: 4, b2: 8, c2: 4)], text
     text = 'Ruth 2,5; Markus'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 5, 8, 2, 5), semi, pass(t2, 41, nil, nil, 41, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 5), semi, pass(text: t2, b1: 41, b2: 41)], text
     text = 'Ruth 2,5; Markus 4'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 5, 8, 2, 5), semi, pass(t2, 41, 4, nil, 41, 4, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 5, b2: 8, c2: 2, v2: 5), semi, pass(text: t2, b1: 41, c1: 4, b2: 41, c2: 4)], text
   end
 
   ######################################################################
@@ -208,61 +208,61 @@ class TestParser < Test::Unit::TestCase
   def test_verse_range_and_separated_verse
     text = 'Ruth 2,1-3.11'
     t1, t2 = text.split(dot)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 1, 8, 2, 3), dot, pass(t2, 8, 2, 11, 8, 2, 11)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 1, b2: 8, c2: 2, v2: 3), dot, pass(text: t2, b1: 8, c1: 2, v1: 11, b2: 8, c2: 2, v2: 11)], text
   end
 
   def test_separate_verse_and_verse_range
     text = 'Ruth 2,1.3-11'
     t1, t2 = text.split(dot)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 1, 8, 2, 1), dot, pass(t2, 8, 2, 3, 8, 2, 11)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 1, b2: 8, c2: 2, v2: 1), dot, pass(text: t2, b1: 8, c1: 2, v1: 3, b2: 8, c2: 2, v2: 11)], text
   end
 
   def test_two_verse_ranges
     text = 'Ruth 2,1-3.7-11'
     t1, t2 = text.split(dot)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 1, 8, 2, 3), dot, pass(t2, 8, 2, 7, 8, 2, 11)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 1, b2: 8, c2: 2, v2: 3), dot, pass(text: t2, b1: 8, c1: 2, v1: 7, b2: 8, c2: 2, v2: 11)], text
   end
 
   def test_two_verse_range_different_books
     text = 'Ruth 2,1-11; Markus 4,3-7'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 1, 8, 2, 11), semi, pass(t2, 41, 4, 3,41, 4, 7)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 1, b2: 8, c2: 2, v2: 11), semi, pass(text: t2, b1: 41, c1: 4, v1: 3, b2: 41, c2: 4, v2: 7)], text
   end
 
   def test_two_verse_range_different_chapters
     text = 'Ruth 2,1-11; 3,10-19'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 2, 1, 8, 2, 11), semi, pass(t2, 8, 3, 10, 8, 3, 19)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 2, v1: 1, b2: 8, c2: 2, v2: 11), semi, pass(text: t2, b1: 8, c1: 3, v1: 10, b2: 8, c2: 3, v2: 19)], text
   end
 
   def test_book_range_and_following_book
     text = 'Ruth-Markus; Johannes'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, nil, nil, 41, nil, nil), semi, pass(t2, 43, nil, nil, 43, nil, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, b2: 41), semi, pass(text: t2, b1: 43, b2: 43)], text
   end
 
   def test_chapter_range_and_following_book
     text = 'Ruth 1-2; Joh 4'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 1, nil, 8, 2, nil), semi, pass(t2, 43, 4, nil, 43, 4, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 1, b2: 8, c2: 2), semi, pass(text: t2, b1: 43, c1: 4, b2: 43, c2: 4)], text
   end
 
   def test_chapter_range_and_following_chapter
     text = 'Ruth 1-2; 4'
     t1, t2 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 8, 1, nil, 8, 2, nil), semi, pass(t2, 8, 4, nil, 8, 4, nil)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 8, c1: 1, b2: 8, c2: 2), semi, pass(text: t2, b1: 8, c1: 4, b2: 8, c2: 4)], text
   end
 
   def test_book_only_after_full_passage
     text = 'Matt 3,4; Mar; Joh 3,16'
     t1, t2, t3 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 40, 3, 4, 40, 3, 4), semi, pass(t2, 41, nil, nil, 41, nil, nil), semi, pass(t3, 43, 3, 16, 43, 3, 16)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 40, c1: 3, v1: 4, b2: 40, c2: 3, v2: 4), semi, pass(text: t2, b1: 41, b2: 41), semi, pass(text: t3, b1: 43, c1: 3, v1: 16, b2: 43, c2: 3, v2: 16)], text
   end
 
   def test_chapter_only_after_full_passage
     text = 'Matt 3,4; 8; Joh 3,16'
     t1, t2, t3 = text.split(semi)
-    assert_parsed_ast_for_text [pass(t1, 40, 3, 4, 40, 3, 4), semi, pass(t2, 40, 8, nil, 40, 8, nil), semi, pass(t3, 43, 3, 16, 43, 3, 16)], text
+    assert_parsed_ast_for_text [pass(text: t1, b1: 40, c1: 3, v1: 4, b2: 40, c2: 3, v2: 4), semi, pass(text: t2, b1: 40, c1: 8, b2: 40, c2: 8), semi, pass(text: t3, b1: 43, c1: 3, v1: 16, b2: 43, c2: 3, v2: 16)], text
   end
 
   ######################################################################
@@ -273,13 +273,13 @@ class TestParser < Test::Unit::TestCase
     text = 'Ruth 2,1-11.15; 3,7.9-12; Markus 4; 5,3.18-21'
     t1, t2, t3, t4, t5, t6, t7 = text.split(/; |\./)
     ast = [
-      pass(t1, 8, 2, 1, 8, 2, 11), dot,
-      pass(t2, 8, 2, 15, 8, 2, 15), semi,
-      pass(t3, 8, 3, 7, 8, 3, 7), dot,
-      pass(t4, 8, 3, 9, 8, 3, 12), semi,
-      pass(t5, 41, 4, nil, 41, 4, nil), semi,
-      pass(t6, 41, 5, 3, 41, 5, 3), dot,
-      pass(t7, 41, 5, 18, 41, 5, 21)
+      pass(text: t1, b1: 8, c1: 2, v1: 1, b2: 8, c2: 2, v2: 11), dot,
+      pass(text: t2, b1: 8, c1: 2, v1: 15, b2: 8, c2: 2, v2: 15), semi,
+      pass(text: t3, b1: 8, c1: 3, v1: 7, b2: 8, c2: 3, v2: 7), dot,
+      pass(text: t4, b1: 8, c1: 3, v1: 9, b2: 8, c2: 3, v2: 12), semi,
+      pass(text: t5, b1: 41, c1: 4, b2: 41, c2: 4), semi,
+      pass(text: t6, b1: 41, c1: 5, v1: 3, b2: 41, c2: 5, v2: 3), dot,
+      pass(text: t7, b1: 41, c1: 5, v1: 18, b2: 41, c2: 5, v2: 21)
     ]
     assert_parsed_ast_for_text ast, text
   end
@@ -288,22 +288,20 @@ class TestParser < Test::Unit::TestCase
   # malformed references
   ######################################################################
 
-  def test_error_message
+  def test_exception_and_error_message
     text = 'Ruth 2,x'
-    begin
+    assert_raise ParserError do
       @parser.parse text
-    rescue ParserError
     end
     assert_equal 'Verse expected!', @parser.error
     formated_error = "Verse expected!\nRuth 2,x\n       ^"
     assert_equal formated_error, @parser.format_error
   end
 
-  def test_error_message_for_unambiguous_book
+  def test_exception_and_error_message_for_ambiguous_book
     text = 'Ruth 2,4; M 3,8'
-    begin
+    assert_raise ParserError do
       @parser.parse text
-    rescue ParserError
     end
     assert_match /^Abbreviation M is ambiguous/, @parser.error
     formated_error = "Abbreviation M is ambiguous it matches Micha, Maleachi, Matthäus, Markus!\nRuth 2,4; M 3,8\n          ^"
@@ -315,12 +313,22 @@ class TestParser < Test::Unit::TestCase
   ######################################################################
 
   def test_special_book_abbrev
-    # Abbrev "Phil" would technical match "Philipper" and "Philemon"
+    # Abbreviation "Phil" would technical match "Philipper" and "Philemon"
     # and therefore throw a ParserError because it's ambiguous,
     # but in German the abbrev "Phil" is generally used for "Philipper",
     # so the parser should be able to support such behaviour.
     text = 'Phil 4,4'
-    assert_parsed_ast_for_text [pass(text, 50, 4, 4, 50, 4, 4)], text
+    assert_parsed_ast_for_text [pass(text: text, b1: 50, c1: 4, v1: 4, b2: 50, c2: 4, v2: 4)], text
+    # It must also work with a dot
+    text = 'Phil. 4,4'
+    assert_parsed_ast_for_text [pass(text: text, b1: 50, c1: 4, v1: 4, b2: 50, c2: 4, v2: 4)], text
+  end
+
+  def test_book_abbrev_which_seems_to_be_ambiguous
+    # Abbreviation 'Psm' matches 'Psalm' and 'Psalmen' which is the same
+    # book so it is not an ambiguous error.
+    text = 'Psm 23,6'
+    assert_parsed_ast_for_text [pass(text: text, b1: 19, c1: 23, v1: 6, b2: 19, c2: 23, v2: 6)], text
   end
 
   private

data/test/test_passage.rb

@@ -66,24 +66,24 @@ class TestPassage < Test::Unit::TestCase
   end
 
   def test_start
-    p = pass('', 1, 2, 3, 4, 5, 6)
+    p = pass(text: '', b1: 1, c1: 2, v1: 3, b2: 4, c2: 5, v2: 6)
     assert_equal [1, 2, 3], p.start
   end
 
   def test_end
-    p = pass('', 1, 2, 3, 4, 5, 6)
+    p = pass(text: '', b1: 1, c1: 2, v1: 3, b2: 4, c2: 5, v2: 6)
     assert_equal [4, 5, 6], p.end
   end
 
   def test_sum
-    p1 = pass('', 1, 2, 3, 4, 5, 6)
-    p2 = pass('', 1, 1, 1, 1, 1, 1)
+    p1 = pass(text: '', b1: 1, c1: 2, v1: 3, b2: 4, c2: 5, v2: 6)
+    p2 = pass(text: '', b1: 1, c1: 1, v1: 1, b2: 1, c2: 1, v2: 1)
     assert_equal [2, 3, 4, 5, 6, 7], p1 + p2
   end
 
   def test_differenz
-    p1 = pass('', 1, 2, 3, 4, 5, 6)
-    p2 = pass('', 1, 1, 1, 1, 1, 1)
+    p1 = pass(text: '', b1: 1, c1: 2, v1: 3, b2: 4, c2: 5, v2: 6)
+    p2 = pass(text: '', b1: 1, c1: 1, v1: 1, b2: 1, c2: 1, v2: 1)
     assert_equal [0, 1, 2, 3, 4, 5], p2 - p1
   end
 

data/test/test_processor.rb

@@ -1,35 +1,32 @@
 # - encoding: utf-8 -
 require 'test_helper'
 
-class TestProcessor < Test::Unit::TestCase
+class TestProcessorIterators < Test::Unit::TestCase
 
   include Scripref
   include Test::Helper
 
-  def setup1
+  def setup
     @text = 'Some text Mt 1,1 and Mr 2 and so on ...'
-    @mt = [pass('Mt 1,1 ', 40, 1, 1, 40, 1, 1)]
-    @mr = [pass('Mr 2 ', 41, 2, nil, 41, 2, nil)]
+    @mt = [pass(text: 'Mt 1,1 ', b1: 40, c1: 1, v1: 1, b2: 40, c2: 1, v2: 1)]
+    @mr = [pass(text: 'Mr 2 ', b1: 41, c1: 2, b2: 41, c2: 2)]
     @processor = Processor.new(@text, German)
     @chunks = ['Some text ', @mt, 'and ', @mr, 'and so on ...']
   end
 
   def test_each_with_block
-    setup1
     @processor.each do |chunk|
       assert_equal @chunks.shift, chunk
     end
   end
 
   def test_each_without_block
-    setup1
     enum = @processor.each
     assert_kind_of Enumerator, enum
     assert_equal @chunks, enum.to_a
   end
 
   def test_each_ref_with_block
-    setup1
     refs = @chunks.select {|c| c.kind_of? Array}
     @processor.each_ref do |ref|
       assert_equal refs.shift, ref
@@ -37,16 +34,22 @@ class TestProcessor < Test::Unit::TestCase
   end
 
   def test_each_ref_without_block
-    setup1
     enum = @processor.each_ref
     refs = @chunks.select {|c| c.kind_of? Array}
     assert_kind_of Enumerator, enum
     assert_equal refs, enum.to_a
   end
 
+end
+
+class TestProcessorVariousContexts < Test::Unit::TestCase
+
+  include Scripref
+  include Test::Helper
+
   def test_reference_without_other_text
     text = 'Mt 1,1'
-    ast = [[pass('Mt 1,1 ', 40, 1, 1, 40, 1, 1)]]
+    ast = [[pass(text: 'Mt 1,1 ', b1: 40, c1: 1, v1: 1, b2: 40, c2: 1, v2: 1)]]
     processor = Processor.new(text, German)
     assert_equal ast, processor.each_ref.to_a
     assert_equal ast, processor.each.to_a
@@ -69,47 +72,73 @@ class TestProcessor < Test::Unit::TestCase
   def test_numerical_context
     text = '1. Mt 1,1'
     processor = Processor.new(text, German)
-    ast = [[pass(text, 40, 1, 1, 40, 1, 1)]]
+    ast = [[pass(text: text, b1: 40, c1: 1, v1: 1, b2: 40, c2: 1, v2: 1)]]
     assert_equal ast, processor.each_ref.to_a
-    ast = ['1. ', [pass(text, 40, 1, 1, 40, 1, 1)]]
+    ast = ['1. ', [pass(text: text, b1: 40, c1: 1, v1: 1, b2: 40, c2: 1, v2: 1)]]
     assert_equal ast, processor.each.to_a
   end
 
   def test_verse_addon_or_postfix
     text = 'Mt 1,1a'
     processor = Processor.new(text, German)
-    ast = [[pass(text, 40, 1, 1, 40, 1, 1, a1: 'a')]]
+    ast = [[pass(text: text, b1: 40, c1: 1, v1: 1, b2: 40, c2: 1, v2: 1, a1: 'a')]]
     assert_equal ast, processor.each.to_a
     text = 'Mt 1,1f'
     processor = Processor.new(text, German)
-    ast = [[pass(text, 40, 1, 1, 40, 1, :f)]]
+    ast = [[pass(text: text, b1: 40, c1: 1, v1: 1, b2: 40, c2: 1, v2: :f)]]
     assert_equal ast, processor.each.to_a
     text = 'Mt 1,1ff'
     processor = Processor.new(text, German)
-    ast = [[pass(text, 40, 1, 1, 40, 1, :ff)]]
+    ast = [[pass(text: text, b1: 40, c1: 1, v1: 1, b2: 40, c2: 1, v2: :ff)]]
     assert_equal ast, processor.each.to_a
   end
 
   def test_verse_addon_or_postfix_for_books_with_only_one_chapter
     text = '2. Joh 5b'
     processor = Processor.new(text, German)
-    ast = [[pass(text, 63, 1, 5, 63, 1, 5, a1: 'b')]]
+    ast = [[pass(text: text, b1: 63, c1: 1, v1: 5, b2: 63, c2: 1, v2: 5, a1: 'b')]]
     assert_equal ast, processor.each.to_a
     text = '2. Joh 5f'
     processor = Processor.new(text, German)
-    ast = [[pass(text, 63, 1, 5, 63, 1, :f)]]
+    ast = [[pass(text: text, b1: 63, c1: 1, v1: 5, b2: 63, c2: 1, v2: :f)]]
     assert_equal ast, processor.each.to_a
     text = '2. Joh 5ff'
     processor = Processor.new(text, German)
-    ast = [[pass(text, 63, 1, 5, 63, 1, :ff)]]
+    ast = [[pass(text: text, b1: 63, c1: 1, v1: 5, b2: 63, c2: 1, v2: :ff)]]
     assert_equal ast, processor.each.to_a
   end
 
   def test_verse_sep
     text = '2. Joh 5.8'
     processor = Processor.new(text, German)
-    ast = [[pass(text, 63, 1, 5, 63, 1, 5), '.', pass(text, 63, 1, 8, 63, 1, 8)]]
+    ast = [[pass(text: text, b1: 63, c1: 1, v1: 5, b2: 63, c2: 1, v2: 5), '.', pass(text: text, b1: 63, c1: 1, v1: 8, b2: 63, c2: 1, v2: 8)]]
     assert_equal ast, processor.each.to_a
   end
 
+  def test_complex_reference
+    prefix = 'Wie in den Stellen '
+    ref = 'Apg 2,3; 4,8; 7,55; 8,29-39; Röm 8,2-9; Gal 6,8 '
+    postfix = 'nachzulesen ...'
+    text = prefix + ref + postfix
+    processor = Processor.new(text, German)
+    ast = [pass(text: 'Apg 2,3', b1: 44, c1: 2, v1: 3, b2: 44, c2: 2, v2: 3), '; ', pass(text: '4,8', b1: 44, c1: 4, v1: 8, b2: 44, c2: 4, v2: 8), '; ',
+            pass(text: '7,55', b1: 44, c1: 7, v1: 55, b2: 44, c2: 7, v2: 55), '; ', pass(text: '8,29-39', b1: 44, c1: 8, v1: 29, b2: 44, c2: 8, v2: 39), '; ',
+            pass(text: 'Röm 8,2-9', b1: 45, c1: 8, v1: 2, b2: 45, c2: 8, v2: 9), '; ', pass(text: 'Gal 6,8 ', b1: 48, c1: 6, v1: 8, b2: 48, c2: 6, v2: 8)]
+    assert_equal [ast], processor.each_ref.to_a
+    assert_equal [prefix, ast, postfix], processor.each.to_a
+  end
+
+  def test_reference_ends_with_chapter_or_verse
+    text = 'Joh 8.'
+    processor = Processor.new(text, German)
+    ast = [pass(text: 'Joh 8', b1: 43, c1: 8, b2: 43, c2: 8)]
+    assert_equal [ast], processor.each_ref.to_a
+    assert_equal [ast, '.'], processor.each.to_a
+    text = 'Joh 8,12.'
+    processor = Processor.new(text, German)
+    ast = [pass(text: 'Joh 8,12', b1: 43, c1: 8, v1: 12, b2: 43, c2: 8, v2: 12)]
+    assert_equal [ast], processor.each_ref.to_a
+    assert_equal [ast, '.'], processor.each.to_a
+  end
+
 end

metadata

@@ -1,49 +1,64 @@
 --- !ruby/object:Gem::Specification
 name: scripref
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Jan Friedrich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-06 00:00:00.000000000 Z
+date: 2020-04-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rim
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.9'
+        version: '2.17'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.9'
+        version: '2.17'
 - !ruby/object:Gem::Dependency
   name: regtest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '2'
 description: ''
 email: janfri26@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- "./.aspell.pws"
 - Changelog
 - LICENSE
 - README.md
@@ -66,6 +81,7 @@ files:
 - regtest/parser.yml
 - regtest/processor.rb
 - regtest/processor.yml
+- scripref.gemspec
 - test/test_bookname.rb
 - test/test_english.rb
 - test/test_formatter.rb
@@ -87,15 +103,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Library for parsing scripture references in real texts.