bible270 0.6.2

data/db/migrate/20260101000003_create_bible270_comments.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+class CreateBible270Comments < ActiveRecord::Migration[7.0]
+  def change
+    create_table :bible270_comments do |t|
+      t.references :reader, null: false, index: true,
+                   foreign_key: { to_table: :bible270_readers }
+      t.integer :day,   null: false
+      t.string  :track
+      t.text    :body,  null: false
+      t.timestamps
+    end
+    add_index :bible270_comments, %i[day created_at]
+  end
+end

data/db/migrate/20260101000004_create_bible270_sign_in_tokens.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+class CreateBible270SignInTokens < ActiveRecord::Migration[7.0]
+  def change
+    create_table :bible270_sign_in_tokens do |t|
+      t.string   :email,        null: false
+      t.string   :token_digest, null: false
+      t.string   :display_name
+      t.datetime :expires_at,   null: false
+      t.datetime :consumed_at
+      t.timestamps
+    end
+
+    add_index :bible270_sign_in_tokens, :token_digest, unique: true,
+              name: "idx_b270_signin_tokens_digest"
+    add_index :bible270_sign_in_tokens, %i[email created_at],
+              name: "idx_b270_signin_tokens_email"
+  end
+end

data/lib/bible270/configuration.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+# `uri` is a default gem on every supported Ruby. We deliberately avoid `cgi`
+# here: the CGI library was removed from Ruby's default gems in Ruby 4.0 (only
+# cgi/escape remains), so requiring it emits a deprecation warning there.
+# URI.encode_www_form_component produces byte-identical output to CGI.escape.
+require "uri"
+require "bible270/plan"
+
+module Bible270
+  class Configuration
+    # Controller the engine's controllers inherit from. Set this to your host's
+    # "::ApplicationController" if you want to share layout, auth and helpers.
+    attr_accessor :parent_controller
+
+    # Layout used to render engine pages.
+    attr_accessor :layout
+
+    # A callable (lambda) that receives the current controller and returns a
+    # Bible270::Reader (or nil). Use this to bridge your host's users:
+    #
+    #   config.current_reader_resolver = ->(c) {
+    #     u = c.send(:current_user)
+    #     u && Bible270::Reader.for_owner(u, display_name: u.name, email: u.email)
+    #   }
+    #
+    # Leave nil to use the built-in session-based sign-in (OmniAuth).
+    attr_accessor :current_reader_resolver
+
+    # Where to send the reader after a successful sign-in / sign-out.
+    attr_accessor :after_sign_in_path
+    attr_accessor :after_sign_out_path
+
+    # ---- OmniAuth (built-in sign-in) --------------------------------------
+
+    # Providers to offer on the sign-in screen. Accepts symbols, or pairs of
+    # [provider, label] when you want to override the displayed name:
+    #
+    #   config.omniauth_providers = [:github]
+    #   config.omniauth_providers = [:github, [:google_oauth2, "Google"]]
+    #
+    # The host application supplies the matching strategy gems and registers
+    # them in the OmniAuth builder (see the README, or run the install generator).
+    attr_reader :omniauth_providers
+
+    # OmniAuth's path_prefix, if you need to override it. Normally leave this
+    # nil: the engine derives "<mount point>/auth" from the request, which
+    # matches a builder configured with path_prefix: "<mount point>/auth".
+    attr_accessor :omniauth_path_prefix
+
+    # Human labels for providers we know; anything else is titleised.
+    PROVIDER_LABELS = {
+      github: "GitHub", gitlab: "GitLab", google_oauth2: "Google", google: "Google",
+      facebook: "Facebook", twitter: "Twitter", apple: "Apple", discord: "Discord",
+      microsoft_graph: "Microsoft", azure_activedirectory_v2: "Microsoft",
+      openid_connect: "OpenID Connect", saml: "SSO"
+    }.freeze
+
+    def omniauth_providers=(list)
+      @omniauth_providers = Array(list).map do |entry|
+        key, label = entry.is_a?(Array) ? entry : [entry, nil]
+        key = key.to_sym
+        [key, (label || PROVIDER_LABELS[key] || key.to_s.tr("_", " ").split.map(&:capitalize).join(" "))]
+      end
+    end
+
+    def omniauth_provider_keys = omniauth_providers.map(&:first)
+
+    # ---- Email sign-in (passwordless magic link) --------------------------
+
+    # Offer sign-in by email link, so readers who don't have (or don't want to
+    # use) a GitHub/Google/etc. account can still take part. Requires the host
+    # app to have Action Mailer delivery configured.
+    attr_accessor :email_sign_in
+
+    # From: address for the sign-in email.
+    attr_accessor :mailer_from
+
+    # How long a magic link stays valid (seconds).
+    attr_accessor :email_sign_in_ttl
+
+    # Simple abuse guard: at most N links per address per window (seconds).
+    attr_accessor :email_sign_in_window
+    attr_accessor :email_sign_in_max_per_window
+
+    # Whether a reader may type the display name shown beside their reflections
+    # when signing in by email (otherwise it's derived from the address).
+    attr_accessor :email_sign_in_ask_name
+
+    # Send the sign-in email via Active Job (deliver_later) instead of inline.
+    # Leave false unless you have a queue backend configured.
+    attr_accessor :email_sign_in_deliver_later
+
+    def email_sign_in? = !!@email_sign_in
+
+    # Any way at all for a new person to sign in?
+    def any_sign_in_method?
+      email_sign_in? || omniauth_providers.any?
+    end
+
+    def single_provider? = omniauth_providers.size == 1
+
+    def label_for_provider(key)
+      found = omniauth_providers.find { |k, _| k.to_s == key.to_s }
+      return found.last if found
+
+      PROVIDER_LABELS[key.to_sym] || key.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+    end
+
+    # Default Bible translation and a builder for external passage links.
+    attr_accessor :bible_version
+    attr_accessor :passage_url_builder
+
+    # Public labels.
+    attr_accessor :app_name
+    attr_accessor :tagline
+
+    # Optional community-wide start date for the plan. Set this when everyone
+    # reads together as a cohort (e.g. a church starting on a set Sunday):
+    #
+    #   config.start_date = Date.new(2026, 9, 6)   # or the string "2026-09-06"
+    #
+    # Leave nil for an undated plan, where each reader's own start date applies
+    # (defaulting to the day they first check something off).
+    attr_reader :start_date
+
+    # Whether an individual reader may set or change their own start date. When
+    # false, everyone is pinned to config.start_date.
+    attr_accessor :allow_reader_start_date
+
+    # Only signed-in readers may check off and comment (viewing is always open).
+    attr_accessor :require_sign_in_to_participate
+
+    def initialize
+      @parent_controller = "ActionController::Base"
+      @layout = "bible270/application"
+      @current_reader_resolver = nil
+      @after_sign_in_path = nil
+      @after_sign_out_path = nil
+      @bible_version = "ESV"
+      @passage_url_builder = lambda do |reference, version|
+        search  = URI.encode_www_form_component(reference)
+        version = URI.encode_www_form_component(version)
+        "https://www.biblegateway.com/passage/?search=#{search}&version=#{version}"
+      end
+      @app_name = "Daily Bread"
+      @tagline = "A 270-day journey through Scripture"
+      @require_sign_in_to_participate = true
+      @start_date = nil
+      @allow_reader_start_date = true
+      self.omniauth_providers = [:github]
+      @omniauth_path_prefix = nil
+      @email_sign_in = true
+      @mailer_from = "no-reply@example.com"
+      @email_sign_in_ttl = 20 * 60          # 20 minutes
+      @email_sign_in_window = 15 * 60       # 15 minutes
+      @email_sign_in_max_per_window = 5
+      @email_sign_in_ask_name = true
+      @email_sign_in_deliver_later = false
+    end
+
+    # Accepts a Date, Time, or "YYYY-MM-DD" string.
+    def start_date=(value)
+      @start_date = Plan.to_date(value)
+    end
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+  end
+end

data/lib/bible270/email_sign_in.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "digest"
+
+module Bible270
+  # Pure helpers for passwordless ("magic link") email sign-in. Kept free of
+  # Rails so the security-relevant bits can be unit tested on their own.
+  #
+  # We never store a password and never store the raw token — only a SHA-256
+  # digest of it, so a leaked database can't be used to sign in.
+  module EmailSignIn
+    # Deliberately permissive: real validation is "did the link get clicked".
+    EMAIL_RE = /\A[^@\s,;:<>"]+@[^@\s,;:<>"]+\.[A-Za-z]{2,}\z/
+
+    module_function
+
+    # Trim, strip a mailto:, and downcase. Returns nil for anything unusable.
+    def normalize_email(value)
+      email = value.to_s.strip
+      email = email[7..] if email.downcase.start_with?("mailto:")
+      email = email.strip.downcase
+      return nil if email.empty?
+      return nil unless email.match?(EMAIL_RE)
+      return nil if email.length > 254 # RFC 5321 practical maximum
+
+      email
+    end
+
+    def valid_email?(value)
+      !normalize_email(value).nil?
+    end
+
+    # A URL-safe, high-entropy single-use token (256 bits).
+    def generate_token
+      SecureRandom.urlsafe_base64(32)
+    end
+
+    # What we actually persist. Hex digest keeps it index-friendly.
+    def digest_token(token)
+      return nil if token.to_s.empty?
+
+      Digest::SHA256.hexdigest(token.to_s)
+    end
+
+    # Constant-time comparison, for callers that need to compare digests
+    # directly rather than looking them up.
+    def secure_compare(a, b)
+      a = a.to_s
+      b = b.to_s
+      return false unless a.bytesize == b.bytesize
+
+      res = 0
+      a.bytes.zip(b.bytes) { |x, y| res |= x ^ y }
+      res.zero?
+    end
+
+    # The part of an address we can use as a default display name:
+    # "mary.anne.smith@example.com" => "Mary Anne Smith"
+    def display_name_from(email)
+      local = normalize_email(email)&.split("@")&.first
+      return nil if local.nil? || local.empty?
+
+      # NB: the hyphen must come last or tr reads "_-+" as a range.
+      local.tr("._+-", " ").split.map { |w| w[0].upcase + (w[1..] || "") }.join(" ")
+    end
+  end
+end

data/lib/bible270/engine.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Bible270
+  class Engine < ::Rails::Engine
+    isolate_namespace Bible270
+
+    config.generators do |g|
+      g.test_framework :minitest
+      g.orm :active_record
+    end
+
+    # Make the engine's migrations available to the host via
+    #   bin/rails bible270:install:migrations
+    initializer "bible270.append_migrations" do |app|
+      unless app.root.to_s.match?(root.to_s)
+        config.paths["db/migrate"].expanded.each do |path|
+          app.config.paths["db/migrate"] << path
+        end
+      end
+    end
+  end
+end

data/lib/bible270/plan.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "date"
+require "bible270/versification"
+
+module Bible270
+  # Pure-Ruby, deterministic reading-plan generator. No database required.
+  #
+  # Daily portions are balanced by VERSE COUNT (a canonical, translation-neutral
+  # proxy for how much text there is), not by chapter count — so a day landing on
+  # Psalm 119 (176 verses) is not treated as equal to a day on Psalm 117 (2 verses).
+  #
+  # * Old Testament   – read once, cover to cover; WHOLE chapters grouped so each
+  #                     day is ~equal in verses (~73/day)
+  # * New Testament   – read through TWICE (~2 chapters/day, every day)
+  # * Psalms/Proverbs – a WHOLE-CHAPTER daily companion. With only 181 chapters
+  #                     over 270 days it cycles ~1.9x. Chapters stay intact; very
+  #                     short ones merge with a neighbour, and the one excessively
+  #                     long chapter (Psalm 119) is divided into two readings.
+  #
+  # Genesis→Malachi finishes on day 270, as does the second pass through the NT.
+  module Plan
+    DAYS = 270
+
+    OT = [
+      ["Genesis", 50], ["Exodus", 40], ["Leviticus", 27], ["Numbers", 36],
+      ["Deuteronomy", 34], ["Joshua", 24], ["Judges", 21], ["Ruth", 4],
+      ["1 Samuel", 31], ["2 Samuel", 24], ["1 Kings", 22], ["2 Kings", 25],
+      ["1 Chronicles", 29], ["2 Chronicles", 36], ["Ezra", 10], ["Nehemiah", 13],
+      ["Esther", 10], ["Job", 42], ["Ecclesiastes", 12], ["Song of Solomon", 8],
+      ["Isaiah", 66], ["Jeremiah", 52], ["Lamentations", 5], ["Ezekiel", 48],
+      ["Daniel", 12], ["Hosea", 14], ["Joel", 3], ["Amos", 9], ["Obadiah", 1],
+      ["Jonah", 4], ["Micah", 7], ["Nahum", 3], ["Habakkuk", 3], ["Zephaniah", 3],
+      ["Haggai", 2], ["Zechariah", 14], ["Malachi", 4]
+    ].freeze
+
+    NT = [
+      ["Matthew", 28], ["Mark", 16], ["Luke", 24], ["John", 21], ["Acts", 28],
+      ["Romans", 16], ["1 Corinthians", 16], ["2 Corinthians", 13], ["Galatians", 6],
+      ["Ephesians", 6], ["Philippians", 4], ["Colossians", 4], ["1 Thessalonians", 5],
+      ["2 Thessalonians", 3], ["1 Timothy", 6], ["2 Timothy", 4], ["Titus", 3],
+      ["Philemon", 1], ["Hebrews", 13], ["James", 5], ["1 Peter", 5], ["2 Peter", 3],
+      ["1 John", 5], ["2 John", 1], ["3 John", 1], ["Jude", 1], ["Revelation", 22]
+    ].freeze
+
+    PP = [["Psalm", 150], ["Proverbs", 31]].freeze
+
+    TRACKS = {
+      "ot" => { key: "ot", label: "Old Testament",     color: "#2f6a67" },
+      "nt" => { key: "nt", label: "New Testament",     color: "#8a2f3b" },
+      "pp" => { key: "pp", label: "Psalms & Proverbs", color: "#a5812c" }
+    }.freeze
+
+    module_function
+
+    # ---- shared helpers ---------------------------------------------------
+
+    def flatten(track)
+      track.flat_map { |book, chapters| (1..chapters).map { |c| [book, c] } }
+    end
+
+    def verses_for(book, chapter)
+      Versification.verses(book, chapter)
+    end
+
+    # Collapse consecutive whole chapters in the same book: "Genesis 1–3, Exodus 1"
+    def format_reference(chapters)
+      return nil if chapters.empty?
+
+      parts = []
+      i = 0
+      while i < chapters.size
+        book = chapters[i][0]
+        start = chapters[i][1]
+        j = i
+        while j + 1 < chapters.size &&
+              chapters[j + 1][0] == book &&
+              chapters[j + 1][1] == chapters[j][1] + 1
+          j += 1
+        end
+        last = chapters[j][1]
+        parts << (start == last ? "#{book} #{start}" : "#{book} #{start}\u2013#{last}")
+        i = j + 1
+      end
+      parts.join(", ")
+    end
+
+    # Group ordered items (each [book, chapter]) into `bins` contiguous groups so
+    # that the total weight per group is as even as possible, while guaranteeing
+    # every group gets at least one item.
+    def balance_by_weight(items, weights, bins)
+      n = items.size
+      total = weights.sum.to_f
+      groups = Array.new(bins) { [] }
+      idx = 0
+      running = 0.0
+      (0...bins).each do |d|
+        target = (d + 1) * total / bins
+        # every bin takes at least one item
+        groups[d] << items[idx]
+        running += weights[idx]
+        idx += 1
+        # then add more only while it brings this bin's cumulative closer to the
+        # target boundary (round-to-nearest), keeping one item in reserve per
+        # remaining bin
+        while idx < n && (n - idx) > (bins - d - 1)
+          w = weights[idx]
+          break if running >= target
+          # stop if overshooting the target would be worse than stopping short
+          break if (running + w - target) > (target - running)
+
+          groups[d] << items[idx]
+          running += w
+          idx += 1
+        end
+      end
+      groups[bins - 1].concat(items[idx...n]) if idx < n
+      groups
+    end
+
+    # ---- Old Testament ----------------------------------------------------
+
+    def ot_groups
+      @ot_groups ||= begin
+        chapters = flatten(OT)
+        weights  = chapters.map { |b, c| verses_for(b, c) }
+        balance_by_weight(chapters, weights, DAYS)
+      end
+    end
+
+    def ot_plan
+      @ot_plan ||= ot_groups.map { |g| format_reference(g) }
+    end
+
+    def ot_verse_loads
+      @ot_verse_loads ||= ot_groups.map { |g| g.sum { |b, c| verses_for(b, c) } }
+    end
+
+    # ---- New Testament (read through TWICE) -------------------------------
+    #
+    # 260 chapters x 2 passes = 520 chapter-readings over 270 days, so ~2 chapters
+    # a day and no rest days. Each pass gets its own half of the plan (135 days),
+    # so Revelation 22 lands on day 135 and again on day 270. Within a pass, whole
+    # chapters are grouped so each day is ~equal in verses.
+
+    NT_PASSES = 2
+
+    def nt_days_per_pass = DAYS / NT_PASSES
+
+    def nt_chapters
+      @nt_chapters ||= flatten(NT) * NT_PASSES
+    end
+
+    def nt_groups
+      @nt_groups ||= begin
+        chapters = flatten(NT)
+        weights  = chapters.map { |b, c| verses_for(b, c) }
+        one_pass = balance_by_weight(chapters, weights, nt_days_per_pass)
+        one_pass * NT_PASSES
+      end
+    end
+
+    def nt_plan
+      @nt_plan ||= nt_groups.map { |g| format_reference(g) }
+    end
+
+    def nt_verse_loads
+      @nt_verse_loads ||= nt_groups.map { |g| g.sum { |b, c| verses_for(b, c) } }
+    end
+
+    # Days on which the NT track has content (now every day).
+    def nt_content_days
+      @nt_content_days ||= nt_plan.count { |r| !r.nil? }
+    end
+
+    # 1-indexed day on which the second pass through the NT begins.
+    def nt_second_pass_start_day = nt_days_per_pass + 1
+
+    # ---- Psalms & Proverbs (whole-chapter companion, cycles ~1.9x) --------
+    #
+    # Chapters are kept WHOLE. Because there are only 181 Psalms/Proverbs
+    # chapters but 270 days, the track reads through roughly twice, cycling.
+    # Two adjustments keep daily portions roughly even without chopping text:
+    #   * very short chapters merge with a neighbour (no trivial 2-verse days)
+    #   * only excessively long chapters (> PP_LONG_CHAPTER verses) are split
+    #     into balanced parts — in practice just Psalms 78, 89, and 119.
+
+    PP_MIN_DAY      = 12  # keep merging until a portion reaches at least this many verses
+    PP_DAY_TARGET   = 22  # soft cap: stop merging once a portion would exceed this
+    PP_LONG_CHAPTER = 100 # only an excessively long chapter is split; in the whole
+                          # Psalter+Proverbs that is Psalm 119 (176v) alone, since
+                          # the next longest chapter is Psalm 78 at 72 verses
+    PP_SPLIT_PARTS  = 2   # such a chapter is divided into this many readings
+
+    # The base cycle of readings (whole chapters, short ones merged, long ones
+    # split). Each portion is an array of segments; a segment is either
+    # [book, chapter] (whole) or [book, chapter, from, to] (part of a chapter).
+    def pp_base_portions
+      @pp_base_portions ||= begin
+        units = flatten(PP).map { |b, c| [b, c, verses_for(b, c)] }
+        portions = []
+        buf = []
+        buflen = 0
+        units.each do |book, ch, len|
+          if len > PP_LONG_CHAPTER
+            unless buf.empty?
+              portions << buf
+              buf = []
+              buflen = 0
+            end
+            nparts = PP_SPLIT_PARTS
+            base = len / nparts
+            extra = len % nparts
+            v = 1
+            nparts.times do |i|
+              size = base + (i < extra ? 1 : 0)
+              portions << [[book, ch, v, v + size - 1]]
+              v += size
+            end
+          else
+            if !buf.empty? && buflen >= PP_MIN_DAY && buflen + len > PP_DAY_TARGET
+              portions << buf
+              buf = []
+              buflen = 0
+            end
+            buf << [book, ch]
+            buflen += len
+          end
+        end
+        portions << buf unless buf.empty?
+        portions
+      end
+    end
+
+    def pp_cycle_length = pp_base_portions.size
+
+    def pp_plan
+      @pp_plan ||= (0...DAYS).map { |d| format_pp(pp_base_portions[d % pp_cycle_length]) }
+    end
+
+    def pp_verse_loads
+      @pp_verse_loads ||= (0...DAYS).map do |d|
+        pp_base_portions[d % pp_cycle_length].sum do |s|
+          s.size == 2 ? verses_for(s[0], s[1]) : (s[3] - s[2] + 1)
+        end
+      end
+    end
+
+    # Format a portion, collapsing consecutive whole chapters ("Psalm 24–25")
+    # and rendering split parts as verse ranges ("Psalm 119:1–22").
+    def format_pp(portion)
+      parts = []
+      i = 0
+      while i < portion.size
+        s = portion[i]
+        if s.size == 2 # whole chapter
+          book, ch = s
+          j = i
+          while j + 1 < portion.size && portion[j + 1].size == 2 &&
+                portion[j + 1][0] == book && portion[j + 1][1] == portion[j][1] + 1
+            j += 1
+          end
+          last = portion[j][1]
+          parts << (ch == last ? "#{book} #{ch}" : "#{book} #{ch}\u2013#{last}")
+          i = j + 1
+        else # part of a chapter
+          book, ch, from, to = s
+          parts << (from == to ? "#{book} #{ch}:#{from}" : "#{book} #{ch}:#{from}\u2013#{to}")
+          i += 1
+        end
+      end
+      parts.join(", ")
+    end
+
+    # ---- public API -------------------------------------------------------
+
+    def readings_for(day)
+      { "ot" => ot_plan[day - 1], "nt" => nt_plan[day - 1], "pp" => pp_plan[day - 1] }
+    end
+
+    def present_tracks(day)
+      readings_for(day).select { |_, ref| ref }.keys
+    end
+
+    def required_track_count(day) = present_tracks(day).size
+
+    def valid_day?(day) = day.is_a?(Integer) && day >= 1 && day <= DAYS
+
+    # ---- calendar mapping (all pure functions; nil start_date = undated) ----
+
+    # Coerce whatever we were handed into a Date (or nil).
+    def to_date(value)
+      case value
+      when nil then nil
+      when ::Date then value
+      when ::Time then value.to_date
+      when ::String then (::Date.parse(value) rescue nil)
+      else value.respond_to?(:to_date) ? value.to_date : nil
+      end
+    end
+
+    # The calendar date a given plan day falls on.
+    def date_for(day, start_date)
+      start = to_date(start_date)
+      return nil unless start && valid_day?(day)
+
+      start + (day - 1)
+    end
+
+    # The last day of the plan.
+    def end_date_for(start_date)
+      date_for(DAYS, start_date)
+    end
+
+    # Which plan day a calendar date corresponds to. By default the result is
+    # clamped into 1..DAYS; pass clamp: false to get the raw (possibly out of
+    # range) offset, which is how you tell "hasn't started yet" from "day 1".
+    def day_for(date, start_date, clamp: true)
+      start = to_date(start_date)
+      on    = to_date(date)
+      return nil unless start && on
+
+      offset = (on - start).to_i + 1
+      clamp ? offset.clamp(1, DAYS) : offset
+    end
+
+    def before_start?(date, start_date)
+      raw = day_for(date, start_date, clamp: false)
+      raw ? raw < 1 : false
+    end
+
+    def after_end?(date, start_date)
+      raw = day_for(date, start_date, clamp: false)
+      raw ? raw > DAYS : false
+    end
+
+    def totals
+      {
+        ot: flatten(OT).size,                 # 748 chapters
+        nt: flatten(NT).size,                 # 260 chapters per pass
+        nt_passes: NT_PASSES,                 # read through twice
+        nt_chapters_read: nt_chapters.size,   # 520 chapter-readings
+        pp: flatten(PP).size,                 # 181 chapters
+        pp_verses: flatten(PP).sum { |b, c| verses_for(b, c) }, # 3376 verses
+        pp_cycle: pp_cycle_length,            # base portions before cycling
+        ot_verses: flatten(OT).sum { |b, c| verses_for(b, c) },
+        nt_verses: nt_chapters.sum { |b, c| verses_for(b, c) },
+        days: DAYS
+      }
+    end
+  end
+end