Hayden (Edges) - Hotel

.gitignore

@@ -48,3 +48,5 @@ build-iPhoneSimulator/
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+coverage
+Guardfile

Guardfile

@@ -1,4 +1,4 @@
-guard :minitest, bundler: false, rubygems: false do
+guard :minitest, bundler: false, autorun: false, rubygems: false do
   # with Minitest::Spec
   watch(%r{^spec/(.*)_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }

design-activity.md

@@ -0,0 +1,41 @@
+1. Both implementations contains the same three classes--CartEntry, ShoppingCart, and Order.
+
+2. CartEntry - Responsible for a single entry in a ShoppingCart, tracks unit_price of an item and quantity of that item being purchased.
+
+   ShoppingCart - Responsible for multiple CartEntries.
+
+   Order - Responsible for calculating total price of a particular ShoppingCart
+
+3. CartEntry (one or many)
+           v
+   ShoppingCart (only one)
+           v
+         Order
+
+4. CartEntry - price of a single unit of an item, quantity of that item being purchased
+   ShoppingCart - holds multiple individual CartEntries
+   Order - sales tax constant, a single ShoppingCart
+
+   The data stored by each class does not change between implementations
+
+5. CartEntry - #price returns the price of a quantity of some item
+   ShoppingCart - #price returns the price of all entries in the cart
+   Order - #total_price returns the cart price + sales tax
+
+   Implementation A uses attr_accessor to make the data from CartEntry and ShoppingCart available to Order so it can calculate the total price, but Implementation B provides instance methods for each that return their respective prices, so that Order can simply call @cart.price then add sales tax.
+
+6. In Implementation B, the price logic is delegated to lower level classes, but in Implementation A it is not.
+
+   total_price does directly manipulate the instance variables of other classes in Implementation A, but not in B.
+
+7. Ideally we would be working with Implementation B and could just add conditional functionality in CartEntry#price that affected unit price based on quantity. In Implementation A we would need to modify the code in Order#total_price, which is both unintuitive and messy.
+
+8. Implementation B, absolutely. I've made my case above... lol
+
+9. Once again, B.
+
+
+-----------
+
+
+In RoomBooker#new_block_reservation, the local `room` variable is used to modify the state of the Room struct, which belongs to the RoomBlock instance. If I were to handle this functionality instead within the RoomBlock class itself in an instance method, my classes would be even more loosely coupled and resilient to future change/easier to change in the future.

lib/date_logic.rb

@@ -0,0 +1,33 @@
+module DateLogic
+  def DateLogic.date_range_include?(reservation, date)
+    if (reservation.check_in...reservation.check_out).cover?(date)
+      return true
+    else
+      return false
+    end
+  end
+
+  def DateLogic.date_ranges_exclusive?(
+    old_check_in,
+    old_check_out,
+    new_check_in,
+    new_check_out)
+
+    existing_range_array = date_range_array(old_check_in, old_check_out)
+
+    new_range_array = date_range_array(new_check_in, new_check_out)
+
+    intersecting_dates = existing_range_array & new_range_array
+
+    if intersecting_dates.empty?
+      return true
+    else
+      return false
+    end
+  end
+
+  def DateLogic.date_range_array(check_in, check_out)
+    date_range = check_in...check_out
+    return date_range.to_a
+  end
+end

lib/no_rooms_in_block.rb

@@ -0,0 +1,2 @@
+class NoRoomsInBlock < StandardError
+end

lib/reservation.rb

@@ -0,0 +1,23 @@
+module BookingLogic
+  class Reservation
+    attr_reader :room, :check_in, :check_out
+
+    def initialize(room, check_in, check_out)
+      check_date_range(check_in, check_out)
+      @room = room
+      @check_in = check_in
+      @check_out = check_out
+    end
+
+    def check_date_range(check_in, check_out)
+      if check_out <= check_in
+        raise StandardError, "Invalid date range provided"
+      end
+    end
+
+    def reservation_cost
+      days_reserved = check_out - check_in
+      return days_reserved.to_i * room.cost
+    end
+  end
+end

lib/room.rb

@@ -0,0 +1,4 @@
+module BookingLogic
+  class Room
+  end
+end

lib/room_block.rb

@@ -0,0 +1,44 @@
+require_relative 'no_rooms_in_block'
+
+module BookingLogic
+  class RoomBlock
+    attr_reader :name, :check_in, :check_out, :rooms, :rate
+
+    def initialize(name, check_in, check_out, room_block, rate)
+      check_number_of_rooms(room_block)
+      @name = name
+      @check_in = check_in
+      @check_out = check_out
+      @rooms = room_block
+      @rate = rate
+    end
+
+    def check_number_of_rooms(room_block)
+      if room_block.length > 5
+        raise StandardError, "Maximum of 5 rooms per room block"
+      end
+    end
+
+    def available
+      available_rooms = rooms.find_all { |room| room.block_reserved == nil }
+
+      if available_rooms.empty?
+        raise NoRoomsInBlock, "No rooms currently available in this block"
+      else
+        return available_rooms
+      end
+    end
+
+    def set_blocked_room_rate
+      rooms.each do |room|
+        room.cost = rate
+      end
+    end
+
+    def reserve_room
+      room = self.available.first
+      room.block_reserved = true
+      return room
+    end
+  end
+end

lib/room_booker.rb

@@ -0,0 +1,169 @@
+require 'date'
+require_relative 'date_logic'
+require_relative 'reservation'
+require_relative 'room_block'
+require_relative 'room_not_available'
+
+module BookingLogic
+  class RoomBooker
+    Room = Struct.new(:id, :cost, :block_reserved)
+
+    attr_reader :rooms
+    attr_accessor :reservations, :blocks
+
+    def initialize
+      @rooms = populate_rooms
+      @reservations = []
+      @blocks = []
+    end
+
+    def populate_rooms
+      rooms_array = []
+
+      20.times do |id|
+        room = Room.new((id + 1), 200)
+        rooms_array << room
+      end
+
+      return rooms_array
+    end
+
+    def list_rooms
+      return rooms
+    end
+
+    def find_room_by_id(room_id)
+      return rooms.find { |room| room.id == room_id }
+    end
+
+    def list_reservations(date)
+      list_of_reservations = []
+
+      reservations.each do |reservation|
+        if DateLogic.date_range_include?(reservation, date)
+          list_of_reservations << reservation
+        end
+      end
+
+      return list_of_reservations
+    end
+
+    def list_available_rooms(check_in, check_out)
+      reserved_rooms = []
+
+      reservations.each do |reservation|
+        unless DateLogic.date_ranges_exclusive?(
+          reservation.check_in,
+          reservation.check_out,
+          check_in,
+          check_out
+        )
+
+          reserved_rooms << reservation.room
+        end
+      end
+
+      unavailable_rooms = reserved_rooms + find_blocked_rooms(check_in, check_out)
+
+      available_rooms = rooms.dup
+
+      unavailable_rooms.each do |unavailable_room|
+        available_rooms.delete_if { |room| room.id == unavailable_room.id }
+      end
+
+      return available_rooms
+    end
+
+    def new_reservation(room_id, check_in, check_out)
+      room = find_room_by_id(room_id)
+      room_unavailable?(room, check_in, check_out)
+      new_reservation = BookingLogic::Reservation.new(room, check_in, check_out)
+      reservations << new_reservation
+      return new_reservation
+    end
+
+    def room_unavailable?(room, check_in, check_out)
+      unless list_available_rooms(check_in, check_out).include?(room)
+        raise RoomNotAvailable, "Room not available for the given dates"
+      end
+    end
+
+    def find_block(name)
+      found_block = blocks.find { |block| block.name == name }
+      return found_block
+    end
+
+    def find_blocked_rooms(check_in, check_out)
+      blocked_rooms = []
+
+      blocks.each do |block|
+        unless DateLogic::date_ranges_exclusive?(
+          block.check_in,
+          block.check_out,
+          check_in,
+          check_out
+        )
+
+          block.rooms.each do |room|
+            blocked_rooms << room
+          end
+        end
+      end
+
+      return blocked_rooms
+    end
+
+    def block_available_rooms(check_in, check_out, number_of_rooms, rate)
+
+      available_rooms = list_available_rooms(check_in, check_out)
+
+      room_block = []
+
+      number_of_rooms.times do |i|
+        room_block << available_rooms[i].dup
+      end
+
+      if room_block.length < number_of_rooms
+        raise StandardError, "There are not enough available rooms for the given dates to create this room block"
+      end
+
+      return room_block
+    end
+
+    def new_room_block(name, check_in, check_out, number_of_rooms, rate)
+
+      block_of_rooms = block_available_rooms(
+        check_in,
+        check_out,
+        number_of_rooms,
+        rate
+      )
+
+      new_room_block = BookingLogic::RoomBlock.new(
+        name,
+        check_in,
+        check_out,
+        block_of_rooms,
+        rate
+      )
+
+      new_room_block.set_blocked_room_rate
+
+      @blocks << new_room_block
+      return new_room_block
+    end
+
+    def new_block_reservation(name)
+      block = find_block(name)
+      room = block.reserve_room
+      new_reservation = BookingLogic::Reservation.new(room, block.check_in, block.check_out)
+      reservations << new_reservation
+      return new_reservation
+    end
+
+    def set_room_rate(room_id, custom_rate)
+      room = rooms.find { |room| room.id == room_id }
+      room.cost = custom_rate
+    end
+  end
+end

lib/room_not_available.rb

@@ -0,0 +1,2 @@
+class RoomNotAvailable < StandardError
+end