Pipes - Kate Evans-Spitzer - Hotel

.gitignore

@@ -9,6 +9,7 @@
 /test/tmp/
 /test/version_tmp/
 /tmp/
+design.md
 
 # Used by dotenv library to load environment variables.
 # .env

Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ['lib']
+  t.warning = true
+  t.test_files = FileList['./specs/*_spec.rb']
+end
+
+task default: :test

design-activity.md

@@ -0,0 +1,99 @@
+### Activity
+##### What classes does each implementation include? Are the lists the same?  
+
+Yes, they are the same. Both implementations have:  
+  * CartEntry
+  * ShoppingCart
+  * Order
+
+
+##### Write down a sentence to describe each class.  
+
+Implementation A:  
+* CartEntry
+  * Contains basic pricing info entry
+* ShoppingCart
+  * Contains CartEntry objects
+* Order
+  * Contains and totals a ShoppingCart object
+
+Implementation B:
+* CartEntry
+  * Manages all pricing info of a single entry
+* ShoppingCart
+  * Contains and totals CartEntry objects
+* Order
+  * Contains and totals ShoppingCart, accounting for sales tax
+
+##### How do the classes relate to each other? It might be helpful to draw a diagram on a whiteboard or piece of paper.  
+* Order _has a_ ShoppingCart
+* ShoppingCart _has many_ CartEntries
+
+##### What data does each class store? How (if at all) does this differ between the two implementations?  
+Implementation A:  
+* CartEntry
+  * Unit price
+  * Unit quantity
+* ShoppingCart
+  * List of CartEntries
+* Order
+  * ShoppingCart
+  * Total price of all CartEntries in ShoppingCart
+
+Implementation B:
+* CartEntry
+  * Unit price
+  * Unit quantity
+  * Total entry price
+* ShoppingCart
+  * List of CartEntries
+  * Total of all CartEntry prices
+* Order
+  * ShoppingCart
+  * Total price of ShoppingCart with tax
+
+##### What methods does each class have? How (if at all) does this differ between the two implementations?  
+Implementation A:  
+* CartEntry
+  * #unit_price
+  * #quantity
+* ShoppingCart
+  * #entries
+* Order
+  * #cart
+  * #total_price
+
+Implementation B:
+* CartEntry
+  * #price
+* ShoppingCart
+  * #price
+* Order
+  * #total_price
+
+Implementation A uses attr_accessor methods to make all of the data contained within each class publicly accessible. Implementation B keeps this data private and uses a #price method on CartEntry and ShoppingCart classes to return only the necessary information (in this case, price).
+
+##### Consider the Order#totalprice method. In each implementation:  
+
+##### Is logic to compute the price delegated to "lower level" classes like ShoppingCart and CartEntry, or is it retained in Order?  
+
+Implementation A requires the Order#total_price method to dig through the ShoppingCart class and into the CartEntry class to directly access its variables, while Implementation B takes the returned value of ShoppingCart#price and performs its logic around that.
+
+##### Does totalprice directly manipulate the instance variables of other classes?  
+
+Implementation A directly reads the instance variables of the ShoppingCart and CartEntry classes, though it does not modify them. Implementation B does not directly read or modify any other class' instance variables.
+
+##### If we decide items are cheaper if bought in bulk, how would this change the code? Which implementation is easier to modify?  
+
+Implementation B would be easier to modify, as this change would only affect the CartEntry class, which could be updated to modify price based on quantity. In Implementation A, this would require the Order#total_price method to perform this additional logic within the same method where it is already calculating the total _and_ applying sales tax.
+
+##### Which implementation better adheres to the single responsibility principle?  
+
+Implementation B better adheres to this principle, as each class manages and encapsulates its relevant information.
+
+##### Bonus question once you've read Metz ch. 3: Which implementation is more loosely coupled?  
+
+### Revisiting Hotel
+Overall, I feel that I did a pretty good job of adhering to the single responsibility principle. The only thing that bothers me about my design is that the price of each room comes from a constant variable defined within the Hotel class, but since the current spec of the project is for all of the hotel's rooms to have a price of 200, I still think it makes the most sense for the time being. How I would refactor the code to account for varying room types would vary depending on how the rooms' prices were being determined, so there's nothing to change at the moment.
+
+The change I _did_ make was to remove the #validate method from the DateRange class. My thought process behind the change was that the method (which converts valid input into a Date object if it isn't already one) only interacts with one date, and therefore should be part of the Date class, not DateRange.

lib/block.rb

@@ -0,0 +1,28 @@
+module Hotel
+  class Block
+    attr_reader :rooms, :id, :start_date, :end_date, :dates, :discount_rate
+
+    def initialize(start_date, end_date, rooms, discount_rate = 0)
+      @start_date = Date.parse(start_date)
+      @end_date = Date.parse(end_date)
+      @dates = DateRange.range_to(@start_date, @end_date)
+      @rooms = rooms
+      @discount_rate = get_discount_rate(discount_rate)
+      @id = create_id
+    end
+
+    def create_id
+      format('B%.2d%.2d%.4d', @start_date.month, @start_date.day, rand(9999))
+    end
+
+    def includes_dates?(checkfirst, checklast)
+      DateRange.include_all?(checkfirst, checklast, @start_date, @end_date)
+    end
+
+    def get_discount_rate(input)
+      raise(ArgumentError, "Discount must be number: was #{input.class}") unless (input.class == Integer) || (input.class == Float)
+      raise(DiscountError, "Discount must be between 0-100%: was #{input}") unless 0 <= input && input <= 100
+      return (100.0 - input) / 100
+    end
+  end
+end

lib/date_range.rb

@@ -0,0 +1,68 @@
+module DateRange
+  require 'date'
+
+  def self.range_to(start_date, end_date)
+    start_date = Date.validate(start_date)
+    end_date = Date.validate(end_date)
+    validate_order(start_date, end_date)
+    dates = []
+    while start_date < end_date
+      dates << start_date
+      start_date += 1
+    end
+    dates
+  end
+
+  def self.overlap?(first_start, first_end, second_start, second_end)
+    first_start = Date.validate(first_start)
+    first_end = Date.validate(first_end)
+    second_start = Date.validate(second_start)
+    second_end = Date.validate(second_end)
+
+    first_dates = DateRange.range_to(first_start, first_end)
+    second_dates = DateRange.range_to(second_start, second_end)
+
+    first_dates.each do |first_date|
+      second_dates.each do |second_date|
+        return true if first_date.strftime == second_date.strftime
+      end
+    end
+    false
+  end
+
+  def self.include_all?(search_start, search_end, contain_start, contain_end)
+    search_start = Date.validate(search_start)
+    search_end = Date.validate(search_end)
+    contain_start = Date.validate(contain_start)
+    contain_end = Date.validate(contain_end)
+
+    search_dates = DateRange.range_to(search_start, search_end)
+    contain_dates = DateRange.range_to(contain_start, contain_end)
+
+    search_dates.each do |search_date|
+      return false unless contain_dates.include? search_date
+    end
+    true
+  end
+
+  def self.validate_order(first, second)
+    first = Date.validate(first)
+    second = Date.validate(second)
+    unless first < second
+      raise(DatesError, 'Start date must be at least 1 day before end date')
+    end
+    true
+  end
+end
+
+class Date
+  def self.validate(input)
+    if input.class == Date
+      return input
+    elsif input.class == String
+      return Date.parse(input)
+    else
+      raise(ArgumentError, "Input #{input.class} cannot be converted into Date")
+    end
+  end
+end

lib/exceptions.rb

@@ -0,0 +1,16 @@
+class NoRoomError < StandardError
+  # Raised when there are not enough available rooms for request
+end
+
+class DatesError < StandardError
+  # Raised when dates are in wrong order, out of range, etc
+  # NOT raised for invalid date input (use ArgumentError)
+end
+
+class NoBlockError < StandardError
+  # Raised when provided block does not exist/cannot be found
+end
+
+class DiscountError < StandardError
+  # Raised when discount is not number from 0-100
+end

lib/hotel.rb

@@ -0,0 +1,104 @@
+require 'pry'
+
+module Hotel
+  require_relative 'room'
+  require_relative 'reservation'
+  require_relative 'room'
+  require_relative 'block'
+  require_relative 'exceptions'
+
+  class Hotel
+    attr_reader :rooms, :reservations, :blocks
+    ROOM_COST = 200
+
+    def initialize(num_rooms)
+      @rooms = []
+
+      num_rooms.times do |i|
+        @rooms << Room.new(i + 1, ROOM_COST)
+      end
+      @reservations = []
+      @blocks = []
+    end
+
+    def make_reservation(checkin, checkout, block = false)
+      room_num = find_available_rooms(checkin, checkout, block).first
+      if room_num.nil?
+        raise(NoRoomError, "No available rooms for dates #{checkin} - #{checkout}")
+      end
+      reservation = Reservation.new(room_num, checkin, checkout, self, block)
+      @reservations << reservation
+      reservation
+    end
+
+    def make_block(start_date, end_date, num_rooms, discount = 0)
+      raise(ArgumentError,"Number of rooms must be Integer: is #{num_rooms.class}") unless num_rooms.class == Integer
+
+      rooms = find_available_rooms(start_date, end_date)[0...num_rooms]
+
+      raise(NoRoomError, "Not enough available rooms for amount #{num_rooms}") if rooms.length < num_rooms
+
+      block = Block.new(start_date, end_date, rooms, discount)
+      @blocks << block
+      block
+    end
+
+    def view_reservations(date)
+      date = Date.validate(date)
+      reservations = []
+      @reservations.each do |reservation|
+        reservations << reservation if reservation.dates.include?(date)
+      end
+      reservations
+    end
+
+    def find_available_rooms(checkin, checkout, block_id = false)
+      DateRange.validate_order(checkin, checkout)
+      if block_id
+        unless block_exists?(block_id)
+          raise(NoBlockError, "No such block: #{block_id}")
+        end
+        unless block(block_id).includes_dates?(checkin, checkout)
+          raise(DatesError, "Dates (#{checkin}, #{checkout}) do not fall within provided block #{block(block_id).id}")
+        end
+        rooms = block(block_id).rooms
+      else
+        rooms = find_rooms_not_in_blocks(checkin, checkout)
+      end
+
+      @reservations.each do |reservation|
+        rooms.delete(reservation.room) if (rooms.include? reservation.room) && reservation.includes_dates?(checkin, checkout)
+      end
+      rooms
+    end
+
+    def block_availability?(checkin, checkout, block_id)
+      find_available_rooms(checkin, checkout, block_id) != []
+    end
+
+    def room(num)
+      @rooms.each { |room| return room if room.number == num }
+      nil
+    end
+
+    def block(id)
+      @blocks.each { |block| return block if block.id == id }
+      nil
+    end
+
+    # private
+    def find_rooms_not_in_blocks(start_date, end_date)
+      rooms = @rooms.dup
+      @blocks.each do |block|
+        if block.includes_dates?(start_date, end_date)
+          rooms.delete_if { |room| block.rooms.include? room }
+        end
+      end
+      rooms
+    end
+
+    def block_exists?(block_id)
+      block(block_id) != nil
+    end
+  end
+end

lib/reservation.rb

@@ -0,0 +1,32 @@
+require 'pry'
+
+module Hotel
+  class Reservation
+    require_relative 'date_range'
+    attr_reader :total_cost, :dates, :checkin, :checkout, :id, :hotel, :room, :block
+
+    def initialize(room, checkin, checkout, hotel, block = false)
+      @room = room
+      @checkin = Date.validate(checkin)
+      @checkout = Date.validate(checkout)
+      @dates = DateRange.range_to(@checkin, @checkout)
+      if block
+        @block = hotel.block(block)
+        raise(DatesError) unless @block.includes_dates?(checkin, checkout)
+      else
+        @block = false
+      end
+      get_total
+    end
+
+    def get_total
+      num_nights = @dates.length
+      @total_cost = @room.rate * num_nights
+      @total_cost *= @block.discount_rate if @block
+    end
+
+    def includes_dates?(checkfirst, checklast)
+      DateRange.overlap?(checkfirst, checklast, @checkin, @checkout)
+    end
+  end
+end

lib/room.rb

@@ -0,0 +1,10 @@
+module Hotel
+  class Room
+    attr_reader :number, :rate
+
+    def initialize(number, rate)
+      @number = number
+      @rate = rate
+    end
+  end
+end