Yanchek99
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎.rubocop.yml‎
Lines changed: 3 additions & 0 deletions b/‎.rubocop.yml‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎app/controllers/movement_logs_controller.rb‎
Lines changed: 0 additions & 13 deletions b/‎app/controllers/movement_logs_controller.rb‎
Lines changed: 0 additions & 13 deletions
diff --git a/‎app/controllers/personal_records_controller.rb‎
Lines changed: 88 additions & 0 deletions b/‎app/controllers/personal_records_controller.rb‎
Lines changed: 88 additions & 0 deletions
diff --git a/‎app/helpers/measurable_helper.rb‎
Lines changed: 10 additions & 2 deletions b/‎app/helpers/measurable_helper.rb‎
Lines changed: 10 additions & 2 deletions
diff --git a/‎app/helpers/personal_records_helper.rb‎
Lines changed: 39 additions & 0 deletions b/‎app/helpers/personal_records_helper.rb‎
Lines changed: 39 additions & 0 deletions
diff --git a/‎app/javascript/controllers/index.js‎
Lines changed: 3 additions & 0 deletions b/‎app/javascript/controllers/index.js‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎app/javascript/controllers/rep_max_row_controller.js‎
Lines changed: 16 additions & 0 deletions b/‎app/javascript/controllers/rep_max_row_controller.js‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎app/models/concerns/log_set_breakdown.rb‎
Lines changed: 8 additions & 7 deletions b/‎app/models/concerns/log_set_breakdown.rb‎
Lines changed: 8 additions & 7 deletions
diff --git a/‎app/models/movement_log.rb‎
Lines changed: 19 additions & 0 deletions b/‎app/models/movement_log.rb‎
Lines changed: 19 additions & 0 deletions
@@ -67,3 +67,4 @@ yarn-debug.log*
 # AI
 /.claude
 /.worktrees/
+/.superpowers/
@@ -52,6 +52,9 @@ Metrics/ClassLength:
     - app/services/workout_extraction/llm_parser.rb
     - test/services/workout_extraction/llm_parser_test.rb
     - test/models/workout_test.rb
+    # Grew past the limit purely from merging two unrelated branches' independent
+    # additions to this shared file, not from any single change growing it.
+    - test/helpers/measurable_helper_test.rb
     - test/models/workout_fingerprint_test.rb
     - test/migrations/backfill_segments_for_top_level_exercises_test.rb
     - test/system/workout_drag_ordering_test.rb
 
@@ -0,0 +1,88 @@
+class PersonalRecordsController < ApplicationController
+  before_action :set_user
+
+  def index
+    redirect_to family_user_personal_records_path(@user, family: 'weightlifting')
+  end
+
+  def family
+    @family = params.expect(:family)
+    case @family
+    when 'weightlifting'
+      @movement_rep_maxes = weightlifting_rep_maxes
+      render :weightlifting
+    when 'monostructural'
+      @movement_distances, @other_records = monostructural_records
+      render :monostructural
+    else
+      @movement_logs = family_movement_logs
+      render :family
+    end
+  end
+
+  def repeated_workouts
+    @logs = @user.workout_records.sort_by { |log| log.workout.name }
+  end
+
+  private
+
+  def weightlifting_rep_maxes
+    @user.personal_records
+         .select { |record| weightlifting_rep_max?(record) }
+         .group_by(&:movement)
+         .sort_by { |movement, _records| movement.name }
+         .map { |movement, records| [movement, records.sort_by { |record| record.verified_unbroken_reps || Float::INFINITY }] }
+  end
+
+  def weightlifting_rep_max?(record)
+    record.movement.family_weightlifting? && record.load.present? && !unverified_reps_claim?(record)
+  end
+
+  def family_movement_logs
+    @user.personal_records
+         .select { |record| record.movement.public_send("family_#{@family}?") && !unverified_reps_claim?(record) }
+         .sort_by { |m| [m.movement.name, m.reps.to_i, m.distance.to_i, m.duration_seconds.to_i] }
+  end
+
+  # A record whose reps are blank (e.g. a load-only PR, no rep count tracked at all) or <= 1 makes
+  # no unverified claim. A record with reps > 1 is only trustworthy once its set_breakdown backs up
+  # a genuine unbroken effort (see MovementLog#verified_unbroken_reps) -- otherwise it'd render a
+  # fabricated claim, like Diane's aggregated "45RM" Deadlift or Murph's raw "100" pull-ups. Shared
+  # by both the Weightlifting rep-max grouping and the Gymnastics flat list, since a gymnastics
+  # rep count carries the same implicit "your real capability at N reps" claim (e.g. "max unbroken
+  # pull-ups") as a weightlifting rep-max does.
+  def unverified_reps_claim?(record)
+    record.reps.present? && record.reps > 1 && record.verified_unbroken_reps.blank?
+  end
+
+  # Only a movement whose records are uniformly distance+time (no load) gets the grouped/expand
+  # treatment -- other shapes (calorie-based, reps-in-a-time-cap) stay in the flat list below,
+  # rather than forcing genuinely different kinds of record into one row format.
+  def monostructural_records
+    records = @user.personal_records.select { |record| record.movement.family_monostructural? }
+    distance_time_records, other_records = records.partition { |record| distance_time_record?(record) }
+    [grouped_distance_records(distance_time_records), sorted_other_records(other_records)]
+  end
+
+  def distance_time_record?(record)
+    record.load.blank? && record.distance.present? && record.duration_seconds.present?
+  end
+
+  def grouped_distance_records(records)
+    records.group_by(&:movement)
+           .sort_by { |movement, _records| movement.name }
+           .map { |movement, movement_records| [movement, movement_records.sort_by(&:distance), most_recent(movement_records)] }
+  end
+
+  def most_recent(records)
+    records.max_by { |record| record.log.created_at }
+  end
+
+  def sorted_other_records(records)
+    records.sort_by { |m| [m.movement.name, m.reps.to_i, m.distance.to_i, m.duration_seconds.to_i] }
+  end
+
+  def set_user
+    @user = User.find(params.expect(:user_id))
+  end
+end
@@ -38,7 +38,12 @@ def literal_single_rep?(measurable, rep_metric)
       !measurable.reps_defined_by_interval?
   end
 
-  def measurable_reps_msg(measurable) = metric_unit_msg(measurable.prescription_metrics.find(&:rep?))
+  def measurable_reps_msg(measurable)
+    rep_metric = measurable.prescription_metrics.find(&:rep?)
+    return unless rep_metric
+
+    metric_unit_msg(rep_metric)
+  end
 
   def measurable_additional_metrics(measurable)
     metrics = additional_metrics(measurable)
@@ -48,11 +53,14 @@ def measurable_additional_metrics(measurable)
     "(#{metrics.map { |metric| metric_unit_msg(metric) }.join(' / ')})"
   end
 
+  # A single set (one round, one entry, e.g. one line of a "5x5 Back Squat") isn't a "breakdown"
+  # at all -- it's just restating the reps count, so showing "[5]" would be noise rather than
+  # information. Only render once there's more than one recorded set to actually reveal.
   def measurable_set_breakdown(measurable)
     return unless measurable.respond_to?(:set_breakdown_rounds)
 
     rounds = measurable.set_breakdown_rounds
-    return if rounds.blank?
+    return if rounds.blank? || rounds.sum(&:size) <= 1
 
     "[#{rounds.map { |round| round.join('-') }.join(', ')}]"
   end
 
@@ -0,0 +1,39 @@
+module PersonalRecordsHelper
+  # reps: 0 is this app's existing convention for "uncapped/unspecified reps" (see the
+  # "max reps X" prescription pattern in MeasurableHelper), not a literal zero-rep set -- label it
+  # explicitly rather than rendering "0RM" or leaving it blank next to labeled sibling rows. The
+  # labeled count is the verified rep-max (see MovementLog#verified_unbroken_reps), not the raw
+  # reps total, since a record only reaches this helper once it's passed that verification.
+  def rep_max_label(movement_log)
+    reps = movement_log.verified_unbroken_reps
+    return if reps.blank?
+    return 'Max' if reps.zero?
+
+    "#{reps}RM"
+  end
+
+  def rep_max_load_msg(movement_log)
+    pluralize(load_input_value(movement_log.load).to_i, load_display_unit)
+  end
+
+  # measurable_additional_metrics always parenthesizes its output, since it's meant to trail a
+  # reps message (e.g. "10 Rows (20 calories / 135 lbs)"). A pure distance/duration test with no
+  # reps has nothing for those parens to trail, so render the bare metrics instead.
+  def record_msg(movement_log)
+    reps_msg = measurable_reps_msg(movement_log)
+    return "#{reps_msg} #{measurable_additional_metrics(movement_log)}".strip if reps_msg
+
+    additional_metrics(movement_log).map { |metric| metric_unit_msg(metric) }.join(' / ')
+  end
+
+  DISTANCE_UNIT_ABBREVIATIONS = { 'meter' => 'm', 'foot' => 'ft', 'inch' => 'in' }.freeze
+
+  def distance_label(movement_log)
+    unit = (movement_log.distance_unit || 'meter').to_s
+    "#{movement_log.distance.to_i}#{DISTANCE_UNIT_ABBREVIATIONS.fetch(unit, unit)}"
+  end
+
+  def duration_msg(movement_log)
+    duration_metric_msg(Metric.new(measurement: :seconds, value: movement_log.duration_seconds))
+  end
+end
@@ -31,6 +31,9 @@ application.register("movement-select", MovementSelectController)
 import NestedFormController from "./nested_form_controller"
 application.register("nested-form", NestedFormController)
 
+import RepMaxRowController from "./rep_max_row_controller"
+application.register("rep-max-row", RepMaxRowController)
+
 import SegmentCardController from "./segment_card_controller"
 application.register("segment-card", SegmentCardController)
 
 
@@ -0,0 +1,16 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["toggle", "details", "caret"]
+  static values = { expanded: Boolean }
+
+  toggle() {
+    this.expandedValue = !this.expandedValue
+  }
+
+  expandedValueChanged() {
+    this.detailsTarget.hidden = !this.expandedValue
+    this.toggleTarget.setAttribute("aria-expanded", this.expandedValue.toString())
+    this.caretTarget.textContent = this.expandedValue ? "▴" : "▾"
+  }
+}
@@ -23,13 +23,14 @@ def round_sizes_for_set_breakdown(movement_log)
 
   private
 
-  # A single logged rep, or a dedicated single-lift weightlifting day, is unbroken by
-  # construction -- no self-report needed. reps: 0 is this app's existing "unspecified/max
-  # effort" sentinel (see ExercisePrescription#rep_prescription_metric), not a literal single
-  # rep, so it's excluded here and left unpopulated like any other not-yet-known case.
-  # Excludes structured round-repeat movements (AMRAPs, ascending ladders) entirely: for these,
-  # reps is a per-round value, not a lifetime total, so a build-time reps == 1 says nothing about
-  # what the eventual set_breakdown target will be once score_value is known.
+  # A single logged rep, or a set within a dedicated set-based lifting workout (see
+  # Workout#set_based_lifting? -- a fixed "5x5 Back Squat", or a variable build like "Back Squat:
+  # 5-5-3-3-1-1"), is unbroken by construction -- no self-report needed. reps: 0 is this app's
+  # existing "unspecified/max effort" sentinel (see ExercisePrescription#rep_prescription_metric),
+  # not a literal single rep, so it's excluded here and left unpopulated like any other
+  # not-yet-known case. Excludes structured round-repeat movements (AMRAPs, ascending ladders)
+  # entirely: for these, reps is a per-round value, not a lifetime total, so a build-time reps == 1
+  # says nothing about what the eventual set_breakdown target will be once score_value is known.
   def auto_populate_set_breakdown(movement_log, exercise)
     return if movement_log.reps.blank? || movement_log.reps.zero?
     return if structured_round_repeat?(exercise)
 
@@ -57,6 +57,25 @@ def set_breakdown_rounds
     chunk_set_breakdown_by_round(round_sizes)
   end
 
+  # The largest rep count this movement log can actually back up as one continuous, unbroken
+  # effort -- nil when that can't be verified. Three cases are unbroken by construction, not
+  # self-report: reps <= 1 (a single rep, or the app's "max effort" reps: 0 sentinel, can't be
+  # broken into sets); a set-based lifting day (Workout#set_based_lifting? -- a fixed "5x5" or a
+  # variable build like "5-5-3-3-1-1"); and a single max-effort achievement test
+  # (Workout#single_achievement_test? -- a bare "Max Pull-up"-style test, where going until
+  # failure in one continuous attempt is what the test *is*). Each of those proofs comes from
+  # workout structure that already exists for every log, old or new, so none of them need a
+  # captured set_breakdown to trust reps directly. Anything else needs a captured set_breakdown,
+  # and the largest entry in it is the real rep-max, not the raw (possibly WOD-aggregated) reps
+  # total -- e.g. Diane's Deadlift logs reps: 45 (21+15+9 summed by Metric#calculated_value) but
+  # set_breakdown: [21, 15, 9], so the verified rep-max is 21.
+  def verified_unbroken_reps
+    return if reps.blank?
+    return reps if reps <= 1 || log.workout.set_based_lifting? || log.workout.single_achievement_test?
+
+    set_breakdown.presence&.max
+  end
+
   private
 
   def compact_set_breakdown