rubyuw 0.99.2 → 0.99.3

data/README.md

@@ -52,9 +52,9 @@ The following is a quick and simple example:
 
 ## Documentation
 
-You may view all documentation [at the following URL](http://mitchellh.github.com/RubyUW/):
+You may view all documentation [at the following URL](http://mitchellh.github.com/rubyuw/):
 
-http://mitchellh.github.com/RubyUW/
+[http://mitchellh.github.com/rubyuw/](http://mitchellh.github.com/rubyuw/)
 
 ## Testing
 

data/VERSION

@@ -1 +1 @@
-0.99.2
+0.99.3

data/lib/rubyuw/curriculum.rb

@@ -0,0 +1,192 @@
+module RubyUW
+  # RubyUW::Curriculum is used to gather a list of courses offered by
+  # a specific curriculum within the University of Washington. This
+  # is opposite of {RubyUW::SLN} which pulls data for a single SLN.
+  # With RubyUW::Curriculum, you can answer the following sorts of
+  # questions:
+  #
+  # * What courses are offered within the "Chemistry" curriculum?
+  # * What courses are offered within the "BIO A" curriculum?
+  # * What courses are offered for "CHEM 142?" This would return
+  #   all the lectures, labs, and quiz sections associated with a
+  #   specific course.
+  #
+  # <b>Does _not_ require authentication with {RubyUW::Base} for use!</b>
+  class Curriculum
+    class <<self
+      # Find all courses within a specific curriculum or course.
+      # The class itself determines, based on the format of the
+      # curriculum parameter, whether the user intends to search
+      # for an entire curriculum or specific course. This search
+      # can be verified in the resulting hash's <pre>:type</pre>
+      # value.
+      #
+      # = Examples:
+      #
+      #   RubyUW::Curriculum.find("Chemistry", "WIN2010")
+      #
+      #   RubyUW::Curriculum.find("BIO A", "WIN2010")
+      #
+      #   RubyUW::Curriculum.find("CHEM 142", "WIN2010")
+      #
+      # = Return Format
+      #
+      # The method returns a hash which depending on your search is
+      # returned in one of two formats. Specific documentation for this
+      # will come soon. For now I recommend simply inspecting the hash
+      # for yourself, as it is fairly simple.
+      #
+      # @param [String] curriculum The curriculum or course to search
+      # @param [String] term The term (quarter) to search in.
+      # @return [Hash]
+      def find(curriculum, term)
+        curriculum = curriculum.strip # So we don't modify the original variable
+        type = !!(curriculum =~ /^(.+?)(\d+)$/) ? :course : :curriculum
+        send("find_#{type}", curriculum, term)
+      end
+      
+      protected
+      
+      def find_curriculum(curriculum, term)
+        page = Base.connection.get("http://www.washington.edu/students/timeschd/#{term}/")
+        raise Errors::QuarterDoesNotExistError.new if !quarter_exists?(page)
+        
+        curriculum_page = extract_curriculum_url(curriculum, page)
+        raise Errors::CurriculumDoesNotExistError.new if curriculum_page.nil?
+
+        curriculum_page = Base.connection.get("http://www.washington.edu/students/timeschd/#{term}/#{curriculum_page}")
+        raise Errors::CurriculumDoesNotExistError.new if !curriculum_exists?(page)
+        
+        return {
+          :type => :curriculum,
+          :courses => extract_courses(curriculum_page)
+        }
+      end
+      
+      def find_course(raw_curriculum, term)
+        curriculum, course = parse_curriculum(raw_curriculum)
+        curriculum_data = find_curriculum(curriculum, term)
+        courses = find_course_in_data(course, curriculum_data)
+        raise Errors::CourseDoesNotExistError.new(curriculum, course, raw_curriculum) if courses.nil?
+
+        return {
+          :type => :course,
+          :courses => courses
+        }
+      end
+      
+      def find_course_in_data(course, data)
+        data[:courses].each do |course_data, listing|
+          next unless course_data[:name] =~ /#{course}$/
+          
+          return listing
+        end
+        
+        return nil
+      end
+      
+      def extract_courses(page)
+        nodes = page.search("//table[@bgcolor=\"#d3d3d3\"][1]//following-sibling::table")
+        
+        courses = {}
+        current_course = []
+        
+        nodes.each do |node|
+          if node[:bgcolor] == "#99ccff"
+            # If its a course header, start putting course listings under that
+            # course header
+            current_course = []
+            courses[extract_course_header(node)] = current_course
+          else
+            # Otherwise we just extract the course listing and stuff it under
+            # the the current course
+            current_course.push(extract_course_listing(node))
+          end
+        end
+        
+        courses
+      end
+      
+      def extract_course_header(node)
+        Base.extract(node, ".//td[@width=\"50%\"]//a", [:name, :title])
+      end
+      
+      def extract_course_listing(node)
+        pre_node = node.search(".//pre")
+        pre_text = pre_node.inner_text.gsub("\302\240", "").gsub("\n", "").strip.chomp
+        
+        # Ugly regex to match the <pre> text to extract the proper information for the
+        # course.
+        raise Errors::CourseListingMatchError.new(pre_text) unless pre_text =~ /^((IS\s+)|(Restr\s+))?>?([0-9]+)\s([A-Z]{1,2})\s(.+?)\s(.+)/i #\s(([A-Z]+)\s(.+?))\s(([A-Z]+)\s([0-9]+))/i
+
+        {
+          :sln => $4.to_s,
+          :section => $5.to_s,
+          :type => ($6.to_i > 0) ? "LC" : $3.to_s
+        }
+      end
+      
+      def quarter_exists?(page)
+        # Time Schedule - No Courses Offered
+        return !(page.body.to_s =~ /Time Schedule - No Courses Offered/i)
+      end
+      
+      # For now, unless MyUW changes, these are equivalent
+      alias :curriculum_exists? :quarter_exists?
+      
+      def extract_curriculum_url(curriculum, page)
+        links = page.search("a")
+        
+        links.each do |link|
+          text = link.inner_text.gsub("\302\240", " ").to_s
+          
+          return link[:href].to_s if text =~ /^#{curriculum} \((.+?)\)$/i ||
+                                     text =~ /^(.+?) \(#{curriculum}\)$/i
+        end
+        
+        return nil
+      end
+      
+      def parse_curriculum(curriculum)
+        return nil unless curriculum =~ /^(.+?)\s+(\d+)$/
+        return $1, $2
+      end
+    end
+  end
+  
+  module Errors
+    # An error indicating that a quarter does not exist in the time schedule
+    class QuarterDoesNotExistError < Exception; end
+    
+    # An error indicating that the curriculum requested does not exist
+    class CurriculumDoesNotExistError < Exception; end
+    
+    # An error indicating that the course listing didn't match the format
+    class CourseListingMatchError < Exception
+      attr_reader :listing_text
+      
+      def initialize(listing_text, message = nil)
+        @listing_text = listing_text
+        
+        message = "Failed to match: #{@listing_text}" if message.nil?
+        super(message)
+      end
+    end
+    
+    # An error indicating that a course does not exist
+    class CourseDoesNotExistError < Exception
+      attr_reader :curriculum
+      attr_reader :course
+      attr_reader :original
+      
+      def initialize(curriculum, course, original, message = nil)
+        @curriculum = curriculum
+        @course = course
+        @original = original
+        
+        message = "Course does not exist: (#{curriculum}, #{course}) from \"#{original}\""
+        super(message)
+      end
+    end
+  end
+end

data/lib/rubyuw.rb

@@ -4,6 +4,7 @@ require 'nokogiri'
 require 'rubyuw/errors'
 require 'rubyuw/base'
 require 'rubyuw/connection'
+require 'rubyuw/curriculum'
 require 'rubyuw/sln'
 require 'rubyuw/curriculum_enrollment'
 require 'rubyuw/schedule'

data/rubyuw.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyuw}
-  s.version = "0.99.2"
+  s.version = "0.99.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mitchell Hashimoto"]
-  s.date = %q{2009-12-06}
+  s.date = %q{2010-01-17}
   s.description = %q{Library which provides a ruby interface to the University of Washington student portal.}
   s.email = %q{mitchell.hashimoto@gmail.com}
   s.extra_rdoc_files = [
@@ -23,17 +23,20 @@ Gem::Specification.new do |s|
      "lib/rubyuw.rb",
      "lib/rubyuw/base.rb",
      "lib/rubyuw/connection.rb",
+     "lib/rubyuw/curriculum.rb",
      "lib/rubyuw/curriculum_enrollment.rb",
      "lib/rubyuw/errors.rb",
      "lib/rubyuw/schedule.rb",
      "lib/rubyuw/sln.rb",
      "rubyuw.gemspec",
      "test/live/curriculum_enrollment_test.rb",
+     "test/live/curriculum_test.rb",
      "test/live/sln_test.rb",
      "test/live/test_helper.rb",
      "test/mocked/base_test.rb",
      "test/mocked/connection_test.rb",
      "test/mocked/curriculum_enrollment_test.rb",
+     "test/mocked/curriculum_test.rb",
      "test/mocked/fixture_pages/bad_request.html",
      "test/mocked/fixture_pages/curric_courses.html",
      "test/mocked/fixture_pages/curric_no_courses.html",
@@ -43,6 +46,7 @@ Gem::Specification.new do |s|
      "test/mocked/fixture_pages/no_form_login.html",
      "test/mocked/fixture_pages/no_login_button.html",
      "test/mocked/fixture_pages/not_logged_in_relay.html",
+     "test/mocked/fixture_pages/quarter_time_schedule.html",
      "test/mocked/fixture_pages/registration.html",
      "test/mocked/fixture_pages/registration_error.html",
      "test/mocked/fixture_pages/registration_error_no_rows.html",
@@ -58,6 +62,7 @@ Gem::Specification.new do |s|
      "test/mocked/fixture_pages/sln_no_course_notes.html",
      "test/mocked/fixture_pages/sln_no_enrollment_info.html",
      "test/mocked/fixture_pages/sln_status.html",
+     "test/mocked/fixture_pages/time_schedule_chem.html",
      "test/mocked/fixture_pages/welcome.html",
      "test/mocked/schedule_test.rb",
      "test/mocked/sln_test.rb",
@@ -71,11 +76,13 @@ Gem::Specification.new do |s|
   s.summary = %q{Library which provides a ruby interface to the University of Washington student portal.}
   s.test_files = [
     "test/live/curriculum_enrollment_test.rb",
+     "test/live/curriculum_test.rb",
      "test/live/sln_test.rb",
      "test/live/test_helper.rb",
      "test/mocked/base_test.rb",
      "test/mocked/connection_test.rb",
      "test/mocked/curriculum_enrollment_test.rb",
+     "test/mocked/curriculum_test.rb",
      "test/mocked/schedule_test.rb",
      "test/mocked/sln_test.rb",
      "test/mocked/test_helper.rb"

data/test/live/curriculum_test.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class LiveCurriculumTest < Test::Unit::TestCase
+  setup do
+    @term = "WIN2010"
+  end
+
+  context "live curriculum listing grabbing" do
+    context "checking parsing of curriculums" do
+      setup do
+        @valid_curriculums = ["CHEM", "Chemistry", "   BIO A "]
+        @invalid_curriculums = ["Underwater Weaving", "  Chmeistry"]
+      end
+      
+      should "not raise any errors on valid curriculums" do
+        @valid_curriculums.each do |curriculum|
+          assert_nothing_raised {
+            result = RubyUW::Curriculum.find(curriculum, @term)
+            assert result.is_a?(Hash)
+            assert_equal :curriculum, result[:type]
+          }
+        end
+      end
+      
+      should "raise CurriculumDoesNotExistError on invalid curriculums" do
+        @invalid_curriculums.each do |curriculum|
+          assert_raises(RubyUW::Errors::CurriculumDoesNotExistError) {
+            RubyUW::Curriculum.find(curriculum, @term)
+          }
+        end
+      end
+    end
+    
+    context "proper grabbing of courses" do
+      setup do
+        @valid_curriculums = {
+          "BIO A" => {
+            "BIO A 201" => 10943..10949
+          }
+        }
+      end
+      
+      should "extract proper amount of courses from a curriculum" do
+        @valid_curriculums.each do |curriculum, courses|
+          result = RubyUW::Curriculum.find(curriculum, @term)
+          assert result.is_a?(Hash)
+
+          courses.each do |expected_course, sln_range|
+            found = false
+            slns = []
+            
+            result[:courses].each do |course, data|
+              next unless course[:name] == expected_course
+              
+              data.each do |listing|
+                slns.push(listing[:sln].to_i)
+              end
+              
+              found = true
+              break
+            end
+            
+            assert found
+            assert !slns.empty?
+            
+            sln_range.each { |sln| 
+              assert slns.include?(sln)
+              slns -= [sln] 
+            }
+            assert slns.empty?
+          end
+        end
+      end
+    end
+  end
+  
+  context "live course listing grabbing" do
+    context "checking parsing of courses" do
+      setup do
+        @valid_courses = ["Chemistry 142", "CHEM 142", "CHEM 152", "   BIO A     466"]
+        @invalid_courses = [" Chemistry 111 ", "  CHEM 269"]
+      end
+      
+      should "not raise any errors on valid courses" do
+        @valid_courses.each do |course|
+          assert_nothing_raised {
+            result = RubyUW::Curriculum.find(course, @term)
+            assert result.is_a?(Hash)
+            assert_equal :course, result[:type]
+          }
+        end
+      end
+      
+      should "raise a CourseDoesNotExistError on invalid courses" do
+        @invalid_courses.each do |course|
+          assert_raises(RubyUW::Errors::CourseDoesNotExistError) {
+            RubyUW::Curriculum.find(course, @term)
+          }
+        end
+      end
+    end
+  end
+end

data/test/mocked/curriculum_test.rb

@@ -0,0 +1,256 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class CurriculumTest < Test::Unit::TestCase
+  setup do
+    RubyUW::Curriculum.publicize_singleton_methods
+  end
+  
+  teardown do
+    RubyUW::Curriculum.protect_singleton_methods
+  end
+  
+  context "properly routing to find_curriculum or find_course" do
+    setup do
+      @curriculums = ["Chemistry", "BIO A", "CSE", "  CHEM ", "CHEMISTRY"]
+      @courses = ["CHEM 142", "BIO A 240", "  CHEM 142 ", "  BIO A 240   "]
+      @term = "WIN2010"
+    end
+    
+    should "recognize each of the curriculums" do
+      RubyUW::Curriculum.expects(:find_curriculum).times(@curriculums.length)
+      RubyUW::Curriculum.expects(:find_course).never
+      
+      @curriculums.each do |curriculum|
+        RubyUW::Curriculum.find(curriculum, @term)
+      end
+    end
+    
+    should "recognize each of the courses" do
+      RubyUW::Curriculum.expects(:find_curriculum).never
+      RubyUW::Curriculum.expects(:find_course).times(@courses.length)
+      
+      @courses.each do |course|
+        RubyUW::Curriculum.find(course, @term)
+      end
+    end
+  end
+  
+  context "finding course information" do
+    setup do
+      @term = "WIN2010"
+    end
+
+    context "parsing course string" do
+      should "parse the proper curriculum from the course string" do
+        curriculums = {
+          "Chemistry 142" => ["Chemistry", "142"],
+          "CHEM 142" => ["CHEM", "142"],
+          "Chemistry 142" => ["Chemistry", "142"],
+          "BIO A   240" => ["BIO A", "240"],
+          "I'm invalid =]" => [nil, nil],
+          "CHEM INVALID" => [nil, nil]
+        }
+
+        curriculums.each do |course, curric|
+          parsed = RubyUW::Curriculum.parse_curriculum(course)
+          parsed_curric = parsed[0] unless parsed.nil?
+          parsed_number = parsed.nil? ? nil : parsed[1]
+          assert_equal curric[0], parsed_curric
+          assert_equal curric[1], parsed_number
+        end
+      end
+    end
+    
+    context "finding course within returned curriculum information" do
+      setup do
+        @page = RubyUW::Base.connection.get(path_to_html("time_schedule_chem"))
+        @data = {
+          :type => :curriculum,
+          :courses => RubyUW::Curriculum.extract_courses(@page)
+        }
+        
+        # Below pulled directly from Chem WIN2010 time schedule
+        @listings_count = {
+          "299" => 2,
+          "321" => 3,
+          "520" => 1,
+          "317" => 8
+        }
+        
+        @nonexistent_course = "111"
+      end
+      
+      should "return proper number of listings for a course" do
+        @listings_count.each do |course, amount|
+          listing = RubyUW::Curriculum.find_course_in_data(course, @data)
+        
+          assert_not_nil listing
+          assert_equal amount, listing.length
+        end
+      end
+      
+      should "return nil for a course which doesn't exist" do
+        assert_nil RubyUW::Curriculum.find_course_in_data(@nonexistent_course, @data)
+      end
+    end
+    
+    context "the actual find_course method" do
+      setup do
+        @raw_curriculum = "CHEM 142"
+        @curriculum, @course = RubyUW::Curriculum.parse_curriculum(@raw_curriculum)
+        @page = RubyUW::Base.connection.get(path_to_html("time_schedule_chem"))
+        @data = {
+          :type => :curriculum,
+          :courses => RubyUW::Curriculum.extract_courses(@page)
+        }
+        
+        @listing = RubyUW::Curriculum.find_course_in_data(@course, @data)
+        
+        RubyUW::Curriculum.expects(:parse_curriculum).once.returns([@curriculum, @course])
+        RubyUW::Curriculum.expects(:find_curriculum).once.returns(@data)
+      end
+      
+      should "raise a CourseDoesNotExistError if it can't be parsed" do
+        RubyUW::Curriculum.expects(:find_course_in_data).once.returns(nil)
+        assert_raises(RubyUW::Errors::CourseDoesNotExistError) {
+          RubyUW::Curriculum.find_course(@raw_curriculum, @term)
+        }
+      end
+      
+      should "return a hash on a valid course" do
+        RubyUW::Curriculum.expects(:find_course_in_data).once.returns(@listing)
+        assert_nothing_raised {
+          returned = RubyUW::Curriculum.find_course(@raw_curriculum, @term)
+          assert returned.is_a?(Hash)
+          assert_equal :course, returned[:type]
+          assert returned[:courses].is_a?(Array)
+        }
+      end
+    end
+  end
+  
+  context "finding curriculum information" do
+    context "with checking existence of a quarter" do
+      setup do
+        @page = mock('page')
+      end
+      
+      should "return false if page contains the string 'Time Schedule - No Courses Offered'" do
+        @page.stubs(:body).returns("Time Schedule - No Courses Offered")
+        assert !RubyUW::Curriculum.quarter_exists?(@page)
+      end
+      
+      should "return true if page does not contain that string" do
+        @page.stubs(:body).returns("HI!")
+        assert RubyUW::Curriculum.quarter_exists?(@page)
+      end
+    end
+    
+    context "with checking existence of a curriculum" do
+      setup do
+        @page = mock('page')
+      end
+      
+      should "return false if page contains the string 'Time Schedule - No Courses Offered'" do
+        @page.stubs(:body).returns("Time Schedule - No Courses Offered")
+        assert !RubyUW::Curriculum.curriculum_exists?(@page)
+      end
+      
+      should "return true if page does not contain that string" do
+        @page.stubs(:body).returns("HI!")
+        assert RubyUW::Curriculum.curriculum_exists?(@page)
+      end
+    end
+    
+    context "with finding the link for a curriculum" do
+      setup do
+        @page = RubyUW::Base.connection.get(path_to_html("quarter_time_schedule"))
+        
+        @curriculums = {
+          "Chemistry" => "chem.html",
+          "Biology" => "biology.html",
+          "JAPAN" => "japanese.html",
+          "BIO A" => "bioanth.html",
+          "Underwater Basket" => nil,
+          "UBASK" => nil
+        }
+      end
+      
+      should "extract proper URLs for curriculums" do
+        @curriculums.each do |curric, url|
+          assert_equal url, RubyUW::Curriculum.extract_curriculum_url(curric, @page)
+        end
+      end
+    end
+  end
+  
+  context "extracting course information" do
+    setup do
+      @page = RubyUW::Base.connection.get(path_to_html("time_schedule_chem"))
+    end
+
+    context "extracting course headers" do
+      setup do
+        @header = {
+          :name => "CHEM 142",
+          :title => "GENERAL CHEMISTRY"
+        }
+      end
+      
+      should "extract proper information out of a header" do
+        header_node = @page.search("//table[@bgcolor=\"#99ccff\"]")[0]
+        
+        returned_header = RubyUW::Curriculum.extract_course_header(header_node)
+        @header.each do |k,v|
+          assert_equal v, returned_header[k]
+        end
+      end
+      
+      should "return nil for an invalid header" do
+        header_node = @page.search("//table[@bgcolor=\"#d3d3d3\"]")[0]
+        
+        assert_nothing_raised { 
+          assert_nil RubyUW::Curriculum.extract_course_header(header_node)
+        }
+      end
+    end
+    
+    context "extracting a course listing" do
+      setup do
+        @listing = {
+          :sln => "11610",
+          :section => "A",
+          :type => "LC"
+        }
+      end
+      
+      should "return the proper information for the first listing" do
+        node = @page.search("//table[@bgcolor=\"#99ccff\"]//following-sibling::table")[0]
+        
+        returned = RubyUW::Curriculum.extract_course_listing(node)
+        @listing.each do |k,v|
+          assert_equal v, returned[k]
+        end
+      end
+      
+      should "raise an exception if the listing does not match" do
+        pre_node = mock('pre_node')
+        pre_node.expects(:inner_text).once.returns("I don't match")
+        node = mock('node')
+        node.expects(:search).once.returns(pre_node)
+        
+        assert_raises(RubyUW::Errors::CourseListingMatchError) {
+          RubyUW::Curriculum.extract_course_listing(node)
+        }
+      end
+    end
+    
+    context "extracting the list of courses" do
+      should "not raise any errors on a valid page" do
+        assert_nothing_raised {
+          RubyUW::Curriculum.extract_courses(@page)
+        }
+      end
+    end
+  end
+end