tableau 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 78a2bd4d06b44a5c5fac93cc6eb728f0b405e9e7
+  data.tar.gz: 44763957d728478811a5f91c9509f334f3966752
+SHA512:
+  metadata.gz: 28b0d5f1082b31434cf4debb8b463a2c4bd823c9ab93b6e9ac6a51a70bcd9ff1672639f0d6c375cfa2c892f3a27cecf54df162702f60b95c44244dbc3b7c890d
+  data.tar.gz: f0e570d93e64733397d197f6d64d356312796b317534abe3bd88f44e92152c5f039835864e08f79f95ebebd980d077f6bca606b32df09ab7a5e3f9777020092b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Matt Ryder
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Tableau'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+

data/lib/tableau.rb

@@ -0,0 +1,21 @@
+require 'json'
+require 'tableau/timetable'
+require 'tableau/moduleparser'
+require 'tableau/tablebuilder'
+
+module Tableau
+	class << self
+
+    def generate(table_id, module_codes)
+      timetable = Tableau::Timetable.new(table_id, module_codes)
+      builder = Tableau::TableBuilder.new(timetable)
+      builder.to_html
+    end
+
+    # Return the Name, Code and Types (2Prac / PracA / PracB etc) from the timetable
+    def module_info(module_code)
+      Tableau::ModuleParser.new(module_code).module_info
+    end
+
+	end
+end

data/lib/tableau/baseparser.rb

@@ -0,0 +1,136 @@
+require 'tableau/timetable'
+require 'tableau/module'
+require 'tableau/class'
+require 'tableau/uribuilder'
+require 'tableau/classarray'
+
+module Tableau
+  class BaseParser
+
+    @@COURSE_DESCRIPTION_XPATH = '/html/body/table[1]//td//td/text()'
+    @@WEEKS_REGEX = /^([\d]{2}-[\d]{2})|^([\d]{2})/
+
+    # Create a new instance of the BaseParser, with an ID to lookup
+    def initalize(lookup_id)
+      @time, @day = Time.new(2013, 1, 1, 9, 0, 0), 0
+      @lookup_id  = lookup_id
+    end
+
+    # Parse the module table for any classes
+    def parse_table(table_rows)
+      classes = Tableau::ClassArray.new
+      @day = 0
+
+      # delete the time header row
+      table_rows.delete(table_rows.first)
+
+      table_rows.each do |row|
+        @time = Time.new(2013, 1, 1, 9, 0, 0)
+
+        # drop the 'Day' cell from the row
+        row_items = row.xpath('td')
+        row_items.delete(row_items.first)
+
+        row_items.each do |cell|
+          if cell.attribute('colspan')
+            intervals = cell.attribute('colspan').value
+            classes << create_class(cell)
+          else intervals = 1
+          end
+
+          inc_time(intervals)
+        end
+
+        @day += 1
+      end
+
+      classes
+    end
+
+    # Create a Class from the given data element
+    def create_class(class_element)
+      begin
+        tt_class = Tableau::Class.new(@day, @time)
+        data = class_element.xpath('table/tr/td//text()')
+        raise "Misformed cell for #{module_id}" if data.count < 4
+      rescue Exception => e
+        p "EXCEPTION: #{e.message}", "Data Parsed:", data
+        return nil
+      end
+
+      # If the weeks are in the 2nd index, it's a core timetable
+      if @@WEEKS_REGEX.match(data[1].text())
+        tt_class.code = data[0].text().match(/^[A-Za-z0-9\-]+/).to_s
+        tt_class.type = data[0].text().gsub(tt_class.code, '').gsub('/', '')
+
+        tt_class.weeks    = create_class_weeks(data[1].text())
+        tt_class.location = data[2].text()
+        tt_class.name     = data[3].text()
+      else # this is a module timetable, laid out differently
+        if data[0].to_s != ""
+          tt_class.code = data[0].text().match(/^[A-Za-z0-9\-]+/).to_s
+          tt_class.type = data[0].text().gsub(tt_class.code, '').gsub('/', '')
+        end
+
+        tt_class.location  = data[1].text()
+        tt_class.name      = data[2].text()
+        tt_class.weeks     = create_class_weeks(data[3].text())
+      end
+
+      # Same attribute on both timetables, DRY'd here
+      tt_class.tutor = data[4] ? data[4].text() : nil
+
+      if intervals = class_element.attribute('colspan').value
+        tt_class.intervals = intervals.to_i
+      end
+
+      tt_class
+    end
+
+    # Create the week range array for the given week string
+    def create_class_weeks(week_data)
+      week_span_regex   = /([\d]{2}-[\d]{2})/
+      week_start_regex  = /^[0-9]{2}/
+      week_end_regex    = /[0-9]{2}$/
+      week_single_regex = /[\d]{2}/
+
+      class_weeks = Array.new
+
+      week_data.scan(@@WEEKS_REGEX).each do |weekspan|
+
+        # if it's a 28-39 week span
+        if weekspan =~ week_span_regex
+          start  = week_start_regex.match(weekspan)[0].to_i
+          finish = week_end_regex.match(weekspan)[0].to_i
+
+          while start <= finish
+            class_weeks << start
+            start += 1
+          end
+
+        # some single week (30, 31, 32 etc) support
+        elsif weekspan =~ week_single_regex
+          class_weeks << week_single_regex.match(weekspan)[0].to_i
+        end
+      end
+
+      class_weeks
+    end
+
+    # Increments the @time by 15 minute intervals
+    def inc_time(intervals)
+      intervals.to_i.times { @time += 900 }
+    end
+
+    # Get the ID string in the first <table> element (usually <:code> - <:name>)
+    def get_info(timetable_data)
+      timetable_data.xpath(@@COURSE_DESCRIPTION_XPATH).to_html
+    end
+
+    # Returns the XPath for the nth table
+    def xpath_for_table(table_count)
+      "/html/body/table[#{3 * table_count - 1}]/tr"
+    end
+
+  end
+end

data/lib/tableau/class.rb

@@ -0,0 +1,34 @@
+module Tableau
+  class Class
+
+    attr_accessor :type, :location, :name, :tutor,
+                  :day, :time, :intervals, :weeks,
+                  :code
+
+    def defaults
+      def_opts = {
+        type: '',
+        location: '',
+        name: '',
+        tutor: '',
+        intervals: 4,
+        day:  0,
+        code: 0,
+        time: Time.new
+      }
+    end
+
+    def initialize(day, time, options = {})
+      @day = day
+      @time = time
+      @weeks = Array.new
+      defaults.merge!(options)
+    end
+
+    # Duration of the class in hours
+    def duration
+      @intervals / 4
+    end
+
+  end
+end

data/lib/tableau/classarray.rb

@@ -0,0 +1,30 @@
+module Tableau
+  class ClassArray < Array
+
+    def initialize
+      super
+    end
+
+    # Returns an array of all the classes for the day
+    def classes_for_day(day)
+      days_classes = ClassArray.new
+      self.each { |c| days_classes << c if c.day == day }
+      days_classes.count > 0 ? days_classes : nil
+    end
+
+    # Returns the earliest class in the module
+    def earliest_class
+      earliest = self.first
+      self.each { |c| earliest = c if c.time < earliest.time }
+      earliest
+    end
+
+    # Returns the latest class in the module
+    def latest_class
+      latest = self.first
+      self.each { |c| latest = c if c.time > latest.time }
+      latest
+    end
+
+  end
+end

data/lib/tableau/module.rb

@@ -0,0 +1,40 @@
+module Tableau
+  class Module
+
+    attr_reader :module_id, :name, :classes
+
+    def initialize(id, options = {})
+      @module_id = id
+
+      @name    = options[:name] || ''
+      @classes = options[:classes] || Tableau::ClassArray.new
+    end
+
+    # Add a class to the module
+    def add_class(new_class)
+      @classes << new_class
+    end
+
+    # Returns an array of all the classes for the day
+    def classes_for_day(day)
+      days_classes = Tableau::ClassArray.new
+      @classes.each { |c| days_classes << c if c.day == day }
+      days_classes.count > 0 ? days_classes : nil
+    end
+
+    # Returns the earliest class in the module
+    def earliest_class
+      earliest = @classes.first
+      @classes.each { |c| earliest = c if c.time < earliest.time }
+      earliest
+    end
+
+    # Returns the latest class in the module
+    def latest_class
+      latest = @classes.first
+      @classes.each { |c| latest = c if c.time > latest.time }
+      latest
+    end
+
+  end
+end

data/lib/tableau/moduleparser.rb

@@ -0,0 +1,51 @@
+require 'open-uri'
+require 'nokogiri'
+require 'tableau/baseparser'
+
+module Tableau
+  class ModuleParser < Tableau::BaseParser
+
+    @@MODULE_ID_REGEX = /^CE[\d]{5}-[1-8]/
+    attr_reader :raw_timetable
+
+    # Create a new ModuleParser, with an optional module code
+    def initialize(module_code = nil)
+      begin
+        timetable_response = Tableau::UriBuilder.new(module_code, module_lookup: true).read
+        @raw_timetable = Nokogiri::HTML(timetable_response) if timetable_response
+      rescue OpenURI::HTTPError
+        return nil
+      end
+    end
+
+    def module_info
+      mod, types = parse, Set.new
+      mod.classes.each { |c| types.add?(c.type) }
+
+      return { name: mod.name, code: mod.module_id, types: types }
+    end
+
+    def parse
+      raise "No module timetable loaded!" unless @raw_timetable
+
+      #Get the ID and Name from the first <table>
+      raw_info    = @raw_timetable.xpath(@@COURSE_DESCRIPTION_XPATH).to_html
+      module_id   = @@MODULE_ID_REGEX.match(raw_info).to_s
+      module_name = raw_info.gsub(module_id, '')
+
+      mod = Tableau::Module.new(module_id, name: module_name)
+      table_count = 1
+      table_data = @raw_timetable.xpath(xpath_for_table(table_count))
+
+      # Iterate through each timetable until xpath returns no more timetable tables
+      while !table_data.empty?
+        tables_classes = parse_table(table_data)
+        tables_classes.each { |c| mod.classes << c }
+        table_data = @raw_timetable.xpath(xpath_for_table(table_count += 1))
+      end
+
+      mod #return the module to the caller
+    end
+
+  end
+end

data/lib/tableau/tablebuilder.rb

@@ -0,0 +1,134 @@
+module Tableau
+  class TableBuilder
+
+    def css_defaults
+      css_defaults = {
+        body_color:      '#F4F5F6',
+        border_color:    'rgba(0, 0, 0, 0.25)',
+        class_color:     '#a9b1b9',
+        header_bg_color: '#CFD3D7',
+        header_fg_color: '#25292D',
+        empty_color:     '#EBEDEE'
+      }
+    end
+
+    def initialize(timetable, css_options = {})
+      @timetable = timetable
+      @css = css_defaults.merge(css_options)
+    end
+
+    def build_css
+    %Q{
+    body {
+      background-color: #{@css[:body_color]};
+    }
+
+    table {
+      border-collapse: collapse;
+      border: 1px solid #{@css[:border_color]};
+    }
+
+    #time {
+      background-color: #{@css[:header_bg_color]};
+      color: #{@css[:header_fg_color]};
+    }
+
+    #time > th {
+      font-weight: lighter;
+      border-left: 1px solid #{@css[:border_color]};
+    }
+
+    .dh {
+      background-color: #{@css[:header_bg_color]};
+      color: #{@css[:header_fg_color]};
+    }
+
+    td {
+      background-color: #{@css[:empty_color]};
+      border: 1px solid #{@css[:border_color]};
+      padding: 5px;
+    }
+
+    .class_item {
+      background-color: #{@css[:class_color]};
+    }
+    }
+    end
+
+    def day_row(day, classes, end_time = nil)
+      days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri']
+      time = Time.new(2013, 1, 1, 9, 0 , 0)
+      end_time ||= Time.new(2013, 1, 1, 21, 0, 0)
+
+      day_row = %Q{<td class="dh">#{days[day]}</td>}
+
+      if !classes || classes.count == 0
+        while time < end_time
+          day_row += "<td></td>"
+          time += 900 # 15 mins in seconds
+        end
+      else
+        while time < end_time
+          class_at_time = @timetable.class_for_time(day, time)
+          if class_at_time
+            day_row += make_class(class_at_time)
+            time += (900 * class_at_time.intervals)
+          else
+            day_row += "<td></td>"
+            time += 900 # 15 mins in seconds
+          end
+        end
+      end
+      day_row
+    end
+
+    # Create the HTML for a class item on the table
+    def make_class(klass)
+      %Q{
+        <td class="class_item" colspan="#{klass.intervals}">
+          <p>#{klass.name} - #{klass.location}</p>
+          <p>#{klass.type}</p>
+        </td>}
+    end
+
+    # HTML5 representation of the timetable
+    def to_html
+      time_header, rows = '<th></th>', Array.new
+      end_time = Time.new(2013, 1, 1, 21, 0, 0)
+
+      # make the time row
+      @time = Time.new(2013, 1, 1, 9, 0, 0)
+      while @time < end_time
+        time_header += "<th>#{@time.strftime("%-k:%M")}</th>"
+        @time += 900
+      end
+
+      #make each day row
+      (0..4).each do |day|
+        classes = @timetable.classes_for_day(day)
+        rows << day_row(day, classes)
+      end
+
+      rows_str, id_str = '', "id=\"#{@timetable.name}\""
+      rows.each{ |r| rows_str += "<tr class=\"day\">\n#{r}\n</tr>\n" }
+
+      %Q{
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>#{@timetable.name || 'Timetable' } - Timetablr.co</title>
+          <style>#{build_css}</style>
+        </head>
+        <body>
+          <h3>#{@timetable.name}</h3>
+          <table #{id_str if @timetable.name}>
+            <tr id="time">#{time_header}</tr>
+            #{rows_str}
+          </table>
+        </body>
+        </html>
+      }
+    end
+
+  end
+end

data/lib/tableau/timetable.rb

@@ -0,0 +1,114 @@
+module Tableau
+  class Timetable
+
+    attr_accessor :name, :modules
+
+    # Create a new Timetable, with a Timetable Name and Student Set ID
+    def initialize(timetable_name)
+      @name = name || "Timetable"
+      @modules = Array.new
+    end
+
+    # Pushes an existing module into the timetable
+    def push_module(mod)
+      @modules << mod
+    end
+
+    # Adds a Module to the Timetable via the Parser
+    def add_module(module_code)
+      @module = Tableau::ModuleParser.new(module_code).parse
+      @modules << @module if @module
+    end
+
+    # Mass-adds an array of modules objects to the timetable
+    def add_modules(modules)
+      modules.each { |mod_code| add_module(mod_code) }
+    end
+
+    # Removes a class from the timetable
+    def remove_class(rem_class)
+      @modules.each do |m|
+        if m.name == rem_class.name
+          m.classes.delete(rem_class)
+          break
+        end
+      end
+    end
+
+    # Returns an array of the given day's classes
+    def classes_for_day(day)
+      classes = Tableau::ClassArray.new
+
+      @modules.each do |mod|
+        cfd = mod.classes_for_day(day)
+        cfd.each { |cl| classes << cl } if cfd
+      end
+
+      classes.count > 0 ? classes : nil
+    end
+
+    # Returns the class at the given day & time
+    def class_for_time(day, time)
+      cfd = self.classes_for_day(day)
+      cfd.each { |c| return c if c.time == time }
+      nil
+    end
+
+    # Returns the module with given Module Code
+    def module_for_name(module_name)
+      modules.each { |m| return m if m.name }
+      nil
+    end
+
+    # Return the Tableau::Module that matches a given code
+    def module_for_code(mod_code)
+      @modules.each { |m| return m if m.module_id == mod_code } if @modules
+      nil
+    end
+
+    # Returns the earliest class on the timetable
+    def earliest_class
+      earliest_classes = Tableau::ClassArray.new
+      @modules.each { |m| earliest_classes << m.earliest_class }
+
+      earliest = earliest_classes.first
+      earliest_classes.each { |c| earliest = c if c.time < earliest.time }
+      earliest
+    end
+
+    # Returns the latest class on the timetable
+    def latest_class
+      latest_classes = Tableau::ClassArray.new
+      @modules.each { |m| latest_classes << m.latest_class }
+
+      latest = latest_classes.first
+      latest_classes.each { |c| latest = c if c.time > latest.time }
+      latest
+    end
+
+    # Returns an array of time conflicts found in the timetable
+    def conflicts
+      conflicts = Tableau::ClassArray.new
+
+      (0..4).each do |day|
+        days_classes = self.classes_for_day(day)
+        next if !days_classes || days_classes.count == 0
+
+        # get the last element index
+        last = days_classes.count - 1
+
+        for i in 0..last
+          i_c = days_classes[i]
+          time_range = i_c.time..(i_c.time + 3600 * i_c.duration)
+
+          for j in (i+1)..last
+            if time_range.cover?(days_classes[j].time)
+              conflicts << [days_classes[i], days_classes[j]]
+            end
+          end
+        end
+      end
+      conflicts # return the conflicts
+    end
+  end
+end

data/lib/tableau/timetableparser.rb

@@ -0,0 +1,54 @@
+require 'tableau/baseparser'
+
+module Tableau
+  class TimetableParser < Tableau::BaseParser
+
+    @@TIMETABLE_CODE_REGEX = /^[A-Za-z0-9\(\)]+/
+
+    # Create a new TimetableParser, with a Student Set ID (aka Core Timetable)
+    def initialize(student_set_id = nil)
+      begin
+        timetable_response = Tableau::UriBuilder.new(student_set_id).read
+        @raw_timetable = Nokogiri::HTML(timetable_response) if timetable_response
+      rescue OpenURI::HTTPError
+        return nil
+      end
+    end
+
+    # Get a summary of information about this timetable
+    def timetable_info
+    end
+
+    # Parse the Timetable for all Modules within
+    # Returns: A Tableau::Timetable
+    def parse
+      raise "No Timetable loaded!" unless @raw_timetable
+
+      table_info = @@TIMETABLE_CODE_REGEX.match(get_info(@raw_timetable))
+      timetable = Tableau::Timetable.new(table_info)
+
+      table_count = 1
+      table_data = @raw_timetable.xpath(xpath_for_table(table_count))
+
+      while !table_data.empty?
+        table_classes = parse_table(table_data)
+        sort_classes(timetable, table_classes)
+        table_data = @raw_timetable.xpath(xpath_for_table(table_count += 1))
+      end
+      timetable
+    end
+
+    # Sort all the parsed classes into modules
+    def sort_classes(timetable, classes)
+      classes.each do |c|
+        if !(cmodule = timetable.module_for_code(c.code))
+          cmodule = Tableau::Module.new(c.code)
+          timetable.push_module(cmodule)
+        end
+
+        cmodule.add_class(c)
+      end
+    end
+
+  end
+end

data/lib/tableau/uribuilder.rb

@@ -0,0 +1,43 @@
+module Tableau
+  class UriBuilder
+
+    def defaults
+      @options = {
+        root:               'crwnmis3.staffs.ac.uk/Reporting/',
+        timetable_type:     'Individual',
+        lookup_type:        'Student+Sets',
+        timetable_template: 'Design+Template',
+        weeks:              '10-25',                        # 10-25 for Semester 1, 26-42 for Semester 2
+        days:               '1-5',                          # Mon - Fri
+        period_from:        '5',                            # 15 min intervals since 8AM
+        period_to:          '52',
+        optional_params:    '&width=0&height=0'             #optional params
+      }
+    end
+
+    def initialize(lookup_id, options = {})
+      @lookup_id = lookup_id
+      defaults.merge!(options)
+
+      if options[:module_lookup]
+        @options[:lookup_type] = "Modules"
+        @options[:timetable_template] = "Module%20Individual%20SOC"
+      end
+
+      @options[:weeks] = ENV["TABLEAU_SEMESTER"] == 1 ? '10-25' : '26-42'
+    end
+
+    def read
+      open(self.to_s){ |io| io.read }
+    end
+
+    def to_s
+      "http://#{@options[:root]}#{@options[:timetable_type]};#{@options[:lookup_type]};name;" +
+      "#{@lookup_id}?&template=#{@options[:timetable_template].gsub(' ', '%20')}" +
+      "&weeks=#{@options[:weeks]}&days=#{@options[:days]}" +
+      "&periods=#{@options[:period_from]}-#{@options[:period_to]}" +
+      "#{@options[:optional_params]}"
+    end
+
+  end
+end

data/lib/tableau/version.rb

@@ -0,0 +1,3 @@
+module Tableau
+  VERSION = "0.0.1"
+end

data/lib/tasks/tableau_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :tableau do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: tableau
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matt Ryder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-spork
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parses, analyses and creates Timetables for Staffordshire University
+  students.Handles both Course and individual Module timetables.
+email:
+- matt@mattryder.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tableau/timetable.rb
+- lib/tableau/class.rb
+- lib/tableau/uribuilder.rb
+- lib/tableau/timetableparser.rb
+- lib/tableau/moduleparser.rb
+- lib/tableau/baseparser.rb
+- lib/tableau/classarray.rb
+- lib/tableau/module.rb
+- lib/tableau/tablebuilder.rb
+- lib/tableau/version.rb
+- lib/tasks/tableau_tasks.rake
+- lib/tableau.rb
+- MIT-LICENSE
+- Rakefile
+homepage: http://www.github.com/MattRyder/tableau
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Parses, analyses and creates Timetables for Staffordshire University students.Handles
+  both Course and individual Module timetables.
+test_files: []