ruby-scheduler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c8ea947aa1ab9a3cc95c7ff37f7c88cf6a3648503359b8d24360a972d145f61b
+  data.tar.gz: 292a91c4d24504f8721885735be772590599c9d4a28c69a9dc7ce3ac4b76d1e8
+SHA512:
+  metadata.gz: 3b3a0364d8c20262ad30c6049c2f1440efaae5ede5563e365a6914ff1d89fb76a9c5a546c90d779175bdd004a2ab8b6f353add4723a27bf7e3da371613614869
+  data.tar.gz: ff2151a3d00007b92297aef51d8482d31aeb1c2594cda21c67e4038dadab3bd463ea68f842369d554cda59400a05cc671eec21dccc6b3505ca0a3d6e166b7f75

data/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_PATH: "vendor"

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1 @@
+--format documentation

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby-scheduler.gemspec
+gemspec
+
+# TODO: remove rspec and add as development dependency
+gem 'rspec'
+gem "rake", "~> 12.0"

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    ruby-scheduler (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (12.3.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.1)
+      rspec-support (~> 3.9.1)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 12.0)
+  rspec
+  ruby-scheduler!
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -0,0 +1,118 @@
+# Ruby Scheduler
+
+Your product owner is asking you to implement a new feature in the calendar system
+that is in your scheduling tool. The feature needs to support arranging a set of
+meetings within an 8 hour day in a way that makes them work, and let the user know
+if the meetings cannot fit into the day.
+
+For this feature there will be two kinds of meetings, on-site meetings and off-site
+meetings. On-site meetings can be scheduled back to back with no gaps in between
+them, but off-site meetings must have 30 minutes of travel time padded to either
+end. This travel time however can overlap for back to back off-site meetings, and can
+extend past the start and end of the day.
+
+# Run Scheduler
+To run the scheduler
+```
+exec-scheduler
+```
+
+or 
+```
+ruby lib/ruby/scheduler.rb
+```
+
+# Tests
+To run the tests suite
+```
+test-scheduler
+```
+
+or to run a specific test file
+```
+bundle exec rspec spec/lib/scheduler_spec.rb
+bundle exec rspec spec/lib/scheduler/meeting_spec.rb
+bundle exec rspec spec/lib/schedulder/schedule_spec.rb
+bundle exec rspec spec/helpers/scheduler_helper_spec.rb
+```
+
+# Examples
+
+```
+Given a set of meetings (below is an example of a set of meetings):
+{
+{ name: “Meeting 1”, duration: 3, type: :onsite },
+{ name: “Meeting 2”, duration: 2, type: :offsite },
+{ name: “Meeting 3”, duration: 1, type: :offsite },
+{ name: “Meeting 4”, duration: 0.5, type: :onsite }
+}
+```
+
+You must write code to determine if these meetings can fit into a 9 to 5 schedule,
+and propose a layout for those meetings in a format like this:
+```
+9:00 - 12:00 - Meeting 1
+12:00 - 12:30 - Meeting 4
+1:00 - 3:00 - Meeting 2
+3:30 - 4:30 - Meeting 3
+```
+
+## Here are a few example sets for you to test against:
+
+Example 1:
+```
+{
+{ name: “Meeting 1”, duration: 1.5, type: :onsite },
+{ name: “Meeting 2”, duration: 2, type: :offsite },
+{ name: “Meeting 3”, duration: 1, type: :onsite },
+{ name: “Meeting 4”, duration: 1, type: :offsite },
+{ name: “Meeting 5”, duration: 1, type: :offsite },
+}
+```
+Yes, can fit. One possible solution would be:
+```
+9:00 - 10:30 - Meeting 1
+10:30 - 11:30 - Meeting 3
+12:00 - 1:00 - Meeting 5
+1:30 - 2:30 - Meeting 4
+3:00 - 5:00 - Meeting 2
+```
+
+Example 2:
+```
+{
+{ name: “Meeting 1”, duration: 4, type: :offsite },
+{ name: “Meeting 2”, duration: 4, type: :offsite }
+}
+```
+No, can’t fit.
+
+Example 3:
+```
+{
+{ name: “Meeting 1”, duration: 0.5, type: :offsite },
+{ name: “Meeting 2”, duration: 0.5, type: :onsite },
+{ name: “Meeting 3”, duration: 2.5, type: :offsite },
+{ name: “Meeting 4”, duration: 3, type: :onsite }
+}
+```
+Yes, can fit. One possible solution would be:
+```
+9:00 - 9:30 - Meeting 2
+10:00 - 10:30 - Meeting 1
+11:00 - 2:00 - Meeting 4
+2:30 - 5:00 - Meeting 3
+```
+
+## Instructions
+
+. Write the solution in Ruby.
+
+. Put the code up on Github, Bitbucket, etc…
+
+. Commit early and often so we can see progress as you work through the solution.
+
+. No need to create a complex UI, just a command line application is enough.
+
+. The data samples can be hardcoded into the solution, no need to read in external
+data.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ruby/scheduler"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exec-scheduler.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+ruby lib/ruby/scheduler.rb

data/helpers/schedule_helper.rb

@@ -0,0 +1,13 @@
+module ScheduleHelper
+
+    # Change hours to seconds for Time operations.
+    # Input:
+    # - Float
+    # * This value represents a duration of time in hours
+    # Output:
+    # - float
+    def to_seconds(time)
+        time * 3600.0
+    end
+
+end

data/lib/ruby/scheduler.rb

@@ -0,0 +1,79 @@
+require_relative './scheduler/schedule.rb'
+require_relative './scheduler/meeting.rb'
+
+module Scheduler
+
+    # This module should execute the project task.
+    # Given a schedule, ptimize the meetings, to 
+    # fit them within a business day.
+    # Input:
+    # - Schedule object
+    # Output:
+    # - String
+    MEETINGS = {
+        example_1: [{
+            name: 'Meeting 1',
+            duration: 1.5,
+            type: :onsite,
+        }, {
+            name: 'Meeting 2',
+            duration: 2,
+            type: :offsite
+        }, {
+            name: 'Meeting 3',
+            duration: 1,
+            type: :onsite
+        }, {
+            name: 'Meeting 4',
+            duration: 1,
+            type: :offsite
+        }, {
+            name: 'Meeting 5',
+            duration: 1,
+            type: :offsite
+        }],
+        example_2: [{
+            name: 'Meeting 1',
+            duration: 4,
+            type: :offsite
+        }, {
+            name: 'Meeting 2',
+            duration: 4,
+            type: :offsite
+        }],
+        example_3: [{
+            name: 'Meeting 1',
+            duration: 0.5,
+            type: :offsite
+        }, {
+            name: 'Meeting 2',
+            duration: 0.5,
+            type: :onsite
+        }, {
+            name: 'Meeting 3',
+            duration: 2.5,
+            type: :offsite
+        }, {
+            name: 'Meeting 4',
+            duration: 3,
+            type: :onsite
+        }]
+    }
+
+    def self.run(meetings = nil)
+        puts "Execute file"
+        if meetings.nil?
+            meetings = MEETINGS[:example_1]
+        end
+        schedule = Scheduler::Schedule.new({
+            meetings: meetings
+        })
+
+        schedule.reschedule
+        return schedule
+    end
+
+end
+
+schedule = Scheduler.run()
+puts schedule

data/lib/ruby/scheduler/meeting.rb

@@ -0,0 +1,85 @@
+# RoR configuration would autoload the lib and helpers directories
+require_relative '../../../helpers/schedule_helper'
+
+module Scheduler
+    
+    class Meeting
+        # name, duration, type, start_time, end_time
+        include ScheduleHelper
+
+        attr_reader   :name, :duration, :type
+        attr_accessor :start_time, :end_time
+
+        VALID_TYPES = [:offsite, :onsite]
+
+        # Initialize Meeting object
+        def initialize(params = {})
+            @name = params.fetch(:name, nil)
+            @duration = params.fetch(:duration, 0)
+            @type = params.fetch(:type, nil)
+            @start_time = params.fetch(:start_time, nil)
+            @end_time = params.fetch(:end_time, nil)
+
+            validate!
+        end
+
+        ## Setter methods
+        # Setter method for start_time attribute
+        # Input:
+        # - Time
+        def set_start_time(start_time)
+            @start_time = start_time
+        end
+
+        # Setter method for end_time attribute
+        # Input:
+        # - NONE
+        def set_end_time
+            return unless start_time
+            @end_time = start_time + to_seconds(duration)
+        end
+
+        ## Conditional methods
+        # Conditional method to check if type is offsite
+        # Output:
+        # - boolean
+        def offsite?
+            type == :offsite
+        end
+
+        ## Additonal class methods
+        # Calculate next meeting start_time
+        # Output:
+        # - Time
+        def next_start_time
+            end_time + to_seconds(offsite_buffer)
+        end
+
+        # Calcuate offsite buffer for travel (30 minutes)
+        # Output:
+        # - Integer
+        def offsite_buffer
+            offsite? ? 0.5 : 0.0
+        end
+
+        private
+
+        # Method to check valid parameters
+        # Output:
+        # - boolean
+        def valid?
+            @name.is_a? String
+            @duration.is_a? (Integer || Float)
+            @type.is_a? Symbol
+            VALID_TYPES.include? @type
+        end
+
+        # Method to raise error if invalid parameters
+        # Note: Would use RoR ActiveRecord validations if this were
+        # a rails application. Could also use dry-rb gem validations.
+        def validate!
+            raise ArgumentError.new("Invalid Params") unless valid?
+        end
+    end
+
+end

data/lib/ruby/scheduler/schedule.rb

@@ -0,0 +1,173 @@
+# RoR configuration would autoload the lib and helpers directories
+require_relative './meeting'
+
+module Scheduler
+
+    class Schedule
+        # meetings
+        # Offsite meeting buffer can extend past the end of the day
+        DAY_LENGTH = {
+            all_offsite: 9,
+            any_offsite: 8.5,
+            no_offsite: 8
+        }
+
+        attr_accessor :meetings
+
+        # Initialize a Schedule of Meeting objects.
+        def initialize(params = {})
+            @meetings = []
+            meetings_arr = params.fetch(:meetings, nil)
+            meetings_arr.each do |meeting|
+                meeting_object = Meeting.new(meeting)
+                @meetings << meeting_object
+            end
+
+            validate!
+        end
+
+        ## Overriden methods
+        # Override `to_s` method to print expected message provided in README.
+        # Output:
+        # - String
+        def to_s
+            valid = valid_meeting_schedule? ? "Valid Schedule\n" : "Invalid Schedule\n"
+            meeting_str = meetings.reduce(valid) do |str, meeting| 
+                str += meeting.start_time&.strftime("%I:%M %p") || 'none'
+                str += ' - '
+                str += meeting.end_time&.strftime("%I:%M %p") || 'none'
+                str += ' - '
+                str += meeting.name
+                str += "\n"
+            end
+            meeting_str
+        end
+
+        ## Setter methods
+        # Set a meeting schedule using an optimal meeting order
+        # Note: Would consider using Trailblazer to construct
+        # a contract and operation.
+        def reschedule
+            set_meeting_order
+
+            meetings.first.set_start_time(first_start_time)
+
+            meetings.each_with_index do |meeting, index|
+                if meeting.start_time.nil?
+                    previous_meeting = meetings[index - 1]
+                    next_start_time = previous_meeting.next_start_time
+                    meeting.set_start_time(next_start_time)
+                end
+                meeting.set_end_time
+            end
+            @meetings = meetings
+            self
+        end
+        
+        ## Conditional methods
+        # Check if any time left after meetings
+        # Output:
+        # - boolean
+        def valid_meeting_schedule?
+            time_left_in_day >= 0
+        end
+
+        # Check if all meetings are offsite
+        # Note: If RoR application, I would use the ActiveRecord scope method
+        # Output:
+        # - boolean
+        def all_offsite_meetings?
+            meetings.all? { |meeting| meeting.offsite? }
+        end
+
+        # Check if any meetings are offsite
+        # Note: If RoR application, I would use the ActiveRecord scope method
+        # Output:
+        # - boolean
+        def any_offsite_meetings?
+            meetings.any? { |meeting| meeting.offsite? }
+        end
+
+        # Additional class methods
+        # Calculate total meeting time for both onsite and offsite meetings
+        def total_meeting_time
+            calculate_total_duration(offsite_meetings, offsite: true) + calculate_total_duration(onsite_meetings, offsite: false)
+        end
+
+        private
+
+        # Get start time for first meeting
+        def first_start_time
+            time = Time.now
+            Time.new(time.year, time.month, time.day, 9, 0, 0,  "-05:00")
+        end
+
+        # Determine total time in day given whether or not
+        # there consist any offsite meetings. 
+        def time_left_in_day
+            if all_offsite_meetings?
+                day_length = DAY_LENGTH[:all_offsite]
+            elsif any_offsite_meetings?
+                day_length = DAY_LENGTH[:any_offsite]
+            else
+                day_length = DAY_LENGTH[:no_offsite]
+            end
+            day_length - total_meeting_time
+        end
+
+        # Place offsite before onsite meetings for an
+        # optimal meeting order
+        # Output:
+        # - Array
+        def optimal_meeting_order
+            offsite_meetings + onsite_meetings
+        end
+
+        # Select offsite meetings from all meetings
+        # Output:
+        # - Array
+        def offsite_meetings
+            meetings.select { |meeting| meeting.offsite? }
+        end
+
+        # Select onsite meetings from all meetings
+        # Output:
+        # - Array
+        def onsite_meetings
+            meetings.select{ |meeting| !meeting.offsite? }
+        end
+
+        # Set an optimal meeting order
+        def set_meeting_order
+            @meetings = optimal_meeting_order
+        end
+
+        # Calculate total meeting time and buffer for selected meetings
+        # Note: This does not use the same methods as reschedule - refactor
+        # to reuse those methods for consistency
+        # Input:
+        # - Array of Meetings
+        # - boolean
+        # Output:
+        # - Float
+        def calculate_total_duration(selected_meetings, offsite:)
+            start_buffer = offsite ? 0.5 : 0
+            selected_meetings.reduce(start_buffer) { |sum, meeting| offsite ? sum + (meeting.duration + 0.5) : sum + meeting.duration }
+        end
+
+        # Method to check valid parameters
+        # Output:
+        # - boolean
+        def valid?
+            meetings.is_a? Array
+        end
+
+        # Method to raise error if invalid parameters
+        # Note: Would use RoR ActiveRecord validations if this were
+        # a rails application. Could also use dry-rb gem validations 
+        def validate!
+            raise ArgumentError.new("Invalid Params") unless valid?
+        end
+
+    end
+end