change train method to accept reps.

@@ -2,10 +2,19 @@ class ExerciseSession < ActiveRecord::Base
   belongs_to :training_session
   belongs_to :exercise_workout
   has_one :exercise, through: :exercise_workout
-  has_many :exercise_sets, dependent: :destroy
+  has_many :exercise_sets, -> { order(:created_at) }, dependent: :destroy
   delegate :name, to: :exercise
 
   def sets
     exercise_sets
   end
+
+  def to_sets
+    sets.map(&:actual_repetitions)
+  end
+
+  #def target_weight
+    ## shim for migrations
+    #read_attribute(:target_weight) || sets.first.target_weight
+  #end
 end

@@ -1,3 +1,4 @@
 class ExerciseSet < ActiveRecord::Base
   belongs_to :exercise_session
+  has_one :exercise, through: :exercise_session
 end

@@ -43,7 +43,7 @@ class TrainingHistory
       joins(:exercise).
       where(exercises: { name: exercise.name }).
       inject({}) do |memo, session|
-        memo[session.training_session.occurred_at] = session.target_weight
+        memo[session.training_session.occurred_at] = session.sets.first.target_weight
         memo
       end
   end

@@ -6,22 +6,17 @@ class TrainingSession < ActiveRecord::Base
   has_many :exercises, through: :exercise_sessions
   accepts_nested_attributes_for :exercise_sessions
 
-  def train(exercise, target_weight, completed_sets)
+  def train(exercise, target_weight, repetitions:, set: nil)
     recommendation = workout.exercise_workouts.find_by(exercise: exercise)
 
-    session = exercise_sessions.find_by(exercise_workout: recommendation)
-    if session.present?
-      session.update!(actual_sets: completed_sets, target_weight: target_weight)
-      session
-    else
-      exercise_sessions.create!(
-        actual_sets: completed_sets,
-        exercise_workout: recommendation,
-        target_repetitions: recommendation.repetitions,
-        target_sets: recommendation.sets,
-        target_weight: target_weight,
-      )
-    end
+    session = exercise_sessions.find_or_create_by(exercise_workout: recommendation)
+    exercise_set = set.present? ? session.sets.at(set-1) : session.sets.build
+    exercise_set.update!(
+      actual_repetitions: repetitions,
+      target_repetitions: recommendation.repetitions,
+      target_weight: target_weight,
+    )
+    session
   end
 
   def progress_for(exercise)

@@ -3,7 +3,7 @@ class CreateExerciseSets < ActiveRecord::Migration
     create_table :exercise_sets, id: :uuid do |t|
       t.uuid :exercise_session_id, null: false
       t.integer :target_repetitions, null: false
-      t.integer :actual_repetitions, null: false, default: 0
+      t.integer :actual_repetitions
       t.float :target_weight, null: false
 
       t.timestamps null: false

@@ -25,12 +25,12 @@ ActiveRecord::Schema.define(version: 20160611171913) do
   end
 
   create_table "exercise_sets", id: :uuid, default: "uuid_generate_v4()", force: :cascade do |t|
-    t.uuid     "exercise_session_id",             null: false
-    t.integer  "target_repetitions",              null: false
-    t.integer  "actual_repetitions",  default: 0, null: false
-    t.float    "target_weight",                   null: false
-    t.datetime "created_at",                      null: false
-    t.datetime "updated_at",                      null: false
+    t.uuid     "exercise_session_id", null: false
+    t.integer  "target_repetitions",  null: false
+    t.integer  "actual_repetitions"
+    t.float    "target_weight",       null: false
+    t.datetime "created_at",          null: false
+    t.datetime "updated_at",          null: false
   end
 
   create_table "exercise_workouts", id: :uuid, default: "uuid_generate_v4()", force: :cascade do |t|

@@ -5,7 +5,7 @@ describe TrainingSession, type: :model do
 
   describe "#train" do
     let(:workout) { subject.workout }
-    let(:sets) { [5, 5, 5, 5, 5] }
+    #let(:sets) { [5, 5, 5, 5, 5] }
     let(:target_weight) { 200 }
     let(:squat) { create(:exercise) }
 
@@ -14,28 +14,63 @@ describe TrainingSession, type: :model do
     end
 
     it "returns a completed exercise" do
-      result = subject.train(squat, target_weight, sets)
+      result = subject.train(squat, target_weight, repetitions: 5)
+
+      expect(result).to be_persisted
+      expect(result.exercise).to eql(squat)
+      expect(result.to_sets).to eql([5])
+      expect(result.sets.at(0).exercise).to eql(squat)
+      expect(result.sets.at(0).target_weight).to eql(target_weight.to_f)
+      expect(result.sets.at(0).target_repetitions).to eql(5)
+      expect(result.sets.at(0).actual_repetitions).to eql(5)
+    end
+
+    it 'records the next set' do
+      subject.train(squat, target_weight, repetitions: 5)
+      result = subject.train(squat, target_weight, repetitions: 3)
+
       expect(result).to be_persisted
-      expect(result.target_weight).to eql(target_weight.to_f)
       expect(result.exercise).to eql(squat)
-      expect(result.actual_sets).to eql(sets.map(&:to_s))
+      expect(result.to_sets).to eql([5, 3])
+      expect(result.sets.at(0).exercise).to eql(squat)
+      expect(result.sets.at(0).target_weight).to eql(target_weight.to_f)
+      expect(result.sets.at(0).target_repetitions).to eql(5)
+      expect(result.sets.at(0).actual_repetitions).to eql(5)
+      expect(result.sets.at(1).exercise).to eql(squat)
+      expect(result.sets.at(1).target_weight).to eql(target_weight.to_f)
+      expect(result.sets.at(1).target_repetitions).to eql(5)
+      expect(result.sets.at(1).actual_repetitions).to eql(3)
     end
 
     it "updates a completed exercise" do
-      subject.train(squat, target_weight, sets)
+      subject.train(squat, target_weight, repetitions: 5)
+      subject.train(squat, target_weight, repetitions: 5)
+      subject.train(squat, target_weight, repetitions: 5)
 
       new_weight = target_weight + 10
-      new_sets = [5, 5, 5]
-      result = subject.train(squat, new_weight, new_sets)
+      result = subject.train(squat, new_weight, repetitions: 3, set: 2)
+
       expect(result).to be_persisted
-      expect(result.target_weight).to eql(new_weight.to_f)
       expect(result.exercise).to eql(squat)
-      expect(result.actual_sets).to eql(new_sets.map(&:to_s))
+      expect(result.to_sets).to eql([5, 3, 5])
+      expect(result.sets.at(0).exercise).to eql(squat)
+      expect(result.sets.at(0).target_weight).to eql(target_weight.to_f)
+      expect(result.sets.at(0).target_repetitions).to eql(5)
+      expect(result.sets.at(0).actual_repetitions).to eql(5)
+      expect(result.sets.at(1).exercise).to eql(squat)
+      expect(result.sets.at(1).target_weight).to eql(new_weight.to_f)
+      expect(result.sets.at(1).target_repetitions).to eql(5)
+      expect(result.sets.at(1).actual_repetitions).to eql(3)
+      expect(result.sets.at(2).exercise).to eql(squat)
+      expect(result.sets.at(2).target_weight).to eql(target_weight.to_f)
+      expect(result.sets.at(2).target_repetitions).to eql(5)
+      expect(result.sets.at(2).actual_repetitions).to eql(5)
     end
 
     it "cannot save a duplicate exercise" do
-      result = subject.train(squat, target_weight, sets)
-      subject.train(squat, target_weight, sets)
+      result = subject.train(squat, target_weight, repetitions: 5)
+      subject.train(squat, target_weight, repetitions: 5)
+
       expect(subject.exercise_sessions.count).to eql(1)
       expect(subject.exercise_sessions).to match_array([result])
     end
@@ -47,14 +82,14 @@ describe TrainingSession, type: :model do
 
     before :each do
       workout.add_exercise(exercise)
-      subject.train(exercise, 100, [5, 5])
+      subject.train(exercise, 100, repetitions: 5)
+      subject.train(exercise, 100, repetitions: 5)
     end
 
     it "returns the progress for the specific exercise" do
       result = subject.progress_for(exercise)
       expect(result.exercise).to eql(exercise)
-      expect(result.actual_sets).to eql(["5", "5"])
-      expect(result.target_weight).to eql(100.0)
+      expect(result.to_sets).to eql([5, 5])
     end
   end
 end

Commit 6b4c9ea

Commit `6b4c9ea`