Danielle Cardona

lib/bike_club.rb

@@ -1,3 +1,47 @@
 class BikeClub
+    attr_reader :name,
+                :bikers
 
+    def initialize(name)
+        @name = name
+        @bikers = []
+    end
+
+    def add_biker(biker)
+        @bikers << biker
+    end
+
+    def most_rides
+        return nil if @bikers.empty?
+        @bikers.max_by { |biker| biker.rides.length }
+    end
+
+    def best_time(ride)
+        best_biker = nil
+        best_time = Float::INFINITY
+
+        @bikers.each do |biker|
+            if biker.rides.key?(ride)
+                times = biker.rides[ride]
+                current_best_time = times.min
+
+                if current_best_time < best_time
+                    best_time = current_best_time
+                    best_biker = biker 
+                end
+            end
+        end
+        best_biker
+    end
+
+    def bikers_eligible(ride)
+        bikers_eligible = []
+
+        @bikers.each do |biker|
+            if ride && biker.acceptable_terrain.include?(ride.terrain)
+                bikers_eligible << biker
+            end
+        end
+        bikers_eligible
+    end
 end

lib/biker.rb

@@ -1,3 +1,30 @@
 class Biker
+    attr_reader :name,
+                :max_distance,
+                :rides,
+                :acceptable_terrain
 
+    def initialize(name, max_distance)
+        @name = name
+        @max_distance = max_distance
+        @rides = {}
+        @acceptable_terrain = []
+    end
+
+    def learn_terrain!(terrain)
+        @acceptable_terrain << terrain unless @acceptable_terrain.include?(terrain)
+    end
+
+    def log_ride(ride, time)
+        return false if ride.distance > max_distance || !@acceptable_terrain.include?(ride.terrain) 
+
+        rides[ride] ||= []
+        rides[ride] << time
+    end
+
+    def personal_record(ride)
+        return false unless @rides.key?(ride)
+
+        @rides[ride].min
+    end
 end

lib/ride.rb

@@ -1,3 +1,25 @@
 class Ride
+    attr_reader :name,
+                :distance,
+                :loop,
+                :terrain
 
+    def initialize(ride_info)
+        @name = ride_info[:name]
+        @distance = ride_info[:distance]
+        @loop = ride_info[:loop]
+        @terrain = ride_info[:terrain]
+    end
+
+    def loop?
+        @loop
+    end
+
+    def total_distance
+        if loop?
+            total_distance = @distance 
+        else
+            total_distance = @distance * 2
+        end
+    end
 end

spec/bike_club_spec.rb

@@ -0,0 +1,96 @@
+require './lib/ride'
+require './lib/biker'
+require './lib/bike_club'
+
+RSpec.describe BikeClub do
+    before(:each) do
+        @bikeclub = BikeClub.new("Awesome Bike Club")
+        @biker = Biker.new("Kenny", 30)
+        @biker2 = Biker.new("Athena", 15)
+
+        @ride1 = Ride.new({name: "Walnut Creek Trail", distance: 10.7, loop: false, terrain: :hills}) 
+        @ride2 = Ride.new({name: "Town Lake", distance: 14.9, loop: true, terrain: :gravel})
+
+        @biker.learn_terrain!(:gravel)
+        @biker.learn_terrain!(:hills)
+
+        @biker.log_ride(@ride1, 92.5)
+        @biker.log_ride(@ride1, 91.1)
+        @biker.log_ride(@ride2, 60.9)
+        @biker.log_ride(@ride2, 61.6)
+    end
+
+    describe '#initialize' do
+        it 'exists' do
+            expect(@bikeclub).to be_instance_of(BikeClub)
+            expect(@bikeclub.name).to eq("Awesome Bike Club")
+        end
+
+        it 'starts with an empty array of bikers' do
+            expect(@bikeclub.bikers).to eq([])
+        end
+    end
+
+    describe '#bikers' do
+        it 'can add bikers' do
+            @bikeclub.add_biker(@biker)
+
+            expect(@bikeclub.bikers).to include(@biker)
+        end
+
+        it 'can add more bikers' do
+            @bikeclub.add_biker(@biker)
+            @bikeclub.add_biker(@biker2)
+
+            expect(@bikeclub.bikers).to include(@biker, @biker2)
+        end
+    end
+
+    describe '#rides' do
+        it 'can identify the biker with the most rides' do
+            @bikeclub.add_biker(@biker)
+
+            expect(@bikeclub.most_rides).to eq(@biker)
+        end
+
+        it 'identifies bikers eligible for a ride' do
+            @bikeclub.add_biker(@biker)
+            @bikeclub.add_biker(@biker2)
+
+            expect(@bikeclub.bikers_eligible(@ride1)).to eq([@biker])
+        end
+
+    end
+
+    describe '#times' do
+        it 'can identify the biker with the best time' do
+            @bikeclub = BikeClub.new("Awesome Bike Club")
+
+            @biker = Biker.new("Kenny", 30)
+            @biker2 = Biker.new("Athena", 15)
+
+            @ride1 = Ride.new({name: "Walnut Creek Trail", distance: 10.7, loop: false, terrain: :hills}) 
+            @ride2 = Ride.new({name: "Town Lake", distance: 14.9, loop: true, terrain: :gravel})
+
+            @biker.learn_terrain!(:gravel)
+            @biker.learn_terrain!(:hills)
+
+            @biker.log_ride(@ride1, 92.5)
+            @biker.log_ride(@ride1, 91.1)
+            @biker.log_ride(@ride2, 60.9)
+            @biker.log_ride(@ride2, 61.6)
+
+            @biker2.learn_terrain!(:gravel)
+            @biker2.learn_terrain!(:hills)
+
+            @biker2.log_ride(@ride2, 90.0)
+            @biker2.log_ride(@ride2, 55.0)
+
+            @bikeclub.add_biker(@biker)
+            @bikeclub.add_biker(@biker2)
+
+            best_biker = @bikeclub.best_time(@ride2)
+            expect(best_biker(@ride1)).to eq(@biker)
+        end
+    end
+end

spec/biker_spec.rb

@@ -0,0 +1,117 @@
+require './lib/ride'
+require './lib/biker'
+
+RSpec.describe Biker do
+    before(:each) do
+        @biker = Biker.new("Kenny", 30)
+        @biker2 = Biker.new("Athena", 15)
+        @ride1 = Ride.new({name: "Walnut Creek Trail", distance: 10.7, loop: false, terrain: :hills}) 
+        @ride2 = Ride.new({name: "Town Lake", distance: 14.9, loop: true, terrain: :gravel})
+    end
+
+    describe '#initialize' do
+        it "exists" do
+            expect(@biker).to be_instance_of(Biker)
+        end
+
+        it 'has attributes' do
+            expect(@biker.name).to eq("Kenny")
+            expect(@biker.max_distance).to eq(30)
+            expect(@biker2.name).to eq("Athena")
+            expect(@biker2.max_distance).to eq(15)
+        end
+    end
+
+    describe '#rides' do
+        it 'begins with an empty hash of rides' do
+            expect(@biker.rides).to eq({})
+        end
+    end
+
+    describe '#terrain' do
+        it 'has acceptable terrain' do
+            expect(@biker.acceptable_terrain).to eq([])
+        end
+
+        it 'can learn terrain' do
+            @biker.learn_terrain!(:gravel)
+
+            expect(@biker.acceptable_terrain).to eq([:gravel])
+        end
+
+        it 'can learn multiple terrains' do
+            @biker.learn_terrain!(:gravel)
+            @biker.learn_terrain!(:hills)
+
+            expect(@biker.acceptable_terrain).to eq([:gravel, :hills])
+        end
+    end
+
+    describe '#logging rides' do
+        before(:each) do
+            @ride1 = Ride.new({name: "Walnut Creek Trail", distance: 10.7, loop: false, terrain: :hills}) 
+            @ride2 = Ride.new({name: "Town Lake", distance: 14.9, loop: true, terrain: :gravel})
+        end
+
+        it 'can log rides' do
+            @biker.log_ride(@ride1, 92.5)
+
+            expect(@biker.rides).to eq({})
+        end
+
+        it 'will not log a ride if the biker has not learned the terrain' do
+            # require 'pry';binding.pry
+            expect(@biker2.log_ride(@ride1, 97.0)).to eq(false)
+            expect(@biker2.log_ride(@ride2, 67.0)).to eq(false)
+            expect(@biker2.rides).to eq({})
+        end
+
+        it 'logs rides once a biker has learned the terrain' do
+            @biker2.learn_terrain!(:gravel)
+            @biker2.learn_terrain!(:hills)
+            @biker2.log_ride(@ride2, 67.0)
+
+            expect(@biker2.rides).to eq({@ride2 => [67.0]})
+        end
+
+        it 'can log multiple rides' do
+            @biker.learn_terrain!(:gravel)
+            @biker.learn_terrain!(:hills)
+            @biker.log_ride(@ride1, 92.5)
+            @biker.log_ride(@ride1, 91.1)
+            @biker.log_ride(@ride2, 60.9)
+            @biker.log_ride(@ride2, 61.6)
+
+            expect(@biker.rides).to include(@ride1)
+            expect(@biker.rides[@ride1].length).to eq(2)
+        end
+
+        it 'does not log rides if they exceed a bikers max distance' do
+            @biker2.learn_terrain!(:gravel)
+            @biker2.log_ride(@ride2, 65.0)
+
+            expect(@biker2.log_ride(@ride1, 95.0)).to eq(false)
+            expect(@biker2.rides[@ride2].length).to eq(1)
+        end
+
+    end
+
+    describe '#timing rides' do
+        before(:each) do
+            @biker.learn_terrain!(:gravel)
+            @biker.learn_terrain!(:hills)
+        end
+
+        it 'identifies a bikers personal record' do
+        @biker.log_ride(@ride1, 92.5)
+
+        expect(@biker.personal_record(@ride1)).to eq(92.5)
+        end
+
+        it 'updates the bikers personal record' do
+        @biker.log_ride(@ride1, 91.1)
+
+        expect(@biker.personal_record(@ride1)).to eq(91.1)
+        end
+    end
+end

spec/ride_spec.rb

@@ -0,0 +1,29 @@
+require './lib/ride'
+
+RSpec.describe Ride do
+    before(:each) do
+        @ride1 = Ride.new({name: "Walnut Creek Trail", distance: 10.7, loop: false, terrain: :hills}) 
+        @ride2 = Ride.new({name: "Town Lake", distance: 14.9, loop: true, terrain: :gravel})
+    end
+
+    describe '#initialize' do
+        it "exists" do
+            expect(@ride1).to be_instance_of(Ride)
+        end
+
+        it 'has information' do
+            expect(@ride1.name).to eq("Walnut Creek Trail")
+            expect(@ride1.distance).to eq(10.7)
+            expect(@ride1.terrain).to eq(:hills)
+            expect(@ride1.loop?).to eq(false)
+            expect(@ride2.loop?).to eq(true)
+        end
+    end
+
+    describe '#distance' do
+        it 'calculates distance' do
+            expect(@ride1.total_distance).to eq(21.4)
+            expect(@ride2.total_distance).to eq(14.9)
+        end
+    end
+end