octranspo 0.0.0

data/lib/octranspo/mobile_resource_methods.rb

@@ -0,0 +1,98 @@
+require "hpricot"
+require "iconv"
+
+module OCTranspo
+  module MobileResourceMethods
+    include RemoteResourceMethods
+    
+    def site
+      "http://www.octranspo.com/mobileweb"
+    end
+
+    def date_stamp (date)
+      date.strftime("%Y%m%d")
+    end
+    
+    def default_options
+      {:index => 0, :date => Date.current}
+    end
+    
+    protected
+    
+    # Return a Hpricot DOM representing source_code.
+    def interpret (source_code)
+      Hpricot(convert_to_utf_8(source_code), :fixup_tags => true)
+    end
+    
+    # Return a copy of source_code converted to UTF-8.
+    def convert_to_utf_8 (source_code)
+      Iconv.new('UTF-8', 'ISO-8859-1').iconv(source_code).sub('charset=iso-8859-1', 'charset=utf-8')
+    end
+    
+    # TODO: Use Lingo instead of local regexps.
+    def extract_route_and_direction_from (text)
+      if matches = /OTrn (.+)/.match(text)
+        {:route => "O-Train", :direction => matches[1].strip.mb_chars.upcase}
+      elsif matches = /^SHTL SCOTIA BANK PLACE BANQUE SCOTIA/.match(text)
+        {:route => nil, :direction => "SHUTTLE TO SCOTIA BANK PLACE BANQUE SCOTIA"}
+      elsif matches = /(\d+) (.+)/.match(text)
+        {:route => matches[1], :direction => matches[2].strip.mb_chars.upcase}
+      else
+        raise "Failed to extract route and direction: #{text}"
+      end
+    end
+    
+    # TODO: Use Lingo instead of local regexps.
+    def extract_location_from (text)
+      if matches = /(.+) ([1-9][A-E]) +\((\d\d\d\d)\)/.match(text)
+        {:station => matches[1], :platform => matches[2], :number => matches[3], :name => "#{matches[1]} #{matches[2]}"}
+      elsif matches = /(.+) \((\d\d\d\d)\)/.match(text)
+        {:name => matches[1], :number => matches[2]}
+      else
+        {:name => text.strip}
+      end
+    end
+
+    def extract_time_from (text, schedule)
+      match = /(\d+):(\d+) (AM|PM)/.match(text)
+      if match
+        hour     = match[1].to_i
+        minute   = match[2].to_i
+        meridian = match[3]
+
+        if meridian == "AM"
+          if hour < 4
+            hour = hour + 24
+          end
+        else
+          unless hour == 12
+            hour = hour + 12
+          end
+        end
+
+        seconds_after_midnight = hour.hours.seconds + minute.minutes.seconds
+        return Time.zone.parse(schedule[:date].to_s) + seconds_after_midnight
+      end
+    end
+    
+    def extract_departure_from (text, schedule)
+      flags = extract_flags_from(text)
+      destination_flag = schedule[:destinations].keys.detect { |key| flags.delete(key) }
+      departure = {}
+      departure[:time] = extract_time_from(text, schedule)
+      departure[:destination] = schedule[:destinations][destination_flag]
+      if flags.any?
+        departure[:notes] = flags.map { |key| schedule[:legend][key] }
+      end
+      departure
+    end
+    
+    def extract_flags_from (text)
+      if flag_data = /\[(.+)\]/.match(text)
+        flag_data[1].split("")
+      else
+        []
+      end
+    end
+  end
+end

data/lib/octranspo/mobile_route_data.rb

@@ -0,0 +1,85 @@
+module OCTranspo
+  module MobileRouteData
+
+    include MobileResourceMethods
+    extend self
+
+    # Provides an interface for retreiving basic information about an OC Transpo transit route. Data is
+    # sourced from http://octranspo.com/mobileweb/jnot/post.routelist.schedules.oci
+    # 
+    # = Usage
+    # 
+    # OCTranspo::MobileRouteData.find returns an array of direction hashes for a single route. Most routes 
+    # operate in two directions so you will usually receive an array with two items in it. For example:
+    #  
+    #   # Find data for OCTranspo bus route 2 on today’s date
+    #   route_data = OCTranspo::MobileRouteData.find(2)
+    #   
+    #   # Bus route 2 has two directions
+    #   route_data.size  # => 2
+    #   
+    #   # 2 BAYSHORE is the first direction
+    #   route_data[0][:route]            # => "2"
+    #   route_data[0][:direction]        # => "BAYSHORE"
+    #   route_data[0][:direction_index]  # => "2"
+    #   route_data[0][:stops]            # => [{:name => "RIDEAU 4A", :number => "3009"}, ...]
+    #   
+    #   # 2 DOWNTOWN is the opposite direction
+    #   route_data[1][:route]            # => "2"
+    #   route_data[1][:direction]        # => "DOWNTOWN / CENTRE-VILLE"
+    #   route_data[1][:direction_index]  # => "1"
+    #   route_data[1][:stops]            # => [{:name => "BAYSHORE 4B", :number => "3050"}, ...]
+    #
+    # = Notes
+    #
+    # The direction_index attributes returned by OCTranspo::MobileRouteData methods are always the values 
+    # "1" or "2". These values correspond to the direction_index argument in OCTranspo::MobileRouteSchedule. 
+    # Sometimes the first direction has the value "1", sometimes it has the value "2". When a route only has
+    # one direction it usually has the value "1". All in all very confusing.
+      
+    # Returns an array of direction hashes or nil if the route was not found. 
+    def find (route_name_or_number, options={})
+      options[:route] = route_name_or_number
+      directions = find_all_directions(options)
+      if directions.any?
+        return directions
+      end
+    end
+    
+    def find_all_directions (options={})
+      directions = []
+      0.upto(1) do |index|
+        directions << find_one_direction(options.merge(:index => index))
+      end
+      directions.compact
+    end
+    
+    def find_one_direction (options={})
+      decode(read(options))
+    end
+    
+    def url_for (options={})
+      options = default_options.merge(options)
+      url = "#{site}/jnot/post.routelist.schedules.oci?"
+      url << "rangeIndex=5&day=#{date_stamp(options[:date])}"
+      url << "&route=#{options[:route]}&routeIndex=#{options[:index]}"
+    end
+    
+    def path_for (options={})
+      options = default_options.merge(options)
+      "#{date_stamp(options[:date])}/route_#{options[:route]}_index_#{options[:index]}.html"
+    end
+    
+    def decode (source_code)
+      document = interpret(source_code)
+      if table_of_stops = document.at("#SchedulesStopListStopsTable")
+        direction = extract_route_and_direction_from(table_of_stops.search(:td)[1].inner_text)
+        direction[:direction_index] = document.at("#direction")[:value].sub('Direction', '')
+        direction[:stops] = table_of_stops.search("td.checkbox").map do |cell|
+          extract_location_from(cell.inner_text.strip)
+        end
+        return direction
+      end
+    end
+  end
+end

data/lib/octranspo/mobile_route_schedule.rb

@@ -0,0 +1,118 @@
+module OCTranspo
+  module MobileRouteSchedule
+
+    include MobileResourceMethods
+    extend self
+
+    # Provides an interface for retreiving OC Transpo timetables for a specific route, direction and location_index.
+    # This API is somewhat less convenient than OCTranpo::MobileStopSchedule. 
+    #
+    # The data returned by this module is sourced from:
+    # http://www.octranspo.com/mobileweb/jnot/post.stoplist.schedules.oci
+    #
+    # == Usage
+    #   
+    #   # Find the schedule for the 85 going to HURDMAN from Bayshore Station (the first stop on the route)
+    #   schedule = OCTranspo::MobileRouteSchedule.find(:route => 85, :direction => "HURDMAN", :location_index => 0)
+    #   schedule[:route]             # => "85"
+    #   schedule[:direction]         # => "HURDMAN"
+    #   schedule[:location][:name]   # => "BAYSHORE 4B"
+    #   schedule[:location][:number] # => "3050"
+    #   schedule[:date]              # => Date.current
+    #   schedule[:departures]        # => [{:time => Time.zone.parse('04:12'), :destination => "HURDMAN"}, ...]
+    #
+    #   # Find the schedule for the 85 going to HURDMAN from Bronson Ave. & Somerset St. (53rd stop on the route)
+    #   schedule = OCTranspo::MobileRouteSchedule.find(:route => 85, :direction => "HURDMAN", :location_index => 53)
+    #   schedule[:route]             # => "85"
+    #   schedule[:direction]         # => "HURDMAN"
+    #   schedule[:location][:name]   # => "BRONSON / SOMERSET W-O"
+    #   schedule[:location][:number] # => "6625"
+    #   schedule[:date]              # => Date.current
+    #   schedule[:departures]        # => [{:time => Time.zone.parse('04:42'), :destination => "HURDMAN"}, ...]
+
+    # Return a Hpricot DOM representing source_code.
+    def interpret (source_code)
+      Hpricot(convert_to_utf_8(source_code))
+    end
+    
+    def find (options={})
+      options[:date] = if options[:date]
+        options[:date].to_date          
+      else
+        Date.current
+      end
+      decode(read(options), options[:date])        
+    end
+    
+    def find_one (options={})
+      options[:date] = if options[:date]
+        options[:date].to_date          
+      else
+        Date.current
+      end
+      decode(read(options), options[:date])
+    end
+    
+    def decode (source_code, date)
+      document = interpret(source_code)
+
+      route_and_direction_text = document.at("#SchedulesTimesSelectedTable").search(:tr)[2].search(:td)[1].inner_text
+      location_text            = document.at("#SchedulesTimesListTable td.header").inner_text
+      departure_texts          = Array(document.search('#SchedulesTimesListTable td'))[1..-1].map do |cell| cell.inner_text.strip end
+      
+      schedule = {:date => date, :legend => {}}
+      schedule.merge! extract_route_and_direction_from(route_and_direction_text)
+      schedule[:destinations] = Hash.new(schedule[:direction])
+      
+      Array(document.search("#SchedulesTimesNotesTable td.notes")).in_groups_of(2) do |flag_cell, value_cell|
+        flag = flag_cell.inner_text.sub('[', '').sub(']', '').strip
+        text = value_cell.inner_text.strip
+        if text.include?("Destination")
+          schedule[:destinations][flag] = text.sub("Destination ", "")
+        else
+          schedule[:legend][flag] = text
+        end
+      end
+      
+      schedule[:location] = extract_location_from(location_text)
+      schedule[:departures] = departure_texts.inject([]) do |departures, text|
+        departures << extract_departure_from(text, schedule)
+      end
+      
+      schedule[:headsigns] = schedule[:departures].map do |d| d[:destination] end.uniq
+      
+      return schedule
+    end
+    
+    def default_options
+      {:direction_index => 1, :location_index => 0, :date => Date.current}
+    end
+    
+    def url_for (options={})
+      options = default_options.merge(convert_options(options))
+      url = "#{site}/jnot/post.stoplist.schedules.oci?"
+      url << "rangeIndex=5&day=#{date_stamp(options[:date])}"
+      url << "&route=#{options[:route]}"
+      url << "&direction=Direction#{options[:direction_index]}"
+      url << "&check#{options[:location_index]}=on"
+    end
+    
+    def path_for (options={})
+      options = default_options.merge(convert_options(options))
+      "#{date_stamp(options[:date])}/route_#{options[:route]}_direction_#{options[:direction_index]}_location_#{options[:location_index]}.html"
+    end
+    
+    def convert_options (options={})
+      if options[:direction]
+        route_data = MobileRouteData.find(options[:route], :date => options[:date])
+        direction_data = route_data.detect do |dataset|
+          dataset[:direction] === options[:direction]
+        end
+        if direction_data
+          options[:direction_index] = direction_data[:direction_index]
+        end
+      end
+      return options
+    end
+  end
+end

data/lib/octranspo/mobile_stop_schedule.rb

@@ -0,0 +1,137 @@
+module OCTranspo
+  module MobileStopSchedule
+
+    include MobileResourceMethods
+    extend self
+
+    # Provides an interface for retreiving OCTranspo timetables for a specific route and location. This API
+    # is more convenient than OCTranpo::MobileStopSchedule but it doesn’t work for stops without numbers.
+    #
+    # The data returned by this module is sourced from:
+    # http:/octranspo.com/mobileweb/jnot/post.routelist.stoptimes.oci
+    # 
+    # == Usage
+    # 
+    #   # Find the schedule for the 85 going to HURDMAN at Bayshore Station (the first stop on the route)
+    #   schedule = OCTranspo::MobileStopSchedule.find(:route => 85, :direction => "HURDMAN", :location => "3050")
+    #   schedule[:route]             # => "85"
+    #   schedule[:direction]         # => "HURDMAN"
+    #   schedule[:location][:name]   # => "BAYSHORE 4B"
+    #   schedule[:location][:number] # => "3050"
+    #   schedule[:date]              # => Date.current
+    #   schedule[:departures]        # => [{:time => Time.zone.parse('04:12'), :destination => "HURDMAN"}, ...]
+    #
+    #   # Find the schedule for the 85 going to HURDMAN at Bronson Ave. & Somerset St.
+    #   schedule = OCTranspo::MobileStopSchedule.find(:route => 85, :direction => "HURDMAN", :location => "6625")
+    #   schedule[:route]             # => "85"
+    #   schedule[:direction]         # => "HURDMAN"
+    #   schedule[:location][:name]   # => "BRONSON / SOMERSET W-O"
+    #   schedule[:location][:number] # => "6625"
+    #   schedule[:date]              # => Date.current
+    #   schedule[:departures]        # => [{:time => Time.zone.parse('04:42'), :destination => "HURDMAN"}, ...]
+    
+    def find (options={})
+      route     = "#{options.delete(:route)}"
+      direction = "#{options.delete(:direction)}"
+      find_all(options).detect do |schedule|
+        (schedule[:route] == route) && (schedule[:direction] == direction)
+      end
+    end
+    
+    def find_all (options={})
+      options[:date] ||= default_options[:date]
+      if File.exist? index_path_for(options)
+        localize YAML.load(open(index_path_for(options)))
+      else
+        all_routes = []
+        while schedule = find_one(options.merge(:route_index => all_routes.size))
+          all_routes << schedule
+        end
+        open index_path_for(options), 'w' do |f|
+          YAML.dump all_routes, f
+        end
+
+        find_all(options)
+      end
+    end
+    
+    def find_one (options={})
+      source_code = read(options)
+      decode(source_code)
+    end
+
+    def localize (schedules)
+      schedules.each do |schedule|
+        schedule[:departures].each do |departure|
+          departure[:time] = departure[:time].in_time_zone
+        end
+      end
+    end
+ 
+    def decode (source_code)
+      document = interpret(source_code)
+      unless document.at('.InfoBeanError')
+        schedule = {:legend => {}}
+
+        header_rows = document.search("#StopTimesTimesSelectedTable > tr")
+      
+        date_text = header_rows[0].search(:td)[1].inner_text
+        schedule.merge! :date => Date.parse(date_text)
+      
+        location_text = header_rows[2].search(:td)[1].inner_text
+        schedule.merge! :location => extract_location_from(location_text)
+
+        route_and_direction_text = header_rows[6].search(:td)[1].inner_text
+        schedule.merge! extract_route_and_direction_from(route_and_direction_text)
+      
+        schedule[:destinations] = Hash.new(schedule[:direction])
+        header_rows.slice(8, header_rows.size).each do |row|
+          cells = row.search(:td)
+          flag = /\[(.)\]/.match(cells[0].inner_text)[1]
+          text = cells[1].inner_text
+          if text.include?("Destination")
+            schedule[:destinations][flag] = text.sub("Destination ", "")
+          else
+            schedule[:legend][flag] = text
+          end
+        end
+        
+        departure_texts = document.search("#StopTimesTimesListTable0 td").map {|cell| cell.inner_text.strip }
+        schedule[:departures] = departure_texts.inject([]) do |departures, text|
+          departures << extract_departure_from(text, schedule)
+        end
+        
+        schedule[:headsigns] = schedule[:departures].map { |d| d[:destination] }.uniq
+        
+        return schedule
+      end
+    end
+    
+    def default_options
+      {:route_index => 0, :date => Date.current}
+    end
+    
+    def url_for (options={})
+      options = default_options.merge(options)
+      url = "#{site}/jnot/post.routelist.stoptimes.oci?"
+      url << "rangeIndex=5&day=#{date_stamp(options[:date])}"
+      url << "&stop=#{options[:location]}"
+      url << "&check#{options[:route_index]}=on"
+    end
+
+    def path_for (options={})
+      options = default_options.merge(options)
+      "#{date_stamp(options[:date])}/location_#{options[:location]}_route_index_#{options[:route_index]}.html"
+    end
+
+    def index_path_for (options={})
+      options = default_options.merge(options)
+      case @source
+      when :fixtures
+        "#{fixtures_path}/#{date_stamp(options[:date])}/location_#{options[:location]}.yml"
+      else
+        "#{cache_path}/#{date_stamp(options[:date])}/location_#{options[:location]}.yml"
+      end
+    end
+  end
+end

data/lib/octranspo/remote_resource_methods.rb

@@ -0,0 +1,89 @@
+require "open-uri"
+
+module OCTranspo
+  module RemoteResourceMethods
+    
+    def read (options={})
+      # puts url_for(options)
+      case @source
+      when :fixtures
+        read_from_fixture(options)
+      else
+        read_from_cache(options) || cache(options)
+      end
+    end
+    
+    def read_from_remote (options)
+      url = url_for(options)
+      puts "Opening #{url}"
+      open(url).read
+    end
+    
+    def read_from_fixture (options)
+      address = fixture_path_for(options)
+      create_fixture(options) unless File.exist?(address)
+      open(address).read
+    end
+    
+    def read_from_cache (options)
+      address = cache_path_for(options)
+      if File.exist?(address)
+        open(address).read
+      end
+    end
+    
+    def reset!
+      @source = nil
+    end
+    
+    def use_fixtures!
+      @source = :fixtures
+    end
+    
+    def site; end
+    
+    def url_for (options={}); end
+
+    def path_for (options={}); end
+    
+    def fixture_path_for (options={}); 
+      "#{fixtures_path}/#{path_for(options)}"
+    end
+
+    def cache_path_for (options={}); 
+      "#{cache_path}/#{path_for(options)}"
+    end
+    
+    def fixtures_path
+      "test/fixtures/#{self.name.demodulize.underscore}"
+    end
+    
+    def cache_path
+      "cache/octranspo/#{self.name.demodulize.underscore}"
+    end
+    
+    def create_fixture (options={})
+      address = fixture_path_for(options)
+      puts "Creating fixture #{address}"
+      system "mkdir -p #{File.dirname(address)}"
+      File.open(address, "w") do |f|
+        f.write read_from_remote(options)
+      end
+      read_from_fixture(options)
+    end
+    
+    def cache (options={})
+      address = cache_path_for(options)
+      system "mkdir -p #{File.dirname(address)}"
+      File.open(address, "w") do |f|
+        f.write read_from_remote(options)
+      end
+      puts "Cached #{address}"
+      read_from_cache(options)
+    end
+    
+    def logger
+      RAILS_DEFAULT_LOGGER
+    end
+  end
+end