pcr-ruby 0.2.1 → 0.5

data/.gitignore

@@ -18,4 +18,5 @@ test/tmp
 test/version_tmp
 tmp
 instructors.txt
-examples.rb
+examples.rb
+json_responses.txt

data/README.md

@@ -15,76 +15,97 @@ gem install pcr-ruby
 
 pcr-ruby follows the structure of the PCR API, with a few name changes to make object identities and roles clearer in your code.  (Before using pcr-ruby, you should most definitely read the PCR API documentation, the link to which you should recieve upon being granted your API token.)
 
-The PCR API essentially consists of four types of objects: 'Courses', 'Sections', 'Instructors', and 'Course Histories'.  pcr-ruby aims to provide intuitive access to the data contained in these four object types while abstracting you and your user from background processing and unnecessary data.  To that end, pcr-ruby (thus far) consists of three types of objects: 'Courses', 'Sections', and 'Instructors'.
+The PCR API essentially consists of four types of objects: 'Courses', 'Sections', 'Instructors', and 'Course Histories'.  pcr-ruby aims to provide intuitive access to the data contained in these four object types while abstracting you and your user from background processing and unnecessary data.  To that end, pcr-ruby (thus far) consists of the same four types of objects: 'Course Histories', 'Courses', 'Sections', and 'Instructors' (coming soon).
 
-### 'Courses' in pcr-ruby ###
-
-Course objects in the PCR API are essentially a group of that Course's Sections which were offered in a certain semester.  Courses in pcr-ruby are different, and match up most directly with 'Course History' objects of the PCR API.  It is my belief that when students think of a "course," they think of the entire history of the course and *not* the course offering for a specific semester.  Therefore, pcr-ruby does not associate Courses with specific semesters -- rather, Courses exist across time and represent a single curriculum and course code.
+### CourseHistories in pcr-ruby ###
+Course Histories represent a course through time, and contain Course objects that represent the course offering in each semester.
 
-To create a Course:
+To create a Course History (the first step in getting PCR data):
 ```ruby
 require 'pcr-ruby'
-pcr = PCR.new(api_token)
-course = pcr.course(course_code)
+pcr = PCR.new(API_TOKEN)
+course_history = pcr.coursehistory(COURSE_CODE)
 ```
-All other instance variables will auto-populate based on data from the PCR API.
 
-pcr-ruby's Course objects have the following instance variables:
-*	**course_code** -- a string in the format "DEPT-###", where "DEPT" is the four-letter department code and "###" is the three-digit course code.
-*	**sections** -- an array of Section objects for the Course across all time.  Useful for calculating average ratings and other cumulative statistics.
-*	**id** -- the Course's PCR API id. (Integer)
-*	**name** -- the Course's plain-English name.  (String)
-*	**path** -- the PCR API sub-path leading to the Course (or, more accurately, the Course History).  For example, "/coursehistories/1794/".  Or, more generally: "/coursehistories/[id]/".  (String)
-*	**reviews** -- an array of Hashes that contain review data for each of the Course's sections.
+All other attributes will auto-populate based on data from the PCR API.
 
-Courses have the following instance methods:
-*	**average(metric)** -- returns the average value, across all Sections, of "metric" as a Float.  "Metric" must be a recognized rating in the PCR API.  (Currently the names of these ratings are not intuitive, so I may provide plain-English access to rating names in the future.)
-*	**recent(metric)** -- returns the most recent value of "metric" as a Float.  "Metric" must be a recognized rating in the PCR API.  (Currently the names of these ratings are not intuitive, so I may provide plain-English access to rating names in the future.)
+Course Histories have the following attributes:
+* **course_code** -- the course code entered by the user at initialization (String)
+* **courses** -- an array of Courses associated with the Course History (Array)
+* **id** -- the Course History's PCR API ID (String)
+* **path** -- the Course History's PCR API URL path (String)
+* **retrieved** -- the date the Course History was retreived (String)
+* **valid** -- true/false whether or not the query was valid (String)
+* **version** -- version of the PCR API hit (String)
 
-### 'Sections' in pcr-ruby ###
+The most useful way to think about a Course History is as a collection of Course objects.
 
-In pcr-ruby, Sections are single offerings of a Course.  Each Section is associated with a certain Instructor and semester -- think of a Section as the individual classes under the umbrella of the Course.  Sections in the PCR API are treated similarly.
+Course Histories have the following instance methods:
+*	**average(metric)** -- returns the average value, across all Courses, of "metric" as a Float.  "Metric" must be a recognized rating in the PCR API.  (Currently the names of these ratings are not intuitive, so I may provide plain-English access to rating names in the future.)
+*	**recent(metric)** -- returns the most recent value of "metric" as a Float. (If there are multiple Sections offered in the most recent semester, the average across those Sections is returned.)  "Metric" must be a recognized rating in the PCR API.  (Currently the names of these ratings are not intuitive, so I may provide plain-English access to rating names in the future.)
 
-To create a Section:
+### 'Courses' in pcr-ruby ###
+
+Courses in the PCR API represent a collection of Sections of a course code during a given semester, and are treated similarly in pcr-ruby.
+
+Courses are accessed from within their "parent" Course History:
 ```ruby
 require 'pcr-ruby'
-pcr = PCR.new(api_token)
-section = pcr.section(id)
+pcr = PCR.new(API_TOKEN)
+course_history = pcr.coursehistory(course_code)
+courses = course_history.courses
+earliest_course = courses.first
+most_recent_course = courses.last
 ```
 
-Sections have the following instance variables:
-*	**aliases** -- an array of the Section's course listings.  Most of the time, a Section will only have one listing (the course code followed by a section code, like "-001"), but Sections that are cross-listed between departments may have multiple listings.
-*	**id** -- the Section's PCR API id.  (Integer)
-*	**name** -- the plain-English name of the class.  (String)
-*	**path** -- the PCR API sub-path that leads to the Section.  Similar in format to Course.path.  (String)
-*	**semester** -- the semester code for the semester in which the Section was offered.  For example: "2011A".  Semester codes are in the format "####X", where "####" represents a year and "X" represents a semester (A for Spring, B for Summer, C for Fall).  (String)
-*	**description** -- a string containing the class description, which is written by the Section's Instructor and details the scope and characteristics of the class.
-*	**comments** -- a string containing PCR's comments about the Section.  The comments are the most major part of the written review, and are sourced from student exit surveys.
-*	**ratings** -- a Hash of metrics and the ratings of the Section for each metric.
-*	**instructors** an Array of the Section's instructors.
-*	**reviews** -- a Hash of the Section's review data, in the format {"comments" => @comments, "ratings" => @ratings}.
+pcr-ruby's Course objects have the following instance variables:
+* **aliases** -- an array of crosslistings (Array)
+* **credits** -- the number of credits awarded for the course (String)
+* **description** -- the PCR course description (String)
+* **history** -- the PCR API path to the course's history (String)
+* **id** -- the PCR API ID of the course (String)
+* **name** -- the plain-English name of the course, taken from the most recent Semester (String)
+* **path** -- the PCR API URL path of the course (String)
+* **reviews** -- a hash that usually contains one key, the path to the course's reviews (String) 
+* **sections** -- an array of Sections associated with the course (Array)
+* **semester** -- the semester in which the course was offered (String)
+* **retrieved** -- the date/time the course was retrieved (String)
+* **valid** -- true/false if valid/invalid request (String)
+* **version** -- PCR API version (String)
+
+The most useful way to think about Courses is as a collection of Section objects.
 
-### 'Instructors' in pcr-ruby ###
+### 'Sections' in pcr-ruby ###
 
-Instructors are arguably the most important part of PCR -- many students use PCR as a substitute for RateMyProfessor and base their course decisions on PCR professor ratings.  The Instructor object represents a single professor through time.  As of now, pcr-ruby allows you to retrieve both the average and most recent ratings of a professor; I may add the ability to look up ratings for specific courses/semesters taught in the future.
+In pcr-ruby, Sections are single offerings of a Course.  Each Section is associated with a certain Course -- think of a Section as the individual classes under the umbrella of the Course.  Sections in the PCR API are treated similarly.
 
-To create an Instructor:
+To retrieve a Section:
 ```ruby
 require 'pcr-ruby'
-pcr = PCR.new(api_token)
-instructor = pcr.instructor(id)
+pcr = PCR.new(API_TOKEN)
+course_history = pcr.coursehistory(course_code)
+recent_sections = course_history.courses.last.sections
+single_recent_section = recent_sections.first
 ```
 
-Insctructors have the following instance variables.  All variables other than **id**, which is user-specified, will be filled from the PCR API:
-*	**id** -- the Instructor's PCR id, a String in the form of "ID#-FIRST-M-LAST".  The PCR API also accepts a String in the form of "ID#".
-*	**name** -- the Instructor's name, a String in the form of "FIRST-M-LAST".
-*	**path** -- the PCR sub-path that leads to the Instructor, a String in the form of "/instructors/id".
-*	**sections** -- a Hash of sections taught by Instructor.
-*	**reviews** -- a Hash of reviews of Instructor in JSON.
+Sections have the following instance variables:
+* **aliases** -- crosslistings of the Section (Array)
+* **course** -- a hash containing info of the parent course (Hash)
+* **group** -- 
+* **id** -- the PCR API ID of the section (String)
+* **instructors** -- a hash of info on each of the section's instructors (Hash)
+* **meetingtimes** -- an array of hashes that contain info on each of the meeting times of the section (Array)
+* **name** -- the plain-English name of the section (String)
+* **path** -- the PCR API URL path of the section (String)
+* **reviews** -- an array of hashes which each contain the review data for the section (usually only one review hash) (Array)
+* **sectionnum** -- the number of the section (e.g. "001") (String)
+* **retrieved** -- date/time retrieved (String)
+* **valid** -- true/false if query valid/invalid (String)
+* **version** -- PCR API version (String)
+
+### 'Instructors' in pcr-ruby ###
 
-Instructors have the following instance methods:
-*	**average(metric)** -- returns the average value, across all Sections taught by Instructor, of "metric" as a Float.  "Metric" must be a recognized rating in the PCR API.  (Currently the names of these ratings are not intuitive, so I may provide plain-English access to rating names in the future.)
-*	**recent(metric)** -- returns the average value of "metric" for the most recent semester in which the Instructor taught as a float. (For example, if the professor taught 3 classes in the most recent semester, this would return the average of "metric" over the three classes.)  "Metric" must be a recognized rating in the PCR API.  (Currently the names of these ratings are not intuitive, so I may provide plain-English access to rating names in the future.)
+(New version of instructors coming soon)
 
 ## pcr-ruby Usage Examples ##
 
@@ -97,8 +118,8 @@ Let's say we want to find the average course quality rating for Introduction to
 require 'pcr-ruby'
 course_code = "PSCI-150"
 pcr = PCR.new(API_TOKEN)
-course = pcr.course(course_code)
-puts course.average("rCourseQuality") #=> 3.041
+psci150 = pcr.coursehistory(course_code)
+puts psci150.average("rCourseQuality") #=> 3.041
 ```
 
 Or, even more briefly:
@@ -106,7 +127,7 @@ Or, even more briefly:
 ```ruby
 require 'pcr-ruby'
 pcr = PCR.new(API_TOKEN)
-puts pcr.course("PSCI-150").average("rCourseQuality")
+puts pcr.coursehistory("PSCI-150").average("rCourseQuality")
 #=> 3.041
 ```
 
@@ -115,19 +136,26 @@ Finding the most recent section's course difficulty rating is just as easy:
 
 ```ruby
 require 'pcr-ruby'
+course_code = "PSCI-150"
 pcr = PCR.new(API_TOKEN)
-course = pcr.course("PSCI-150")
-puts course.recent("rDifficulty") #=> 2.5
+psci150 = pcr.coursehistory(course_code)
+puts psci150.recent("rDifficulty") #=> 2.59
 ```
 
-### Get professor's average "ability to stimulate student interest" rating ###
+### Get the course quality rating for a specific course/semester ###
 ```ruby
 require 'pcr-ruby'
+course_code = "PSCI-150"
 pcr = PCR.new(API_TOKEN)
-instructor = pcr.instructor("1090-LINDA-H-ZHAO")
-puts instructor.average("rStimulateInterest").round(2) #=> 1.7
+psci150 = pcr.coursehistory(course_code)
+psci150_course = psci150.courses[3]
+puts psci150_course.semester #=> "2003C"
+puts psci150_course.average("rDifficulty") #=> 2.98
 ```
 
+
 ## TODO ##
+* Make the coursehistory init quicker
+* Implement refactored Instructor object
 * Implement stricter checks on course code arguments
 *	Implement search by professor last/first name rather than by ID.  ID is unintuitive.  Will probably need to see if I can make a lookup method, or simply pull down a database of all instructors and do a search on that database.

data/lib/classes/course.rb

@@ -1,79 +1,68 @@
 class Course < PCR
-  attr_accessor :course_code, :sections, :id, :name, :path, :reviews
+  attr_accessor :aliases, :credits, :description, :history, :id, 
+                :name, :path, :reviews, :sections, :semester, 
+                :retrieved, :valid, :version
   
-  def initialize(course_code)
-    if course_code.is_a? String && course_code.isValidCourseCode?
-      @course_code = course_code
-      
-      #Read JSON from the PCR API
-      api_url = @@api_endpt + "coursehistories/" + self.course_code + "/?token=" + @@token
-      json = JSON.parse(open(api_url).read)
-      
-      #Create array of Section objects
-      @sections = []
-      json["result"]["courses"].each { |c| @sections << Section.new(c["id"]) }
-      
-      #Set variables according to Course JSON data
-      @id = json["result"]["id"]
-      @name = json["result"]["name"]
-      @path = json["result"]["path"]
-      
-      #Get reviews for the Course -- this has to be a separate query
-      api_url_reviews = @@api_endpt + "coursehistories/" + 
-                        self.id.to_s + "/reviews?token=" + @@token
-      json_reviews = JSON.parse(open(api_url_reviews).read)
-      @reviews = json_reviews["result"]["values"]
-    else
-      raise CourseError, "Invalid course code specified.  Use format [DEPT-###]."
+  def initialize(path, semester, api_endpt, token)
+    @path, @semester = path, semester
+    @api_endpt, @token = api_endpt, token
+    
+    # Hit api
+    api_url = makeURL(self.path)
+    json = JSON.parse(open(api_url).read)
+    
+    # List of sections
+    section_list = json['result']['sections']['values']
+    @sections = []
+    section_list.each do |section|
+      @sections << Section.new(section['path'], @api_endpt, @token)
+    end
+    
+    # Assign attrs
+    attrs = %w(aliases credits description history id name reviews 
+               retrieved valid version)
+    attrs.each do |attr|
+      if json['result'][attr]
+        self.instance_variable_set("@#{attr}", json['result'][attr])
+      else
+        self.instance_variable_set("@#{attr}", json[attr])
+      end
     end
   end
   
-  def average(metric)
-    #Ensure that we know argument type
-    metric = metric.to_s if metric.is_a? Symbol
-
-    if metric.is_a? String
-      #Loop vars
-      total, n = 0, 0
-      
-      #For each section, check if ratings include metric arg
-      #if so, add metric rating to total && increment counting variable
-      self.reviews.each do |review|
-        if review["ratings"].include? metric
-          total = total + review["ratings"][metric].to_f
-          n = n + 1
-        else
-          raise CourseError, "No ratings found for \"#{metric}\" in #{self.name}."
-        end
+  def compareSemester(other)
+    year = self.semester[0..3]
+    season = self.semester[4]
+    compYear = other.semester[0..3]
+    compSeason = other.semester[4]
+    
+    if year.to_i > compYear.to_i #Later year
+      return 1
+    elsif year.to_i < compYear.to_i #Earlier year
+      return -1
+    elsif year.to_i == compYear.to_i #Same year, so test season
+      if season > compSeason #Season is later
+        return 1
+      elsif season = compSeason #Exact same time
+        return 0
+      elsif season < compSeason #compSeason is later
+        return -1
       end
-      
-      #Return average score as a float
-      (total / n)
-    else
-      raise CourseError, "Invalid metric format. Metric must be a string or symbol."
     end
   end
   
-  def recent(metric)
-    #Ensure that we know argument type
-    metric = metric.to_s if metric.is_a? Symbol
-    
-    if metric.is_a? String
-      #Get the most recent section
-      section = self.sections[-1]
-      
-      #Iterate through all the section reviews, and if the section review id matches
-      #the id of the most recent section, return that rating
-      self.reviews.each do |review|
-        if review["section"]["id"].to_s[0..4].to_i == section.id
-          return review["ratings"][metric]
-        end
+  def average(metric)
+    # Aggregate ratings across all sections
+    total, num = 0, 0
+    self.sections.each do |section|
+      section.reviews.each do |review|
+        total += review.send(metric).to_f
+        num += 1
       end
-      
-      #Else, metric hasn't been found
-      raise CourseError, "No ratings found for #{metric} in #{section.semester}."
-    else
-      raise CourseError, "Invalid metric format. Metric must be a string or symbol."
     end
+    
+    # Return average value across all sections
+    (total / num)
   end
+
 end

data/lib/classes/coursehistory.rb

@@ -0,0 +1,70 @@
+class CourseHistory < PCR
+  attr_accessor :course_code, :courses, :id, :path, :retrieved, :valid, :version
+  
+  def initialize(course_code, api_endpt, token)
+    @course_code = course_code
+    @api_endpt = api_endpt
+    @token = token
+    
+    # Read JSON from PCR API
+    api_url = makeURL("coursehistories/#{self.course_code}")
+    json = JSON.parse(open(api_url).read)
+    
+    # List of courses in coursehistory
+    course_list = json['result']['courses']
+    @courses = []
+    course_list.each do |course|
+      @courses << Course.new(course['path'], course['semester'], @api_endpt, @token)
+    end
+    # Sort course list by semester
+    @courses.sort! { |a,b| a.compareSemester(b) }
+    
+    # Assign rest of attrs
+    attrs = %w(id path reviews retrieved valid version)
+    attrs.each do |attr|
+      if json['result'][attr]
+        self.instance_variable_set("@#{attr}", json['result'][attr])
+      else
+        self.instance_variable_set("@#{attr}", json[attr])
+      end
+    end
+  end
+  
+  def recent(metric)
+    # Select most recent course
+    course = @courses[-1]
+    
+    # Aggregate ratings for metric
+    total, num = 0, 0
+    course.sections.each do |section|
+      section.reviews.each do |review|
+        total += review.send(metric).to_f
+        num += 1
+      end
+    end
+    
+    # Return average value across most recent sections
+    (total / num)
+  end
+  
+  def average(metric)
+    # Aggregate ratings across all sections
+    total, num = 0, 0
+    courses.each do |course|
+      course.sections.each do |section|
+        section.reviews.each do |review|
+          total += review.send(metric).to_f
+          num += 1
+        end
+      end
+    end
+    
+    # Return average value across all sections
+    (total / num)
+  end
+  
+  def name
+    self.courses.last.name
+  end
+
+end

data/lib/classes/review.rb

@@ -0,0 +1,16 @@
+#review_new.rb
+
+class Review
+  #attr_accessor
+  
+  def initialize(review_hash)
+    # Assign ratings
+    ratings = review_hash['ratings']
+    ratings.each do |name, val|
+      self.instance_variable_set("@#{name}", val)
+      self.class.send(:attr_accessor, name)
+      #self.class_eval("def #{name};@#{name};end")
+    end
+  end
+
+end

data/lib/classes/section.rb

@@ -1,50 +1,36 @@
-#Section is an individual class under the umbrella of a general Course
 class Section < PCR
-  attr_accessor :aliases, :id, :name, :path, :semester, :description, :comments, :ratings, :instructors, :reviews
+  attr_accessor :aliases, :course, :group, :id, :instructors, 
+                :meetingtimes, :name, :path, :reviews, 
+                :sectionnum, :retrieved, :valid, :version
   
-  def initialize(id, hit_api = true)
-    # Set instance vars
-    @id = id
-    
-    # Hit api to fill additional info
-    self.hit_api unless hit_api == false
-  end
-  
-  def hit_api
-    data = ["aliases", "name", "path", "semester", "description"]
-    api_url = @@api_endpt + "courses/" + self.id.to_s + "?token=" + @@token
+  def initialize(path, api_endpt, token)
+    @path = path
+    @api_endpt = api_endpt
+    @token = token
+        
+    # Hit api
+    api_url = makeURL(self.path)
     json = JSON.parse(open(api_url).read)
-    data.each do |d|
-      case d
-      when "aliases"
-        self.instance_variable_set("@#{d}", json["result"]["aliases"])
-      when "name"
-        self.instance_variable_set("@#{d}", json["result"]["name"])
-      when "path"
-        self.instance_variable_set("@#{d}", json["result"]["path"])
-      when "semester"
-        self.instance_variable_set("@#{d}", json["result"]["semester"])
-      when "description"
-        self.instance_variable_set("@#{d}", json["result"]["description"])
-      end
+    
+    # Get reviews
+    # Usually one, but may be > 1
+    @reviews = []
+    reviews_url = makeURL(json['result']['reviews']['path'])
+    reviews_json = JSON.parse(open(reviews_url).read)
+    reviews_json['result']['values'].each do |review|
+      @reviews << Review.new(review)
     end
     
-    # Get review data
-    self.get_reviews
-  end
-  
-  def get_reviews
-    api_url = @@api_endpt + "courses/" + self.id.to_s + "/reviews?token=" + @@token
-    json = JSON.parse(open(api_url).read)
-    @comments = []
-    @ratings = []
-    @instructors = []
-    json["result"]["values"].each do |a|
-      @comments << {a["instructor"]["id"] => a["comments"]}
-      @ratings << {a["instructor"]["id"] => a["ratings"]}
-      @instructors << a["instructor"]
+    # Assign attrs
+    attrs = %w(aliases course group id instructors meetingtimes name 
+               sectionnum retrieved valid version)
+    attrs.each do |attr|
+      if json['result'][attr]
+        self.instance_variable_set("@#{attr}", json['result'][attr])
+      else
+        self.instance_variable_set("@#{attr}", json[attr])
+      end
     end
-    @reviews = {"comments" => @comments, "ratings" => @ratings}
   end
-  
+
 end

data/lib/classes/string.rb

@@ -52,16 +52,16 @@ class ::String
     compSeason = s[4]
     
     if year.to_i > compYear.to_i #Later year
-      return true
+      return 1
     elsif year.to_i < compYear.to_i #Earlier year
-      return false
+      return -1
     elsif year.to_i == compYear.to_i #Same year, so test season
       if season > compSeason #Season is later
-        return true
+        return 1
       elsif season = compSeason #Exact same time
         return 0
       elsif season < compSeason #compSeason is later
-        return false
+        return -1
       end
     end
   end

data/lib/pcr-ruby.rb

@@ -1,27 +1,27 @@
 require 'json'
 require 'open-uri'
-require 'time'
-require 'csv'
-
 
 #PCR class handles token and api url, so both are easily changed
 class PCR
+  attr_accessor :token, :api_endpt
+  
   def initialize(token, api_endpt = "http://api.penncoursereview.com/v1/")
-    @@token = token
-    @@api_endpt = api_endpt
+    @token = token
+    @api_endpt = api_endpt
   end
   
-  def course(course_code)
-    Course.new(course_code)
+  def coursehistory(course_code)
+    CourseHistory.new(course_code, self.api_endpt, self.token)
   end
   
-  def section(id, hit_api = true)
-    Section.new(id, hit_api)
-  end
+  # def instructor(id)
+    # Instructor.new(id)
+  # end
   
-  def instructor(id)
-    Instructor.new(id)
+  def makeURL(path)
+    "#{self.api_endpt + path}?token=#{self.token}"
   end
+  
 end
 
 # Load classes

data/lib/pcr-ruby/version.rb

@@ -1,5 +1,5 @@
 module Pcr
   module Ruby
-    VERSION = "0.2.1"
+    VERSION = "0.5"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pcr-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: '0.5'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-07 00:00:00.000000000 Z
+date: 2012-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -38,10 +38,10 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/classes/array.rb
 - lib/classes/course.rb
+- lib/classes/coursehistory.rb
 - lib/classes/errors.rb
-- lib/classes/instructor.rb
+- lib/classes/review.rb
 - lib/classes/section.rb
 - lib/classes/string.rb
 - lib/pcr-ruby.rb

data/lib/classes/array.rb

@@ -1,18 +0,0 @@
-#Add useful array methods
-class Array
-  def binary_search(target)
-    self.search_iter(0, self.length-1, target)
-  end
-
-  def search_iter(lower, upper, target)
-    return -1 if lower > upper
-    mid = (lower+upper)/2
-    if (self[mid] == target)
-      mid
-    elsif (target < self[mid])
-      self.search_iter(lower, mid-1, target)
-    else
-      self.search_iter(mid+1, upper, target)
-    end
-  end
-end

data/lib/classes/instructor.rb

@@ -1,116 +0,0 @@
-#Instructor is a professor.  Instructors are not tied to a course or section, but will have to be referenced from Sections.
-class Instructor < PCR
-  attr_accessor :id, :name, :path, :sections, :reviews
-  
-  def initialize(id)    
-    #Assign args
-    if id.is_a? String
-      @id = id
-    else
-      raise InstructorError("Invalid Instructor ID specified.")
-    end
-    
-    #Hit PCR API to get missing info based on id
-    self.getInfo
-    self.getReviews
-  end
-  
-  #Hit the PCR API to get all missing info
-  def getInfo
-    api_url = @@api_endpt + "instructors/" + self.id + "?token=" + @@token
-    json = JSON.parse(open(api_url).read)
-    @name = json["result"]["name"].downcase.titlecase unless @name
-    @path = json["result"]["path"] unless @path
-    @sections = json["result"]["reviews"]["values"] unless @sections #Mislabeled reviews in PCR API
-  end
-  
-  #Separate method for getting review data
-  def getReviews
-    api_url = @@api_endpt + "instructors/" + self.id + "/reviews?token=" + @@token
-    json = JSON.parse(open(api_url).read)
-    @reviews = json["result"]["values"] #array
-  end
-  
-  #Get average value of a certain rating for Instructor
-  def average(metric)
-    #Ensure that we know argument type
-    metric = metric.to_s if metric.is_a? Symbol
-    
-    if metric.is_a? String
-      #Loop vars
-      total, n = 0, 0
-      
-      #For each section, check if ratings include metric arg
-      #if so, add metric rating to total and increment counting variable
-      self.getReviews
-      self.reviews.each do |review|
-        if review["ratings"].include? metric
-          total = total + review["ratings"][metric].to_f
-          n = n + 1
-        else
-          raise CourseError, "No ratings found for \"#{metric}\" for #{self.name}."
-        end
-      end
-      
-      #Return average score as a float
-      (total / n)
-    else
-      raise CourseError, "Invalid metric format. Metric must be a string or symbol."
-    end
-  end
-
-  #Get most recent value of a certain rating for Instructor
-  def recent(metric)
-    #Ensure that we know argument type
-    metric = metric.to_s if metric.is_a? Symbol
-    
-    if metric.is_a? String
-      #Iterate through reviews and create Section for each section reviewed, presented in an array
-      sections = []
-      section_ids = []
-      self.getReviews
-      self.reviews.each do |review|
-        if section_ids.index(review["section"]["id"].to_i).nil?
-          s = PCR::Section.new(review["section"]["id"].to_i, false)
-          sections << s
-          section_ids << s.id
-        end
-      end
-      
-      #Get only most recent Section(s) in the array
-      sections.reverse! #Newest first
-      targets = []
-      sections.each do |s|
-        s.hit_api
-        if sections.index(s) == 0
-          targets << s
-        elsif s.semester == sections[0].semester && s.id != sections[0].id
-          targets << s
-        else
-          break
-        end
-      end
-      
-      #Calculate recent rating
-      total, num = 0, 0
-      targets.each do |section|
-        #Make sure we get the rating for the right Instructor
-        section.ratings.each do |rating|
-          if rating.key?(self.id)
-            if rating[self.id][metric].nil?
-              raise InstructorError, "No ratings found for #{metric} for #{self.name}."
-            else
-              total = total + rating[self.id][metric].to_f
-              num += 1
-            end
-          end
-        end
-      end
-
-      # Return recent rating
-      (total / num)
-    else
-      raise CourseError, "Invalid metric format. Metric must be a string or symbol."
-    end
-  end
-end