bible270 0.6.2

data/app/controllers/bible270/comments_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Bible270
+  class CommentsController < ApplicationController
+    def create
+      return unless require_reader!
+
+      @day = params[:day].to_i
+      head :bad_request and return unless Plan.valid_day?(@day)
+
+      @comment = current_reader.comments.new(comment_params.merge(day: @day))
+      @readings = Plan.readings_for(@day)
+
+      if @comment.save
+        respond_to do |format|
+          format.turbo_stream
+          format.html { redirect_to day_path(@day, anchor: "comment-#{@comment.id}") }
+        end
+      else
+        respond_to do |format|
+          format.turbo_stream { render turbo_stream: turbo_stream.replace("new_comment_form", partial: "bible270/comments/form", locals: { day: @day, comment: @comment }) }
+          format.html { redirect_to day_path(@day), alert: @comment.errors.full_messages.to_sentence }
+        end
+      end
+    end
+
+    def destroy
+      return unless require_reader!
+
+      @comment = current_reader.comments.find_by(id: params[:id])
+      head :not_found and return unless @comment
+
+      @day = @comment.day
+      @comment.destroy
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to day_path(@day) }
+      end
+    end
+
+    private
+
+    def comment_params
+      params.require(:comment).permit(:body, :track)
+    end
+  end
+end

data/app/controllers/bible270/days_controller.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module Bible270
+  class DaysController < ApplicationController
+    def index
+      @plan_totals = Plan.totals
+
+      # Community leaderboard (small-community friendly; see README on scaling).
+      @readers = Reader.order(updated_at: :desc).to_a
+      counts = Checkoff.group(:reader_id, :day).count
+      @days_completed = Hash.new(0)
+      counts.each { |(rid, day), n| @days_completed[rid] += 1 if n >= Plan.required_track_count(day) }
+      @readers = @readers.sort_by { |r| -@days_completed[r.id] }
+
+      @start_day = current_reader&.current_day || 1
+      @today_day = current_reader&.calendar_day
+      @community_start_date = Bible270.config.start_date
+      @allow_reader_start_date = Bible270.config.allow_reader_start_date
+    end
+
+    def show
+      @day = params[:day].to_i
+      unless Plan.valid_day?(@day)
+        redirect_to(root_path, alert: "That day is outside the plan.") and return
+      end
+
+      @readings   = Plan.readings_for(@day)
+      @comments   = Comment.for_day(@day).includes(:reader)
+      @new_comment = Comment.new(day: @day)
+      @reader_tracks = current_reader ? current_reader.read_tracks_for(@day) : []
+
+      req = Plan.required_track_count(@day)
+      completer_ids = Checkoff.where(day: @day)
+                              .group(:reader_id)
+                              .having("COUNT(*) >= ?", req)
+                              .pluck(:reader_id)
+      @completers = Reader.where(id: completer_ids).order(:display_name)
+
+      @prev_day = @day > 1 ? @day - 1 : nil
+      @next_day = @day < Plan::DAYS ? @day + 1 : nil
+    end
+  end
+end

data/app/controllers/bible270/readers_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Bible270
+  class ReadersController < ApplicationController
+    def index
+      @readers = Reader.all.to_a
+      counts = Checkoff.group(:reader_id, :day).count
+      @days_completed = Hash.new(0)
+      counts.each { |(rid, day), n| @days_completed[rid] += 1 if n >= Plan.required_track_count(day) }
+      @readers.sort_by! { |r| [-@days_completed[r.id], r.display_name.to_s] }
+    end
+
+    def show
+      @reader = Reader.find_by(id: params[:id])
+      redirect_to(community_path, alert: "Reader not found.") and return unless @reader
+
+      @days_completed = @reader.days_completed
+      @recent_comments = @reader.comments.recent.limit(20)
+    end
+
+    def update_start_date
+      return unless require_reader!
+
+      unless Bible270.config.allow_reader_start_date
+        redirect_to(root_path, alert: "The start date is set for the whole community.") and return
+      end
+
+      if current_reader.update_start_date!(params[:start_date])
+        redirect_to root_path,
+                    notice: "Start date set to #{current_reader.started_on.strftime('%B %-d, %Y')}."
+      else
+        redirect_to root_path, alert: "That doesn't look like a valid date."
+      end
+    end
+
+    def clear_start_date
+      return unless require_reader!
+
+      if Bible270.config.allow_reader_start_date
+        current_reader.clear_start_date!
+        redirect_to root_path, notice: "Start date cleared — the plan is now undated for you."
+      else
+        redirect_to root_path, alert: "The start date is set for the whole community."
+      end
+    end
+  end
+end

data/app/controllers/bible270/sessions_controller.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+module Bible270
+  # Built-in OmniAuth sign-in.
+  #
+  # The OmniAuth middleware (registered by the host app) handles the request and
+  # callback phases; by the time #create runs, request.env["omniauth.auth"] is
+  # populated and we just need to turn it into a Reader and remember them.
+  #
+  # NOTE: OmniAuth 2.0+ only permits POST to its request-phase routes, so all
+  # sign-in controls in these views are forms/buttons rather than links.
+  class SessionsController < ApplicationController
+    def new
+      redirect_to(after_sign_in_path, notice: "You're already signed in.") and return if signed_in?
+
+      @providers = Bible270.config.omniauth_providers
+      @origin = safe_origin(params[:origin])
+    end
+
+    def create
+      auth = request.env["omniauth.auth"]
+      unless auth
+        redirect_to(sign_in_path, alert: "Sign in didn't complete. Please try again.") and return
+      end
+
+      reader = Reader.from_omniauth(auth)
+      unless reader&.persisted?
+        redirect_to(sign_in_path, alert: "We couldn't set up your reader profile.") and return
+      end
+
+      destination = safe_origin(request.env["omniauth.origin"]) || after_sign_in_path
+
+      # Rotate the session id to avoid session fixation, then sign in.
+      reset_session
+      session[:bible270_reader_id] = reader.id
+      @current_reader = reader
+
+      redirect_to destination, notice: "Welcome, #{reader.display_name}."
+    end
+
+    def destroy
+      reset_session
+      @current_reader = nil
+      redirect_to(after_sign_out_path, notice: "Signed out.")
+    end
+
+    def failure
+      message = params[:message].presence || "unknown error"
+      redirect_to sign_in_path, alert: "Sign in failed (#{message.to_s.tr('_', ' ')})."
+    end
+
+    # ---- email (magic link) sign-in ---------------------------------------
+
+    # POST: accept an address and send a one-time link.
+    def email_link
+      unless Bible270.config.email_sign_in?
+        redirect_to(sign_in_path, alert: "Email sign-in isn't enabled here.") and return
+      end
+
+      origin  = safe_origin(params[:origin])
+      address = EmailSignIn.normalize_email(params[:email])
+      if address.nil?
+        redirect_to(sign_in_path(origin: origin),
+                    alert: "That doesn't look like an email address — please check and try again.") and return
+      end
+
+      name = Bible270.config.email_sign_in_ask_name ? params[:display_name].to_s.strip : nil
+      _record, raw = SignInToken.issue!(address, display_name: name)
+
+      if raw
+        url = email_sign_in_url(token: raw, origin: origin)
+        minutes = (Bible270.config.email_sign_in_ttl / 60.0).round
+        mail = SignInMailer.magic_link(email: address, url: url, expires_in_minutes: minutes)
+        Bible270.config.email_sign_in_deliver_later ? mail.deliver_later : mail.deliver_now
+      end
+
+      # Deliberately identical whether or not a link was actually sent, so this
+      # reveals neither who has an account nor that a limit was hit.
+      redirect_to sign_in_path,
+                  notice: "Check your inbox — if that address is valid we've sent a sign-in link to #{address}."
+    end
+
+    # GET: the reader clicked the link.
+    def email_callback
+      token = SignInToken.claim!(params[:token])
+      if token.nil?
+        redirect_to(sign_in_path,
+                    alert: "That link has expired or was already used. Please request a new one.") and return
+      end
+
+      reader = Reader.from_email(token.email, display_name: token.display_name)
+      unless reader&.persisted?
+        redirect_to(sign_in_path, alert: "We couldn't set up your reader profile.") and return
+      end
+
+      destination = safe_origin(params[:origin]) || after_sign_in_path
+
+      reset_session
+      session[:bible270_reader_id] = reader.id
+      @current_reader = reader
+
+      redirect_to destination, notice: "Welcome, #{reader.display_name}."
+    end
+
+    private
+
+    # Only ever redirect within this app, and never back into an auth route.
+    def safe_origin(value)
+      value = value.to_s
+      return nil if value.empty?
+      return nil unless value.start_with?("/")
+      return nil if value.include?("//")   # protocol-relative URL
+      return nil if value.include?("\\")   # browsers may normalise \ to /
+      return nil if value.include?("/auth/")
+
+      value
+    end
+
+    def after_sign_in_path
+      Bible270.config.after_sign_in_path || root_path
+    end
+
+    def after_sign_out_path
+      Bible270.config.after_sign_out_path || root_path
+    end
+  end
+end

data/app/helpers/bible270/plan_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Bible270
+  module PlanHelper
+    def b270_track(track)
+      Plan::TRACKS.fetch(track.to_s)
+    end
+
+    # Path that begins the OmniAuth request phase. Must be POSTed to: OmniAuth
+    # 2.0+ refuses GET on its own routes (CVE-2015-9284), so every sign-in
+    # control in these views is a button_to, not a link_to.
+    def b270_omniauth_path(provider)
+      prefix = Bible270.config.omniauth_path_prefix || "#{request.script_name}/auth"
+      "#{prefix}/#{provider}"
+    end
+
+    def b270_provider_label(provider)
+      Bible270.config.label_for_provider(provider)
+    end
+
+    def b270_passage_url(reference)
+      return "#" if reference.blank?
+      Bible270.config.passage_url_builder.call(reference, Bible270.config.bible_version)
+    end
+
+    def b270_avatar(reader, size: 34)
+      if reader.avatar_url.present?
+        image_tag reader.avatar_url, class: "b270-avatar", width: size, height: size, alt: reader.display_name
+      else
+        content_tag :span, reader.initials, class: "b270-avatar b270-avatar-fallback",
+                    style: "width:#{size}px;height:#{size}px;line-height:#{size}px"
+      end
+    end
+
+    def b270_day_status_class(reader, day)
+      return "" unless reader
+      if reader.day_complete?(day)
+        "complete"
+      elsif reader.read_tracks_for(day).any?
+        "partial"
+      else
+        ""
+      end
+    end
+  end
+end

data/app/mailers/bible270/application_mailer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Bible270
+  class ApplicationMailer < ActionMailer::Base
+    default from: -> { Bible270.config.mailer_from }
+    layout nil
+  end
+end

data/app/mailers/bible270/sign_in_mailer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Bible270
+  class SignInMailer < ApplicationMailer
+    # The URL is built by the controller (which has the request context), so the
+    # mailer needs no default_url_options of its own.
+    def magic_link(email:, url:, expires_in_minutes:)
+      @url = url
+      @expires_in_minutes = expires_in_minutes
+      @app_name = Bible270.config.app_name
+
+      mail to: email, subject: "Your sign-in link for #{@app_name}"
+    end
+  end
+end

data/app/models/bible270/application_record.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Bible270
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/bible270/checkoff.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Bible270
+  # A single reader marking one track (ot / nt / pp) read on one day.
+  class Checkoff < ApplicationRecord
+    self.table_name = "bible270_checkoffs"
+
+    belongs_to :reader, class_name: "Bible270::Reader"
+
+    validates :day, inclusion: { in: 1..Plan::DAYS }
+    validates :track, inclusion: { in: Plan::TRACKS.keys }
+    validates :track, uniqueness: { scope: %i[reader_id day] }
+    validate  :track_present_on_day
+
+    private
+
+    def track_present_on_day
+      return if day.nil? || track.nil?
+      return if Plan.present_tracks(day).include?(track)
+
+      errors.add(:track, "is not part of day #{day}")
+    end
+  end
+end

data/app/models/bible270/comment.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Bible270
+  # A publicly visible reflection attached to a plan day (optionally a track).
+  class Comment < ApplicationRecord
+    self.table_name = "bible270_comments"
+
+    belongs_to :reader, class_name: "Bible270::Reader"
+
+    validates :day, inclusion: { in: 1..Plan::DAYS }
+    validates :body, presence: true, length: { maximum: 4000 }
+    validates :track, inclusion: { in: Plan::TRACKS.keys }, allow_nil: true
+
+    scope :for_day, ->(d) { where(day: d).order(created_at: :asc) }
+    scope :recent,  -> { order(created_at: :desc) }
+  end
+end

data/app/models/bible270/reader.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+module Bible270
+  # A reader identity. Either self-contained (created via OmniAuth) or bridged
+  # to one of the host application's users through the polymorphic :owner.
+  class Reader < ApplicationRecord
+    self.table_name = "bible270_readers"
+
+    has_many :checkoffs, class_name: "Bible270::Checkoff", dependent: :destroy
+    has_many :comments,  class_name: "Bible270::Comment",  dependent: :destroy
+    belongs_to :owner, polymorphic: true, optional: true
+
+    validates :display_name, presence: true
+    validates :uid, uniqueness: { scope: :provider }, allow_nil: true
+
+    # Build/refresh a reader from an OmniAuth auth hash. Tolerant of the various
+    # shapes strategies return (OmniAuth::AuthHash, plain Hash, missing info).
+    def self.from_omniauth(auth)
+      provider = dig_auth(auth, :provider).to_s
+      uid      = dig_auth(auth, :uid).to_s
+      return nil if provider.empty? || uid.empty?
+
+      info = dig_auth(auth, :info) || {}
+      name  = first_present(dig_auth(info, :name), dig_auth(info, :nickname),
+                            dig_auth(info, :first_name), dig_auth(info, :email))
+
+      reader = find_or_initialize_by(provider: provider, uid: uid)
+      reader.display_name = first_present(name, reader.display_name, "Reader")
+      email = dig_auth(info, :email)
+      image = first_present(dig_auth(info, :image), dig_auth(info, :avatar_url))
+      reader.email      = email if email.present?
+      reader.avatar_url = image if image.present?
+      reader.save
+      reader
+    end
+
+    # Find or create the reader behind a verified email address. Uses the same
+    # provider/uid identity columns as OmniAuth, with provider "email", so an
+    # email reader is indistinguishable from any other downstream.
+    def self.from_email(email, display_name: nil)
+      address = EmailSignIn.normalize_email(email)
+      return nil if address.nil?
+
+      reader = find_or_initialize_by(provider: "email", uid: address)
+      chosen = first_present(display_name, reader.display_name,
+                             EmailSignIn.display_name_from(address), "Reader")
+      reader.display_name = chosen
+      reader.email = address
+      reader.save
+      reader
+    end
+
+    def self.dig_auth(obj, key)
+      return nil if obj.nil?
+      if obj.respond_to?(:[])
+        obj[key] || (obj[key.to_s] if key.is_a?(Symbol))
+      elsif obj.respond_to?(key)
+        obj.public_send(key)
+      end
+    rescue StandardError
+      nil
+    end
+    private_class_method :dig_auth
+
+    def self.first_present(*values)
+      values.compact.find { |v| v.to_s.strip != "" }
+    end
+    private_class_method :first_present
+
+    # Find or create a reader bridged to a host user (or any model).
+    def self.for_owner(owner, display_name:, email: nil, avatar_url: nil)
+      reader = find_or_initialize_by(owner: owner)
+      reader.display_name = display_name.presence || reader.display_name || "Reader"
+      reader.email      ||= email
+      reader.avatar_url ||= avatar_url
+      reader.save!
+      reader
+    end
+
+    def initials
+      display_name.to_s.split(/\s+/).first(2).map { |w| w[0] }.join.upcase.presence || "?"
+    end
+
+    # {day => number of tracks checked off}
+    def checked_counts
+      @checked_counts ||= checkoffs.group(:day).count
+    end
+
+    def read_tracks_for(day)
+      checkoffs.where(day: day).pluck(:track)
+    end
+
+    def read?(day, track)
+      read_tracks_for(day).include?(track.to_s)
+    end
+
+    def day_complete?(day)
+      n = checked_counts[day].to_i
+      n.positive? && n >= Plan.required_track_count(day)
+    end
+
+    def days_completed
+      checked_counts.count { |day, n| n >= Plan.required_track_count(day) }
+    end
+
+    def days_read_in(track)
+      checkoffs.where(track: track.to_s).count
+    end
+
+    def completion_percent
+      (days_completed.to_f / Plan::DAYS * 100).round
+    end
+
+    # First day not yet fully complete (where the reader "is").
+    def current_day
+      (1..Plan::DAYS).find { |d| !day_complete?(d) } || Plan::DAYS
+    end
+
+    # Day number implied by the calendar, if a start date is set.
+    # ---- start date / calendar ------------------------------------------
+
+    # The start date that actually governs this reader. A reader's own
+    # started_on wins when per-reader dates are allowed; otherwise (or if they
+    # haven't got one) the community-wide config.start_date applies. Nil means
+    # the plan is undated for this reader and no calendar mapping exists.
+    def effective_start_date
+      config = Bible270.config
+      if config.allow_reader_start_date && started_on
+        started_on
+      else
+        config.start_date
+      end
+    end
+
+    def dated?
+      effective_start_date.present?
+    end
+
+    # Whether this reader is following a personal date or the shared cohort one.
+    def own_start_date?
+      Bible270.config.allow_reader_start_date && started_on.present?
+    end
+
+    # The plan day that today corresponds to (clamped into range), or nil when undated.
+    def calendar_day
+      Plan.day_for(Date.current, effective_start_date)
+    end
+
+    # Raw, unclamped — lets callers distinguish "not started yet" / "finished".
+    def raw_calendar_day
+      Plan.day_for(Date.current, effective_start_date, clamp: false)
+    end
+
+    def not_started_yet?
+      Plan.before_start?(Date.current, effective_start_date)
+    end
+
+    def past_end_date?
+      Plan.after_end?(Date.current, effective_start_date)
+    end
+
+    def plan_end_date
+      Plan.end_date_for(effective_start_date)
+    end
+
+    def date_for_day(day)
+      Plan.date_for(day, effective_start_date)
+    end
+
+    # How many days behind (positive) or ahead (negative) of the calendar the
+    # reader's actual progress is. Nil when undated.
+    def days_off_pace
+      today = calendar_day
+      return nil unless today
+
+      today - days_completed
+    end
+
+    # Set or change this reader's own start date. Accepts a Date or a string.
+    def start_date=(value)
+      self.started_on = Plan.to_date(value)
+    end
+
+    def start_date
+      started_on
+    end
+
+    def update_start_date!(value)
+      return false unless Bible270.config.allow_reader_start_date
+
+      date = Plan.to_date(value)
+      return false if date.nil?
+
+      update!(started_on: date)
+    end
+
+    def clear_start_date!
+      update!(started_on: nil)
+    end
+
+    # Called when a reader first participates. Only stamps a personal start date
+    # when per-reader dates are enabled and a shared date isn't already in force.
+    def ensure_started!
+      config = Bible270.config
+      return unless config.allow_reader_start_date
+      return if started_on.present?
+      return if config.start_date.present?
+
+      update!(started_on: Date.current)
+    end
+  end
+end

data/app/models/bible270/sign_in_token.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+module Bible270
+  # A single-use, short-lived magic-link token for email sign-in.
+  #
+  # Only the SHA-256 digest of the token is stored, so the table is useless to
+  # an attacker who reads it. Tokens are consumed on first successful use.
+  class SignInToken < ApplicationRecord
+    self.table_name = "bible270_sign_in_tokens"
+
+    validates :email, presence: true
+    validates :token_digest, presence: true, uniqueness: true
+    validates :expires_at, presence: true
+
+    scope :unconsumed, -> { where(consumed_at: nil) }
+    scope :live, -> { unconsumed.where(expires_at: Time.current..) }
+
+    # Issue a token for an email. Returns [token_record, raw_token], or
+    # [nil, nil] when the address is being hammered (see rate_limited?).
+    def self.issue!(email, display_name: nil)
+      address = EmailSignIn.normalize_email(email)
+      return [nil, nil] if address.nil?
+      return [nil, nil] if rate_limited?(address)
+
+      raw = EmailSignIn.generate_token
+      record = create!(
+        email: address,
+        display_name: display_name.presence,
+        token_digest: EmailSignIn.digest_token(raw),
+        expires_at: Time.current + Bible270.config.email_sign_in_ttl
+      )
+      [record, raw]
+    end
+
+    # Look up a raw token and consume it. Returns the token record on success
+    # (carrying email and any requested display name), nil for anything
+    # invalid, expired, or already used.
+    def self.claim!(raw_token)
+      digest = EmailSignIn.digest_token(raw_token)
+      return nil if digest.nil?
+
+      record = live.find_by(token_digest: digest)
+      return nil if record.nil?
+
+      # Consume it: only the update that actually flips the row wins, so a
+      # double-clicked link can't sign in twice.
+      claimed = unconsumed.where(id: record.id).update_all(consumed_at: Time.current)
+      return nil if claimed.zero?
+
+      record
+    end
+
+    # Too many outstanding requests for one address in the window.
+    def self.rate_limited?(address)
+      window = Bible270.config.email_sign_in_window
+      max    = Bible270.config.email_sign_in_max_per_window
+      where(email: address).where(created_at: (Time.current - window)..).count >= max
+    end
+
+    # Housekeeping: drop spent and stale rows. Safe to run from a cron/rake task.
+    def self.sweep!(older_than: 7 * 24 * 60 * 60)
+      where(expires_at: ...Time.current).or(where.not(consumed_at: nil))
+        .where(created_at: ...(Time.current - older_than))
+        .delete_all
+    end
+
+    def expired?
+      expires_at.nil? || expires_at < Time.current
+    end
+
+    def consumed?
+      consumed_at.present?
+    end
+  end
+end

data/app/views/bible270/checkoffs/toggle.turbo_stream.erb

@@ -0,0 +1,4 @@
+<%= turbo_stream.replace "reading_#{@day}_#{@track}" do %>
+  <%= render partial: "bible270/days/reading", locals: {
+        track: @track, day: @day, readings: @readings, reader_tracks: @reader_tracks } %>
+<% end %>

data/app/views/bible270/comments/_comment.html.erb

@@ -0,0 +1,15 @@
+<div class="b270-comment" id="comment-<%= comment.id %>">
+  <%= b270_avatar(comment.reader) %>
+  <div style="flex:1">
+    <div class="b270-cmeta">
+      <strong><%= link_to comment.reader.display_name, reader_path(comment.reader), style: "text-decoration:none" %></strong>
+      · <%= comment.created_at.strftime("%b %-d, %Y") %>
+      <% if comment.track.present? %>· <%= b270_track(comment.track)[:label] %><% end %>
+      <% if signed_in? && comment.reader_id == current_reader.id %>
+        <%= button_to "delete", comment_path(comment), method: :delete, class: "b270-cdel",
+              form: { style: "display:inline", data: { turbo_stream: true } } %>
+      <% end %>
+    </div>
+    <p class="b270-cbody"><%= comment.body %></p>
+  </div>
+</div>