Space - Lee

.gitignore

@@ -1,3 +1,4 @@
+.DS_Store
 *.gem
 *.rbc
 /.config

lib/block.rb

@@ -0,0 +1,17 @@
+module Hotel
+	class Block 
+		attr_reader :id, :rooms, :rate, :date_range
+
+		def initialize(id:, rooms:, rate:, start_date:, end_date:)
+			@id = id
+			@rooms = rooms
+			@rate = rate
+			@date_range = Hotel::DateRange.new(
+				start_date: start_date, 
+				end_date: end_date
+			)
+
+			raise ArgumentError.new("Block must contain between 2 and 5 rooms!") if @rooms.length < 2 || @rooms.length > 5
+		end
+	end
+end

lib/date_range.rb

@@ -0,0 +1,38 @@
+module Hotel
+	class DateRange
+		attr_accessor :start_date, :end_date
+
+		def initialize(start_date:, end_date:)
+			@start_date = start_date
+			@end_date = end_date
+
+			raise ArgumentError.new("Invalid date range!") if @start_date > @end_date
+		end
+
+		def nights
+			return (@end_date - @start_date).to_i
+		end
+
+		def overlap?(other)
+			return @start_date <= other.end_date && @end_date >= other.start_date
+		end		
+
+		def include?(date)
+			low = 0
+			high = self.nights
+
+			while low <= high
+				mid = (low + high) / 2
+				if (@start_date + mid) == date
+					return true
+				elsif (@start_date + mid) > date
+					high = mid - 1
+				elsif (@start_date + mid) < date
+					low = mid + 1
+				end
+			end
+
+			return false
+		end
+	end
+end

lib/front_desk.rb

@@ -0,0 +1,103 @@
+module Hotel
+	class FrontDesk
+		attr_reader :rooms, :reservations, :blocks
+
+		def initialize
+			@rooms = (1..20).to_a
+			@reservations = []
+			@blocks = []
+		end
+
+		def add_reservation(reservation)
+			@reservations << reservation
+		end
+
+		def reservations_by_room(room, date_range)
+			return @reservations.select { |reservation| 
+				reservation.room == room && reservation.date_range.overlap?(date_range)
+			}
+		end
+
+		def reservations_by_date(date)
+			return @reservations.select { |reservation| 
+				reservation.date_range.include?(date) 
+			}
+		end
+
+		def find_available_room(date_range)
+			unavailable_rooms = @reservations.map { |reservation| 
+				reservation.room if reservation.date_range.start_date < date_range.end_date && reservation.date_range.end_date > date_range.start_date
+			}
+			@blocks.each { |block| 
+				(block.rooms).each { |room| unavailable_rooms << room } if block.date_range.start_date < date_range.end_date && block.date_range.end_date > date_range.start_date
+			} # This method is very expensive. See refactors.txt for details.
+			available_rooms = @rooms - unavailable_rooms
+
+			raise ArgumentError.new("No rooms available for that date range!") if available_rooms.empty?		
+			return available_rooms		
+		end
+
+		def reserve_room(date_range, rate = 200.0)
+			new_reservation = Hotel::Reservation.new(
+				id: @reservations.length + 1,
+				room: find_available_room(date_range).first, 
+				rate: rate.to_f,
+				start_date: date_range.start_date,
+				end_date: date_range.end_date
+			)
+			add_reservation(new_reservation)	
+			return new_reservation
+		end
+
+		def add_block(block)
+			@blocks << block
+		end
+
+		def find_block(id)
+			block = @blocks.find { |block| block.id == id }
+			raise ArgumentError.new("No blocks with the given ID!") if block.nil?
+			return block
+		end
+
+		def reserve_block(rooms, rate, date_range)
+			rooms.each { |room|
+				raise ArgumentError.new("At least one of the rooms is unavailable for the given date range!") if !find_available_room(date_range).include?(room) 
+			}
+
+			new_block = Hotel::Block.new(
+				id: @blocks.length + 1,
+				rooms: rooms,
+				rate: rate,
+				start_date: date_range.start_date,
+				end_date: date_range.end_date
+			)
+			add_block(new_block)
+			return new_block
+		end
+
+		def find_available_room_in_block(id)
+			block = find_block(id)
+			unavailable_rooms = @reservations.map { |reservation| 
+				reservation.room if reservation.block == block.id 
+			}
+			available_rooms = block.rooms - unavailable_rooms
+
+			raise ArgumentError.new("No rooms available in the given block!") if available_rooms.empty?
+			return available_rooms
+		end
+
+		def reserve_room_in_block(id, room)
+			block = find_block(id)
+			new_reservation = Hotel::Reservation.new(
+				id: @reservations.length + 1,
+				room: room,
+				block: block.id,
+				rate: block.rate,
+				start_date: block.date_range.start_date,
+				end_date: block.date_range.end_date
+			)
+			add_reservation(new_reservation)
+			return new_reservation
+		end
+	end
+end

lib/reservation.rb

@@ -0,0 +1,24 @@
+require_relative 'date_range'
+
+module Hotel
+	class Reservation
+		attr_reader :id, :room, :block, :rate, :date_range
+
+		def initialize(id:, room:, block: false, rate: 200.0, start_date:, end_date:)
+			@id = id
+			@room = room
+			@block = block
+			@rate = rate.to_f
+			@date_range = Hotel::DateRange.new(
+				start_date: start_date, 
+				end_date: end_date
+			)
+
+			raise ArgumentError.new("Invalid rate!") if rate.class != Float
+		end	
+
+		def total_cost
+			return @date_range.nights * @rate 
+		end
+	end
+end

refactors.txt

@@ -0,0 +1,43 @@
+=================
+lib/front_desk.rb
+=================
+
+1) class FrontDesk
+- Since the program will be used by employees of the hotel and not the general public, I thought FrontDesk would be more descriptive. But if the program is ported to an online reservation system that is open to the general public, the class name should probably change to HotelController or ReservationSystem.
+
+2) #find_available_room 
+- This method is very expensive because it iterates through two arrays of unknown size (time complexity is O(n^2)) and it creates a new array in memory each time it adds a room to the unavailable_rooms list (space complexity is O(n)).
+- If I created a Room class that knew its Reservations and/or the Blocks it belonged to during a DateRange, I could refactor this method to just use the #reject enumerable, rejecting any rooms that met the existing conditionals.
+
+3) any method that has date_range as a parameter
+- I was visualizing this program as the backend of a digital form with separate fields for the start and end dates of range (if the function required that information). Each time the 'submit' button is pressed, the program would collect the values of these fields and use them to instantiate a new DateRange object, then pass that object into the method. This is why the start_date and end_date attributes are both readable and writable, so they can be written from outside the program. However, I'm not sure if this will work as intended, so it's possible that many of my tests are passing superficially!
+
+4) #reserve_room & #reserve_room_in_block
+- I may be able to merge these methods into one, because a Reservation can be instantiated without a block and rate attribute.
+- If I create a Room class, I could have the rate stored in each Room instead of having it passed into these methods.
+- But if the program is ported to an online reservation system that is open to the general public, these methods should stay separate because the general public is not allowed to reserve rooms in blocks.
+
+==================
+lib/reservation.rb
+==================
+
+1) #rate & #total_cost
+- If I create a Room class, I could have the rate stored in each Room instead of having it passed into a new Reservation. 
+- The #total_cost method would then call the room.rate
+
+2) #start_date & #end_date
+- I was thinking that since these attributes can be written over in the DateRange class, they should probably not be stored anywhere else. But if each Reservation was able to call its start_date and end_date, this would simplify some method calls in the FrontDesk class. Perhaps this is an opportunity for inheritance (i.e., class Reservation < DateRange)?
+
+=================
+lib/date_range.rb
+=================
+
+1) #include?
+- An earlier version simply returned (start_date..end_date).include?(date), which creates an instance of the Range class, which already has an include? method. I'm wondering if this was a better design, but I also wanted to avoid dependencies (if the Range class changes in the future, any method that creates an instance of that class might break). Instead, I created a binary search method that is not dependent on an additional class.
+
+============
+lib/block.rb
+============
+
+1) class Block
+- If I create a Room class, there could be an opportunity for inheritance here (i.e., a Block is a Room), which could help with the FrontDesk#find_available_room (see notes above)

test/block_test.rb

@@ -0,0 +1,50 @@
+require_relative 'test_helper'
+
+describe "Block class" do
+	before do 
+		@block = Hotel::Block.new(
+			id: 1,
+			rooms: (1..5).to_a,
+			rate: 150.0,
+			start_date: Date.new(2020,3,2),
+			end_date: Date.new(2020,3,5)
+		)
+	end
+
+	describe "Block instantiation" do
+		it "is an instance of Block" do
+			expect(@block).must_be_kind_of Hotel::Block
+		end
+
+		it "is set up for specific attributes and data types" do
+      [:id, :rooms, :rate, :date_range].each do |attribute|
+        expect(@block).must_respond_to attribute
+      end
+
+			expect(@block.id).must_be_kind_of Integer
+			expect(@block.rooms).must_be_kind_of Array
+			expect(@block.rate).must_be_kind_of Float
+			expect(@block.date_range).must_be_kind_of Hotel::DateRange
+    end
+
+		it "throws an exception if the list of rooms is greater than 5" do
+			expect{ Hotel::Block.new(
+				id: 1,
+				rooms: (1..6).to_a,
+				rate: 150.0,
+				start_date: Date.new(2020,3,2),
+				end_date: Date.new(2020,3,5)
+			) }.must_raise ArgumentError
+		end
+
+		it "throws an exception if the list of rooms is less than 2" do
+			expect{ Hotel::Block.new(
+				id: 1,
+				rooms: [1],
+				rate: 150.0,
+				start_date: Date.new(2020,3,2),
+				end_date: Date.new(2020,3,5)
+			) }.must_raise ArgumentError
+		end
+	end
+end