pericope 0.7.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e48633c3d81555ea2a699d359437bcbebfae2c3
-  data.tar.gz: b9017728cd671d4c9d24ed5612ffbf6459e38068
+  metadata.gz: 145908194097992ca18effe78d077c9ab4056e75
+  data.tar.gz: 88d93e6cb4e92b429ee3b0d3e559bd4c1f874aa1
 SHA512:
-  metadata.gz: 280f67bd0faf5654e48a15971ef1874df15b3a5802ad146b27367acb3dc95b3758278c889bf77ab0708c51ecd42886c92340ab825dda1b8880d433478dd8e0fd
-  data.tar.gz: e14e5dadefe61d965613f312d4b14e67566837ef248ae3b0d6bf2abb726f905397760d20b779d314e0b9b8e7327ac8e6fc7f8b2fdd17533fedea7c0ba1702ae8
+  metadata.gz: 72b6bc51a94abdbfbdcb842359d98ca9ca68c8c802c7e4c27c63237ddf66952fda859b64a9782c5b1f909658c4bbf2ac6d3ec073c9ea9f166885a10f8179725a
+  data.tar.gz: 109fe8d1a3eaffa62485d55db3febc29f68a5410592b8d1334610c6d7729575ea59cd2a9118e7e218e2311138356354023966501802f3730b222c5053721cf11

data/lib/pericope.rb

@@ -1,187 +1,171 @@
 require "pericope/version"
 require "pericope/data"
+require "pericope/parsing"
 
 class Pericope
-  attr_reader :book, :book_chapter_count, :book_name, :original_string, :ranges
+  extend Pericope::Parsing
+  include Enumerable
+
+  attr_reader :book, :original_string, :ranges
+
 
   def initialize(arg)
     case arg
     when String
       attributes = Pericope.match_one(arg)
-      raise "no pericope found in #{arg} (#{arg.class})" if attributes.nil?
+      raise ArgumentError, "no pericope found in #{arg}" if attributes.nil?
 
       @original_string = attributes[:original_string]
-      set_book attributes[:book]
+      @book = attributes[:book]
       @ranges = attributes[:ranges]
 
     when Array
-      arg = arg.map(&:to_i)
-      set_book Pericope.get_book(arg.first)
-      @ranges = Pericope.group_array_into_ranges(arg)
-
-    when Range
-      STDERR.puts "DEPRECATION WARNING: instantiating a pericope with a single range is deprecated and will be removed in pericope 1.0.",
-           "",
-           "   You can change `Pericope.new(range)` to `Pericope.new(range.to_a)`",
-           ""
-      set_book Pericope.get_book(arg.begin)
-      @ranges = [arg]
+      @ranges = group_array_into_ranges(arg)
+      @book = @ranges.first.begin.book
 
     else
-      attributes = arg
-      @original_string = attributes[:original_string]
-      set_book attributes[:book]
-      @ranges = attributes[:ranges]
+      @original_string = arg[:original_string]
+      @book = arg[:book]
+      @ranges = arg[:ranges]
 
     end
+    raise ArgumentError, "must specify book" unless @book
   end
 
 
-
-  def self.book_has_chapters?(book)
-    BOOK_CHAPTER_COUNTS[book] > 1
-  end
-
   def book_has_chapters?
     book_chapter_count > 1
   end
 
-
-
-  # Differs from Pericope.new in that it won't raise an exception
-  # if text does not contain a pericope but will return nil instead.
-  def self.parse_one(text)
-    parse(text) do |pericope|
-      return pericope
-    end
-    nil
+  def book_name
+    @book_name ||= Pericope::BOOK_NAMES[@book]
   end
 
+  def book_chapter_count
+    @book_chapter_count ||= Pericope::BOOK_CHAPTER_COUNTS[@book]
+  end
 
 
-  def self.parse(text)
-    pericopes = []
-    match_all(text) do |attributes|
-      pericope = Pericope.new(attributes)
-      if block_given?
-        yield pericope
-      else
-        pericopes << pericope
-      end
-    end
-    block_given? ? text : pericopes
+  def to_s(options={})
+    "#{book_name} #{well_formatted_reference(options)}"
   end
 
+  def inspect
+    "Pericope(#{to_s})"
+  end
 
 
-  def self.split(text)
-    segments = []
-    start = 0
-
-    match_all(text) do |attributes, match|
+  def ==(other)
+    other.is_a?(self.class) && [book, ranges] == [other.book, other.ranges]
+  end
 
-      pretext = text.slice(start...match.begin(0))
-      if pretext.length > 0
-        segments << pretext
-        yield pretext if block_given?
-      end
+  def hash
+    [book, ranges].hash
+  end
 
-      pericope = Pericope.new(attributes)
-      segments << pericope
-      yield pericope if block_given?
+  def <=>(other)
+    to_a <=> other.to_a
+  end
 
-      start = match.end(0)
-    end
+  def intersects?(other)
+    return false unless other.is_a?(Pericope)
+    return false unless book == other.book
 
-    pretext = text.slice(start...text.length)
-    if pretext.length > 0
-      segments << pretext
-      yield pretext if block_given?
+    ranges.each do |self_range|
+      other.ranges.each do |other_range|
+        return true if (self_range.end >= other_range.begin) and (self_range.begin <= other_range.end)
+      end
     end
 
-    segments
+    false
   end
 
 
+  def each
+    return to_enum unless block_given?
 
-  def self.sub(text)
-    STDERR.puts "DEPRECATION WARNING: Pericope.sub is deprecated and will be removed in pericope 1.0.",
-         "",
-         "   You can use `Pericope.split` with `inject` to replace pericopes in a block of text",
-         ""
-
-    split(text).inject("") do |text, segment|
-      if segment.is_a?(String)
-        text << segment
-      else
-        text << "{{#{segment.to_a.join(" ")}}}"
+    ranges.each do |range|
+      range.each do |verse|
+        yield verse
       end
     end
+
+    self
   end
 
 
+  class << self
+    attr_reader :max_letter
 
-  def self.rsub(text)
-    STDERR.puts "DEPRECATION WARNING: Pericope.rsub is deprecated and will be removed in pericope 1.0."
+    def max_letter=(value)
+      unless @max_letter == value
+        @max_letter = value.freeze
+        @_letters = nil
+        @_regexp = nil
+        @_normalizations = nil
+        @_letter_regexp = nil
+        @_fragment_regexp = nil
+      end
+    end
 
-    text.gsub(/\{\{(\d{7,8} ?)+\}\}/) do |match|
-      ids = match[2...-2].split.collect(&:to_i)
-      Pericope.new(ids).to_s
+    def book_has_chapters?(book)
+      BOOK_CHAPTER_COUNTS[book] > 1
     end
-  end
 
+    def get_max_verse(book, chapter)
+      id = (book * 1000000) + (chapter * 1000)
+      CHAPTER_VERSE_COUNTS[id]
+    end
 
+    def get_max_chapter(book)
+      BOOK_CHAPTER_COUNTS[book]
+    end
 
-  def to_s(options={})
-    "#{book_name} #{well_formatted_reference(options)}"
-  end
+    def regexp
+      @_regexp ||= /#{book_pattern}\.?\s*(#{reference_pattern})/i
+    end
 
-  def inspect
-    "Pericope(#{to_s})"
-  end
+    def normalizations
+      @_normalizations ||= [
+        [/(\d+)[".](\d+)/, '\1:\2'],        # 12"5 and 12.5 -> 12:5
+        [/[–—]/,           '-'],            # convert em dash and en dash to -
+        [/[^0-9,:;\-–—#{letters}]/,  ''] ]  # remove everything but recognized symbols
+    end
 
-  def ==(other)
-    other.is_a?(self.class) && [book, ranges] == [other.book, other.ranges]
-  end
+    def letter_regexp
+      @_letter_regexp ||= /[#{letters}]$/
+    end
 
-  def hash
-    [book, ranges].hash
-  end
+    def fragment_regexp
+      @_fragment_regexp ||= /^(?:(?<chapter>\d{1,3}):)?(?<verse>\d{1,3})?(?<letter>[#{letters}])?$/
+    end
 
-  def <=>(other)
-    to_a <=> other.to_a
-  end
+  private
 
+    def book_pattern
+      BOOK_PATTERN.source.gsub(/[ \n]/, "")
+    end
 
+    def reference_pattern
+      number = '\d{1,3}'
+      verse = "#{number}[#{letters}]?"
+      chapter_verse_separator = '\s*[:"\.]\s*'
+      list_or_range_separator = '\s*[\-–—,;]\s*'
+      chapter_and_verse = "(?:#{number + chapter_verse_separator})?" + verse
+      chapter_and_verse_or_letter = "(?:#{chapter_and_verse}|[#{letters}])"
+      chapter_and_verse + "(?:#{list_or_range_separator + chapter_and_verse_or_letter})*"
+    end
 
-  def to_a
-    # one range per chapter
-    chapter_ranges = []
-    ranges.each do |range|
-      min_chapter = Pericope.get_chapter(range.begin)
-      max_chapter = Pericope.get_chapter(range.end)
-      if min_chapter == max_chapter
-        chapter_ranges << range
-      else
-        chapter_ranges << Range.new(range.begin, Pericope.get_last_verse(book, min_chapter))
-        for chapter in (min_chapter+1)...max_chapter
-          chapter_ranges << Range.new(
-            Pericope.get_first_verse(book, chapter),
-            Pericope.get_last_verse(book, chapter))
-        end
-        chapter_ranges << Range.new(Pericope.get_first_verse(book, max_chapter), range.end)
-      end
+    def letters
+      @_letters ||= ("a"..max_letter).to_a.join
     end
 
-    chapter_ranges.inject([]) {|array, range| array.concat(range.to_a)}
   end
 
 
+private
 
   def well_formatted_reference(options={})
-    recent_chapter = nil # e.g. in 12:1-8, remember that 12 is the chapter when we parse the 8
-    recent_chapter = 1 unless book_has_chapters?
-
     verse_range_separator = options.fetch(:verse_range_separator, "–") # en-dash
     chapter_range_separator = options.fetch(:chapter_range_separator, "—") # em-dash
     verse_list_separator = options.fetch(:verse_list_separator, ", ")
@@ -189,353 +173,64 @@ class Pericope
     always_print_verse_range = options.fetch(:always_print_verse_range, false)
     always_print_verse_range = true unless book_has_chapters?
 
-    s = ""
-    ranges.each_with_index do |range, i|
-      min_chapter = Pericope.get_chapter(range.begin)
-      min_verse = Pericope.get_verse(range.begin)
-      max_chapter = Pericope.get_chapter(range.end)
-      max_verse = Pericope.get_verse(range.end)
+    recent_chapter = nil # e.g. in 12:1-8, remember that 12 is the chapter when we parse the 8
+    recent_chapter = 1 unless book_has_chapters?
+    recent_verse = nil
 
+    ranges.each_with_index.each_with_object("") do |(range, i), s|
       if i > 0
-        if recent_chapter == min_chapter
+        if recent_chapter == range.begin.chapter
           s << verse_list_separator
         else
           s << chapter_list_separator
         end
       end
 
-      if min_verse == 1 && max_verse >= Pericope.get_max_verse(book, max_chapter) && !always_print_verse_range
-        s << min_chapter.to_s
-        s << "#{chapter_range_separator}#{max_chapter}" if max_chapter > min_chapter
+      last_verse = Pericope.get_max_verse(book, range.end.chapter)
+      if !always_print_verse_range && range.begin.verse == 1 && range.begin.whole? && (range.end.verse > last_verse || range.end.whole? && range.end.verse == last_verse)
+        s << range.begin.chapter.to_s
+        s << "#{chapter_range_separator}#{range.end.chapter}" if range.end.chapter > range.begin.chapter
       else
-        if recent_chapter == min_chapter
-          s << min_verse.to_s
+        if range.begin.partial? && range.begin.verse == recent_verse
+          s << range.begin.letter
         else
-          recent_chapter = min_chapter
-          s << "#{min_chapter}:#{min_verse}"
+          s << range.begin.to_s(with_chapter: recent_chapter != range.begin.chapter)
         end
 
-        if range.count > 1
-
-          if min_chapter == max_chapter
-            s << "#{verse_range_separator}#{max_verse}"
+        if range.begin != range.end
+          if range.begin.chapter == range.end.chapter
+            s << "#{verse_range_separator}#{range.end}"
           else
-            recent_chapter = max_chapter
-            s << "#{chapter_range_separator}#{max_chapter}:#{max_verse}"
+            s << "#{chapter_range_separator}#{range.end.to_s(with_chapter: true)}"
           end
         end
-      end
-    end
-
-    s
-  end
-
-
 
-  def intersects?(pericope)
-    return false unless pericope.is_a?(Pericope)
-    return false unless book == pericope.book
-
-    ranges.each do |self_range|
-      pericope.ranges.each do |other_range|
-        return true if (self_range.end >= other_range.begin) and (self_range.begin <= other_range.end)
+        recent_chapter = range.end.chapter
+        recent_verse = range.end.verse if range.end.partial?
       end
     end
-
-    false
-  end
-
-
-
-  def self.get_max_verse(book, chapter)
-    id = (book * 1000000) + (chapter * 1000)
-    CHAPTER_VERSE_COUNTS[id]
-  end
-
-  def self.get_max_chapter(book)
-    BOOK_CHAPTER_COUNTS[book]
-  end
-
-
-
-private
-
-
-
-  def set_book(value)
-    @book = value || raise(ArgumentError, "must specify book")
-    @book_name = Pericope::BOOK_NAMES[@book]
-    @book_chapter_count = Pericope::BOOK_CHAPTER_COUNTS[@book]
-  end
-
-
-
-  def self.get_first_verse(book, chapter)
-    get_id(book, chapter, 1)
   end
 
-  def self.get_last_verse(book, chapter)
-    get_id(book, chapter, get_max_verse(book, chapter))
-  end
-
-  def self.get_next_verse(id)
-    id + 1
-  end
-
-  def self.get_start_of_next_chapter(id)
-    book = get_book(id)
-    chapter = get_chapter(id) + 1
-    verse = 1
-    get_id(book, chapter, verse)
-  end
-
-  def self.to_valid_book(book)
-    coerce_to_range(book, 1..66)
-  end
-
-  def self.to_valid_chapter(book, chapter)
-    coerce_to_range(chapter, 1..get_max_chapter(book))
-  end
-
-  def self.to_valid_verse(book, chapter, verse)
-    coerce_to_range(verse, 1..get_max_verse(book, chapter))
-  end
+  def group_array_into_ranges(verses)
+    return [] if verses.nil? or verses.empty?
 
-  def self.coerce_to_range(number, range)
-    return range.begin if number < range.begin
-    return range.end if number > range.end
-    number
-  end
-
-  def self.get_id(book, chapter, verse)
-    book = to_valid_book(book)
-    chapter = to_valid_chapter(book, chapter)
-    verse = to_valid_verse(book, chapter, verse)
-
-    (book * 1000000) + (chapter * 1000) + verse
-  end
-
-  def self.get_book(id)
-    id / 1000000 # the book is everything left of the least significant 6 digits
-  end
-
-  def self.get_chapter(id)
-    (id % 1000000) / 1000 # the chapter is the 3rd through 6th most significant digits
-  end
-
-  def self.get_verse(id)
-    id % 1000 # the verse is the 3 least significant digits
-  end
-
-
-
-  def self.group_array_into_ranges(array)
-    return [] if array.nil? or array.empty?
-
-    array.flatten!
-    array.compact!
-    array.sort!
+    verses = verses.flatten.compact.sort.map { |verse| Verse.parse(verse) }
 
     ranges = []
-    range_start = array.shift
-    range_end = range_start
-    while true
-      next_value = array.shift
-      break if next_value.nil?
-
-      if (next_value == get_next_verse(range_end)) ||
-         (next_value == get_start_of_next_chapter(range_end))
-        range_end = next_value
+    range_begin = verses.shift
+    range_end = range_begin
+    while verse = verses.shift
+      if verse > range_end.next
+        ranges << Range.new(range_begin, range_end)
+        range_begin = range_end = verse
       else
-        ranges << (range_start..range_end)
-        range_start = range_end = next_value
+        range_end = verse
       end
     end
-    ranges << (range_start..range_end)
-
-    ranges
-  end
-
-
-
-  # matches the first valid Bible reference in the supplied string
-  def self.match_one(text)
-    match_all(text) do |attributes|
-      return attributes
-    end
-    nil
-  end
-
-
-
-  # matches all valid Bible references in the supplied string
-  def self.match_all(text)
-    text.scan(Pericope::PERICOPE_PATTERN) do
-      match = Regexp.last_match
-      book = BOOK_IDS[match.captures.find_index(&:itself)]
-
-      ranges = parse_reference(book, match[67])
-      next if ranges.empty?
-
-      attributes = {
-        :original_string => match.to_s,
-        :book => book,
-        :ranges => ranges
-      }
-
-      yield attributes, match
-    end
-  end
-
-  def self.parse_reference(book, reference)
-    parse_ranges(book, normalize_reference(reference).split(/[,;]/))
-  end
 
-  def self.normalize_reference(reference)
-    NORMALIZATIONS.reduce(reference.to_s) { |reference, (regex, replacement)| reference.gsub(regex, replacement) }
+    ranges << Range.new(range_begin, range_end)
   end
 
-  def self.parse_ranges(book, ranges)
-    recent_chapter = nil # e.g. in 12:1-8, remember that 12 is the chapter when we parse the 8
-    recent_chapter = 1 if !book_has_chapters?(book)
-    ranges.map do |range|
-      range = range.split('-') # parse the low end of a verse range and the high end separately
-      range << range[0] if (range.length < 2) # treat 12:4 as 12:4-12:4
-      lower_chapter_verse = range[0].split(':').map(&:to_i) # parse "3:28" to [3,28]
-      upper_chapter_verse = range[1].split(':').map(&:to_i) # parse "3:28" to [3,28]
-
-      # treat Mark 3-1 as Mark 3-3 and, eventually, Mark 3:1-35
-      if (lower_chapter_verse.length == 1) &&
-         (upper_chapter_verse.length == 1) &&
-         (upper_chapter_verse[0] < lower_chapter_verse[0])
-        upper_chapter_verse = lower_chapter_verse.dup
-      end
-
-      # make sure the low end of the range and the high end of the range
-      # are composed of arrays with two appropriate values: [chapter, verse]
-      chapter_range = false
-      if lower_chapter_verse.length < 2
-        if recent_chapter
-          lower_chapter_verse.unshift recent_chapter # e.g. parsing 11 in 12:1-8,11 => remember that 12 is the chapter
-        else
-          lower_chapter_verse[0] = Pericope.to_valid_chapter(book, lower_chapter_verse[0])
-          lower_chapter_verse << 1 # no verse specified; this is a range of chapters, start with verse 1
-          chapter_range = true
-        end
-      else
-        lower_chapter_verse[0] = Pericope.to_valid_chapter(book, lower_chapter_verse[0])
-      end
-      lower_chapter_verse[1] = Pericope.to_valid_verse(book, *lower_chapter_verse)
-
-      if upper_chapter_verse.length < 2
-        if chapter_range
-          upper_chapter_verse[0] = Pericope.to_valid_chapter(book, upper_chapter_verse[0])
-          upper_chapter_verse << Pericope.get_max_verse(book, upper_chapter_verse[0]) # this is a range of chapters, end with the last verse
-        else
-          upper_chapter_verse.unshift lower_chapter_verse[0] # e.g. parsing 8 in 12:1-8 => remember that 12 is the chapter
-        end
-      else
-        upper_chapter_verse[0] = Pericope.to_valid_chapter(book, upper_chapter_verse[0])
-      end
-      upper_chapter_verse[1] = Pericope.to_valid_verse(book, *upper_chapter_verse)
-
-      recent_chapter = upper_chapter_verse[0] # remember the last chapter
-
-      Range.new(
-        Pericope.get_id(book, *lower_chapter_verse),
-        Pericope.get_id(book, *upper_chapter_verse))
-    end
-  end
-
-
-
-  BOOK_PATTERN = %r{\b(?:
-      (?:(?:3|iii|third|3rd)\s*(?:
-        (john|joh|jon|jhn|jh|jo|jn)
-      ))|
-      (?:(?:2|ii|second|2nd)\s*(?:
-        (samuels|samuel|sam|sa|sm)|
-        (kings|king|kngs|kgs|kg|k)|
-        (chronicles|chronicle|chron|chrn|chr)|
-        (john|joh|jon|jhn|jh|jo|jn)|
-        (corinthians?|cor?|corint?h?|corth)|
-        (thessalonians?|thes{1,}|the?s?)|
-        (timothy|tim|tm|ti)|
-        (peter|pete|pet|ptr|pe|pt|pr)
-      ))|
-      (?:(?:1|i|first|1st)\s*(?:
-        (samuels|samuel|sam|sa|sm)|
-        (kings|king|kngs|kgs|kg|k)|
-        (chronicles|chronicle|chron|chrn|chr)|
-        (john|joh|jon|jhn|jh|jo|jn)|
-        (corinthians?|cor?|corint?h?|corth)|
-        (thessalonians?|thes{1,}|the?s?)|
-        (timothy|tim|tm|ti)|
-        (peter|pete|pet|ptr|pe|pt|pr)
-      ))|
-      (genesis|gen|gn|ge)|
-      (exodus|exod|exo|exd|ex)|
-      (leviticus|lev|levi|le|lv)|
-      (numbers|number|numb|num|nmb|nu|nm)|
-      (deuteronomy|deut|deu|dt)|
-      (joshua|josh|jsh|jos)|
-      (judges|jdgs|judg|jdg)|
-      (ruth|rut|rth|ru)|
-      (isaiah|isa|is|ia|isai|isah)|
-      (ezra|ezr)|
-      (nehemiah|neh|ne)|
-      (esther|esth|est|es)|
-      (job|jb)|
-      (psalms|psalm|pslms|pslm|psm|psa|ps)|
-      (proverbs|proverb|prov|prv|prvb|prvbs|pv)|
-      (ecclesiastes|eccles|eccl|ecc|ecl)|
-      ((?:the\s?)?song\s?of\s?solomon|(?:the\s?)?song\s?of\s?songs|sn?gs?|songs?|so?s|sol?|son|s\s?of\s?\ss)|
-      (jeremiah?|jer?|jr|jere)|
-      (lamentations?|lam?|lm)|
-      (ezekiel|ezek|eze|ezk)|
-      (daniel|dan|dn|dl|da)|
-      (hosea|hos|ho|hs)|
-      (joel|jl)|
-      (amos|amo|ams|am)|
-      (obadiah|obadia|obad|oba|obd|ob)|
-      (jonah|jon)|
-      (micah|mica|mic|mi)|
-      (nahum|nah|nahu|na)|
-      (habakk?uk|habk?)|
-      (zephaniah?|ze?ph?)|
-      (haggai|ha?gg?)|
-      (zechariah?|ze?ch?)|
-      (malachi|mal)|
-      (matthew|matt|mat|ma|mt)|
-      (mark|mrk|mk)|
-      (luke|luk|lk|lu)|
-      (john|joh|jon|jhn|jh|jo|jn)|
-      (acts|act|ac)|
-      (romans|roman|roms|rom|rms|ro|rm)|
-      (galatians|galatian|galat|gala|gal|ga)|
-      (ephesians?|eph?|ephe?s?)|
-      (philippians?|phi?l|php|phi|philipp?)|
-      (colossi?ans?|col?)|
-      (titus|tit|ti)|
-      (philemon|phl?mn?|philem?)|
-      (hebrews|hebrew|heb)|
-      (james|jam|jas|jm|js|ja)|
-      (jude)|
-      (revelations|revelation|revel|rev|rv|re)
-  )}ix.freeze
-
-  # The order books of the Bible are matched
-  BOOK_IDS = [ 64, 10, 12, 14, 63, 47, 53, 55, 61, 9, 11, 13, 62, 46, 52, 54, 60, 1, 2, 3, 4, 5, 6,  7, 8, 23, 15, 16, 17, 18, 19, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 48, 49, 50, 51, 56, 57, 58, 59, 65, 66 ].freeze
-
-  BOOK_NAMES = [nil, "Genesis", "Exodus", "Leviticus", "Numbers", "Deuteronomy", "Joshua", "Judges", "Ruth", "1 Samuel", "2 Samuel", "1 Kings", "2 Kings", "1 Chronicles", "2 Chronicles", "Ezra", "Nehemiah", "Esther", "Job", "Psalm", "Proverbs", "Ecclesiastes", "Song of Solomon", "Isaiah", "Jeremiah", "Lamentations", "Ezekiel", "Daniel", "Hosea", "Joel", "Amos", "Obadiah", "Jonah", "Micah", "Nahum", "Habakkuk", "Zephaniah", "Haggai", "Zechariah", "Malachi", "Matthew", "Mark", "Luke", "John", "Acts", "Romans", "1 Corinthians", "2 Corinthians", "Galatians", "Ephesians", "Philippians", "Colossians", "1 Thessalonians", "2 Thessalonians", "1 Timothy", "2 Timothy", "Titus", "Philemon", "Hebrews", "James", "1 Peter", "2 Peter", "1 John", "2 John", "3 John", "Jude", "Revelation"].freeze
-
-  REFERENCE_PATTERN = '(?:\s*\d{1,3})(?:\s*[:\"\.]\s*\d{1,3}[ab]?(?:\s*[,;]\s*(?:\d{1,3}[:\"\.])?\s*\d{1,3}[ab]?)*)?(?:\s*[-–—]\s*(?:\d{1,3}\s*[:\"\.])?(?:\d{1,3}[ab]?)(?:\s*[,;]\s*(?:\d{1,3}\s*[:\"\.])?\s*\d{1,3}[ab]?)*)*'
-
-  PERICOPE_PATTERN = /#{BOOK_PATTERN.source.gsub(/[ \n]/, "")}\.?(#{REFERENCE_PATTERN})/i
-
-  NORMALIZATIONS = [
-    [/(\d+)[".](\d+)/, '\1:\2'], # 12"5 and 12.5 -> 12:5
-    [/[–—]/,           '-'],     # convert em dash and en dash to -
-    [/[^0-9,:;\-–—]/,  '']       # remove everything but [0-9,;:-]
-  ]
 end
+
+Pericope.max_letter = "d"

data/lib/pericope/cli.rb

@@ -4,11 +4,7 @@ require "cli/base"
 class Pericope
   class CLI
 
-
-
-    ALLOWED_COMMANDS = %w{help normalize parse substitute reverse-substitute usage}
-
-
+    ALLOWED_COMMANDS = %w{help normalize parse usage}
 
     def self.run(command, *args)
       if ALLOWED_COMMANDS.member?(command)
@@ -56,26 +52,6 @@ Glossary
 
 
 
-    def substitute
-      begin
-        print Pericope.sub(input)
-      rescue
-        print $!.to_s
-      end
-    end
-
-
-
-    def reverse_substitute
-      begin
-        print Pericope.rsub(input)
-      rescue
-        print $!.to_s
-      end
-    end
-
-
-
     def usage
       print <<-USAGE
 
@@ -88,8 +64,6 @@ Commands
   help                Prints more information about pericope
   normalize           Accepts a pericope and returns a properly-formatted pericope
   parse               Accepts a pericope and returns a list of verse IDs
-  substitute          Accepts a block of text and replaces all pericopes in the text with verse IDs
-  reverse-substitute  Accepts a block of text and replaces collections of verse IDs with pericopes
   usage               Prints this message
 
       USAGE

data/lib/pericope/parsing.rb

@@ -0,0 +1,264 @@
+require "pericope/range"
+require "pericope/verse"
+
+class Pericope
+  module Parsing
+
+    # Differs from Pericope.new in that it won't raise an exception
+    # if text does not contain a pericope but will return nil instead.
+    def parse_one(text)
+      parse(text) do |pericope|
+        return pericope
+      end
+      nil
+    end
+
+    def parse(text)
+      pericopes = []
+      match_all(text) do |attributes|
+        pericope = Pericope.new(attributes)
+        if block_given?
+          yield pericope
+        else
+          pericopes << pericope
+        end
+      end
+      block_given? ? text : pericopes
+    end
+
+    def split(text)
+      segments = []
+      start = 0
+
+      match_all(text) do |attributes, match|
+
+        pretext = text.slice(start...match.begin(0))
+        if pretext.length > 0
+          segments << pretext
+          yield pretext if block_given?
+        end
+
+        pericope = Pericope.new(attributes)
+        segments << pericope
+        yield pericope if block_given?
+
+        start = match.end(0)
+      end
+
+      pretext = text.slice(start...text.length)
+      if pretext.length > 0
+        segments << pretext
+        yield pretext if block_given?
+      end
+
+      segments
+    end
+
+    def match_one(text)
+      match_all(text) do |attributes|
+        return attributes
+      end
+      nil
+    end
+
+    def match_all(text)
+      text.scan(Pericope.regexp) do
+        match = Regexp.last_match
+        book = BOOK_IDS[match.captures.find_index(&:itself)]
+
+        ranges = parse_reference(book, match[67])
+        next if ranges.empty?
+
+        attributes = {
+          :original_string => match.to_s,
+          :book => book,
+          :ranges => ranges
+        }
+
+        yield attributes, match
+      end
+    end
+
+    def parse_reference(book, reference)
+      parse_ranges(book, normalize_reference(reference).split(/[,;]/))
+    end
+
+    def normalize_reference(reference)
+      normalizations.reduce(reference.to_s) { |reference, (regex, replacement)| reference.gsub(regex, replacement) }
+    end
+
+    def parse_ranges(book, ranges)
+      default_chapter = nil
+      default_chapter = 1 unless book_has_chapters?(book)
+      default_verse = nil
+
+      ranges.map do |range|
+        range_begin_string, range_end_string = range.split("-")
+
+        # treat 12:4 as 12:4-12:4
+        range_end_string ||= range_begin_string
+
+        range_begin = parse_reference_fragment(range_begin_string, default_chapter: default_chapter, default_verse: default_verse)
+
+        # no verse specified; this is a range of chapters, start with verse 1
+        chapter_range = false
+        if range_begin.needs_verse?
+          range_begin.verse = 1
+          chapter_range = true
+        end
+
+        range_begin.chapter = to_valid_chapter(book, range_begin.chapter)
+        range_begin.verse = to_valid_verse(book, range_begin.chapter, range_begin.verse)
+
+        if range_begin_string == range_end_string && !chapter_range
+          range_end = range_begin.dup
+        else
+          range_end = parse_reference_fragment(range_end_string, default_chapter: (range_begin.chapter unless chapter_range))
+          range_end.chapter = to_valid_chapter(book, range_end.chapter)
+
+          # treat Mark 3-1 as Mark 3-3 and, eventually, Mark 3:1-35
+          range_end.chapter = range_begin.chapter if range_end.chapter < range_begin.chapter
+
+          # this is a range of chapters, end with the last verse
+          if range_end.needs_verse?
+            range_end.verse = get_max_verse(book, range_end.chapter)
+          else
+            range_end.verse = to_valid_verse(book, range_end.chapter, range_end.verse)
+          end
+        end
+
+        # e.g. parsing 11 in 12:1-8,11 => remember that 12 is the chapter
+        default_chapter = range_end.chapter
+
+        # e.g. parsing c in 9:12a, c => remember that 12 is the verse
+        default_verse = range_end.verse
+
+        range = Range.new(range_begin.to_verse(book: book), range_end.to_verse(book: book))
+
+        # an 'a' at the beginning of a range is redundant
+        range.begin.letter = nil if range.begin.letter == "a" && range.end.to_i > range.begin.to_i
+
+        # a 'c' at the end of a range is redundant
+        range.end.letter = nil if range.end.letter == max_letter && range.end.to_i > range.begin.to_i
+
+        range
+      end
+    end
+
+    def parse_reference_fragment(input, default_chapter: nil, default_verse: nil)
+      chapter, verse, letter = input.match(Pericope.fragment_regexp).captures
+      chapter = default_chapter unless chapter
+      chapter, verse = [verse, nil] unless chapter
+      verse = default_verse unless verse
+      letter = nil unless verse
+      ReferenceFragment.new(chapter.to_i, verse&.to_i, letter)
+    end
+
+    def to_valid_chapter(book, chapter)
+      coerce_to_range(chapter, 1..get_max_chapter(book))
+    end
+
+    def to_valid_verse(book, chapter, verse)
+      coerce_to_range(verse, 1..get_max_verse(book, chapter))
+    end
+
+    def coerce_to_range(number, range)
+      return range.begin if number < range.begin
+      return range.end if number > range.end
+      number
+    end
+
+
+    ReferenceFragment = Struct.new(:chapter, :verse, :letter) do
+      def needs_verse?
+        verse.nil?
+      end
+
+      def to_verse(book:)
+        Verse.new(book, chapter, verse, letter)
+      end
+    end
+  end
+
+
+  BOOK_PATTERN = %r{\b(?:
+      (?:(?:3|iii|third|3rd)\s*(?:
+        (john|joh|jon|jhn|jh|jo|jn)
+      ))|
+      (?:(?:2|ii|second|2nd)\s*(?:
+        (samuels|samuel|sam|sa|sm)|
+        (kings|king|kngs|kgs|kg|k)|
+        (chronicles|chronicle|chron|chrn|chr)|
+        (john|joh|jon|jhn|jh|jo|jn)|
+        (corinthians?|cor?|corint?h?|corth)|
+        (thessalonians?|thes{1,}|the?s?)|
+        (timothy|tim|tm|ti)|
+        (peter|pete|pet|ptr|pe|pt|pr)
+      ))|
+      (?:(?:1|i|first|1st)\s*(?:
+        (samuels|samuel|sam|sa|sm)|
+        (kings|king|kngs|kgs|kg|k)|
+        (chronicles|chronicle|chron|chrn|chr)|
+        (john|joh|jon|jhn|jh|jo|jn)|
+        (corinthians?|cor?|corint?h?|corth)|
+        (thessalonians?|thes{1,}|the?s?)|
+        (timothy|tim|tm|ti)|
+        (peter|pete|pet|ptr|pe|pt|pr)
+      ))|
+      (genesis|gen|gn|ge)|
+      (exodus|exod|exo|exd|ex)|
+      (leviticus|lev|levi|le|lv)|
+      (numbers|number|numb|num|nmb|nu|nm)|
+      (deuteronomy|deut|deu|dt)|
+      (joshua|josh|jsh|jos)|
+      (judges|jdgs|judg|jdg)|
+      (ruth|rut|rth|ru)|
+      (isaiah|isa|is|ia|isai|isah)|
+      (ezra|ezr)|
+      (nehemiah|neh|ne)|
+      (esther|esth|est|es)|
+      (job|jb)|
+      (psalms|psalm|pslms|pslm|psm|psa|ps)|
+      (proverbs|proverb|prov|prv|prvb|prvbs|pv)|
+      (ecclesiastes|eccles|eccl|ecc|ecl)|
+      ((?:the\s?)?song\s?of\s?solomon|(?:the\s?)?song\s?of\s?songs|sn?gs?|songs?|so?s|sol?|son|s\s?of\s?\ss)|
+      (jeremiah?|jer?|jr|jere)|
+      (lamentations?|lam?|lm)|
+      (ezekiel|ezek|eze|ezk)|
+      (daniel|dan|dn|dl|da)|
+      (hosea|hos|ho|hs)|
+      (joel|jl)|
+      (amos|amo|ams|am)|
+      (obadiah|obadia|obad|oba|obd|ob)|
+      (jonah|jon)|
+      (micah|mica|mic|mi)|
+      (nahum|nah|nahu|na)|
+      (habakk?uk|habk?)|
+      (zephaniah?|ze?ph?)|
+      (haggai|ha?gg?)|
+      (zechariah?|ze?ch?)|
+      (malachi|mal)|
+      (matthew|matt|mat|ma|mt)|
+      (mark|mrk|mk)|
+      (luke|luk|lk|lu)|
+      (john|joh|jon|jhn|jh|jo|jn)|
+      (acts|act|ac)|
+      (romans|roman|roms|rom|rms|ro|rm)|
+      (galatians|galatian|galat|gala|gal|ga)|
+      (ephesians?|eph?|ephe?s?)|
+      (philippians?|phi?l|php|phi|philipp?)|
+      (colossi?ans?|col?)|
+      (titus|tit|ti)|
+      (philemon|phl?mn?|philem?)|
+      (hebrews|hebrew|heb)|
+      (james|jam|jas|jm|js|ja)|
+      (jude)|
+      (revelations|revelation|revel|rev|rv|re)
+  )}ix.freeze
+
+  # The order books of the Bible are matched
+  BOOK_IDS = [ 64, 10, 12, 14, 63, 47, 53, 55, 61, 9, 11, 13, 62, 46, 52, 54, 60, 1, 2, 3, 4, 5, 6,  7, 8, 23, 15, 16, 17, 18, 19, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 48, 49, 50, 51, 56, 57, 58, 59, 65, 66 ].freeze
+
+  BOOK_NAMES = [nil, "Genesis", "Exodus", "Leviticus", "Numbers", "Deuteronomy", "Joshua", "Judges", "Ruth", "1 Samuel", "2 Samuel", "1 Kings", "2 Kings", "1 Chronicles", "2 Chronicles", "Ezra", "Nehemiah", "Esther", "Job", "Psalm", "Proverbs", "Ecclesiastes", "Song of Solomon", "Isaiah", "Jeremiah", "Lamentations", "Ezekiel", "Daniel", "Hosea", "Joel", "Amos", "Obadiah", "Jonah", "Micah", "Nahum", "Habakkuk", "Zephaniah", "Haggai", "Zechariah", "Malachi", "Matthew", "Mark", "Luke", "John", "Acts", "Romans", "1 Corinthians", "2 Corinthians", "Galatians", "Ephesians", "Philippians", "Colossians", "1 Thessalonians", "2 Thessalonians", "1 Timothy", "2 Timothy", "Titus", "Philemon", "Hebrews", "James", "1 Peter", "2 Peter", "1 John", "2 John", "3 John", "Jude", "Revelation"].freeze
+
+end

data/lib/pericope/range.rb

@@ -0,0 +1,58 @@
+class Pericope
+  class Range
+    include Enumerable
+
+    def initialize(first, last)
+      @begin = first
+      @end = last
+    end
+
+    attr_reader :begin
+    attr_reader :end
+
+    def ==(other)
+      return true if equal? other
+
+      other.kind_of?(Pericope::Range) and
+        self.begin == other.begin and
+        self.end == other.end
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      self.begin.hash ^ self.end.hash
+    end
+
+    def each
+      return to_enum unless block_given?
+
+      if self.begin == self.end
+        yield self.begin
+        return self
+      end
+
+      current = self.begin
+      last_verse = self.end.whole
+      while current < last_verse
+        yield current
+        current = current.succ
+      end
+
+      if self.end.partial?
+        "a".upto(self.end.letter).each do |letter|
+          yield Verse.new(self.end.book, self.end.chapter, self.end.verse, letter)
+        end
+      else
+        yield self.end
+      end
+
+      self
+    end
+
+    def inspect
+      "#{self.begin.to_id}..#{self.end.to_id}"
+    end
+
+  end
+end

data/lib/pericope/verse.rb

@@ -0,0 +1,74 @@
+class Pericope
+  Verse = Struct.new(:book, :chapter, :verse, :letter) do
+    include Comparable
+
+    def initialize(book, chapter, verse, letter=nil)
+      super
+
+      raise ArgumentError, "#{book} is not a valid book" if book < 1 || book > 66
+      raise ArgumentError, "#{chapter} is not a valid chapter" if chapter < 1 || chapter > Pericope.get_max_chapter(book)
+      raise ArgumentError, "#{verse} is not a valid verse" if verse < 1 || verse > Pericope.get_max_verse(book, chapter)
+    end
+
+    def self.parse(input)
+      return nil unless input
+      id = input.to_i
+      book = id / 1000000 # the book is everything left of the least significant 6 digits
+      chapter = (id % 1000000) / 1000 # the chapter is the 3rd through 6th most significant digits
+      verse = id % 1000 # the verse is the 3 least significant digits
+      letter = input[Pericope.letter_regexp] if input.is_a?(String)
+      new(book, chapter, verse, letter)
+    end
+
+    def <=>(other)
+      [ book, chapter, verse, letter || "a" ] <=> [ other.book, other.chapter, other.verse, other.letter || "a" ]
+    end
+
+    def ==(other)
+      to_a == other.to_a
+    end
+
+    def to_i
+      book * 1000000 + chapter * 1000 + verse
+    end
+    alias :number :to_i
+
+    def to_id
+      "#{to_i}#{letter}"
+    end
+
+    def to_s(with_chapter: false)
+      with_chapter ? "#{chapter}:#{verse}#{letter}" : "#{verse}#{letter}"
+    end
+
+    def partial?
+      !letter.nil?
+    end
+
+    def whole?
+      letter.nil?
+    end
+
+    def whole
+      return self unless partial?
+      self.class.new(book, chapter, verse)
+    end
+
+    def next
+      if partial? && (next_letter = letter.succ) <= Pericope.max_letter
+        return self.class.new(book, chapter, verse, next_letter)
+      end
+
+      next_verse = verse + 1
+      if next_verse > Pericope.get_max_verse(book, chapter)
+        next_chapter = chapter + 1
+        return nil if next_chapter > Pericope.get_max_chapter(book)
+        self.class.new(book, next_chapter, 1)
+      else
+        self.class.new(book, chapter, next_verse)
+      end
+    end
+    alias :succ :next
+
+  end
+end

data/lib/pericope/version.rb

@@ -1,3 +1,3 @@
 class Pericope
-  VERSION = "0.7.2" unless defined?(::Pericope::Version)
+  VERSION = "1.0.0" unless defined?(::Pericope::Version)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pericope
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Bob Lail
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-21 00:00:00.000000000 Z
+date: 2018-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  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: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -100,8 +114,10 @@ files:
 - lib/pericope.rb
 - lib/pericope/cli.rb
 - lib/pericope/data.rb
+- lib/pericope/parsing.rb
+- lib/pericope/range.rb
+- lib/pericope/verse.rb
 - lib/pericope/version.rb
-- lib/tasks/pericope_tasks.rake
 homepage: http://github.com/boblail/pericope
 licenses: []
 metadata: {}

data/lib/tasks/pericope_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :pericope do
-#   # Task goes here
-# end