bort 0.0.1

data/lib/bort.rb

@@ -0,0 +1,160 @@
+require 'net/http'
+require 'time'
+require 'date'
+require 'hpricot'
+require 'bort/realtime'
+require 'bort/route'
+require 'bort/schedule'
+require 'bort/station'
+
+module Bort
+  def self.Bort(key)
+    Util.set_key(key)
+  end
+  def Bort(key); Bort::Bort(key); end
+
+  # shortcuts
+  def self.trains_near(orig, filters={})
+    Realtime::Estimates.new(orig).select(filters)
+  end
+
+  def self.routes(options={})
+    Route.routes(options)
+  end
+
+  def self.route(route_number, options={})
+    Route::Info.new(route_number, options)
+  end
+
+  def self.trips(orig, dest, options={})
+    command = options.delete(:by) { 'arrive' }
+    Schedule::Trips.new(command, orig, dest, options).trips
+  end
+
+  def self.fare(orig, dest, options={})
+    Schedule::fare(orig, dest, options)
+  end
+
+  def self.schedules
+    Schedule.schedules
+  end
+
+  def self.schedule_at(abbreviation, options={})
+    Schedule::StationSchedule.new(abbreviation, options).schedules
+  end
+
+  def self.stations
+    Station.stations
+  end
+
+  def self.station_info(abbreviation)
+    Station.info(abbreviation)
+  end
+
+  class Util
+    def self.set_key(key)
+      @@api_key = key
+    end
+
+    def self.download(params)
+      params[:key] = @@api_key
+      action    = params.delete(:action)
+
+      queries   = params.delete_if{|k, v|v.nil?}.map{|k, v| "#{k}=#{v}" }.join('&')
+      request   = Net::HTTP::Get.new("/api/#{action}.aspx?#{queries}")
+      response  = Net::HTTP.start('api.bart.gov') do |http|
+        http.request(request)
+      end
+
+      response.body
+    end
+
+    # param validation
+    VALID_AM_PM       = ['am', 'pm', nil]
+    VALID_DATE_STRING = ['today', 'now', nil]
+
+    def self.validate_time(time)
+      return unless time
+
+      hm, ap = time.split('+')
+      hh, mm = hm.split(':').map(&:to_i)
+
+      unless /^\d{1,2}:\d{1,2}\+\w\w$/ === time &&
+        VALID_AM_PM.include?(ap.downcase) &&
+        (1..12) === hh &&
+        (0..59) === mm
+
+        raise InvalidTime.new(time)
+      end
+    end
+
+    def self.validate_date(date)
+      return if VALID_DATE_STRING.include?(date)
+
+      mm, dd, yyyy = date.split('/').map(&:to_i)
+      year = Time.now.year
+
+      unless /^\d{1,2}\/\d{1,2}\/\d{4}$/ === date &&
+        (1..12) === mm &&
+        (1..31) === dd &&
+        (year-1..year+1) === yyyy
+
+        raise InvalidDate.new(date)
+      end
+    end
+
+    def self.validate_station(station)
+      raise InvalidStation.new(station) unless STATIONS.keys.map(&:to_s).include?(station.to_s.downcase)
+    end
+  end
+
+  STATIONS = {
+    :"12th" => "12th St. Oakland City Center",
+    :"16th" => "16th St. Mission (SF)",
+    :"19th" => "19th St. Oakland",
+    :"24th" => "24th St. Mission (SF)",
+    :ashb   => "Ashby (Berkeley)",
+    :balb   => "Balboa Park (SF)",
+    :bayf   => "Bay Fair (San Leandro)",
+    :cast   => "Castro Valley",
+    :civc   => "Civic Center (SF)",
+    :cols   => "Coliseum/Oakland Airport",
+    :colm   => "Colma",
+    :conc   => "Concord",
+    :daly   => "Daly City",
+    :dbrk   => "Downtown Berkeley",
+    :dubl   => "Dublin/Pleasanton",
+    :deln   => "El Cerrito del Norte",
+    :plza   => "El Cerrito Plaza",
+    :embr   => "Embarcadero (SF)",
+    :frmt   => "Fremont",
+    :ftvl   => "Fruitvale (Oakland)",
+    :glen   => "Glen Park (SF)",
+    :hayw   => "Hayward",
+    :lafy   => "Lafayette",
+    :lake   => "Lake Merritt (Oakland)",
+    :mcar   => "MacArthur (Oakland)",
+    :mlbr   => "Millbrae",
+    :mont   => "Montgomery St. (SF)",
+    :nbrk   => "North Berkeley",
+    :ncon   => "North Concord/Martinez",
+    :orin   => "Orinda",
+    :pitt   => "Pittsburg/Bay Point",
+    :phil   => "Pleasant Hill",
+    :powl   => "Powell St. (SF)",
+    :rich   => "Richmond",
+    :rock   => "Rockridge (Oakland)",
+    :sbrn   => "San Bruno",
+    :sfia   => "San Francisco Int'l Airport",
+    :sanl   => "San Leandro",
+    :shay   => "South Hayward",
+    :ssan   => "South San Francisco",
+    :ucty   => "Union City",
+    :wcrk   => "Walnut Creek",
+    :woak   => "West Oakland",
+  }
+
+  class InvalidDate < RuntimeError; end
+  class InvalidTime < RuntimeError; end
+  class InvalidStation < RuntimeError; end
+end

data/lib/bort/realtime.rb

@@ -0,0 +1,83 @@
+module Bort
+  module Realtime
+    class Estimates
+      attr_accessor :origin, :platform, :direction, :fetched_at, :destinations, :trains
+
+      VALID_PLATFORMS = %w(1 2 3 4)
+      VALID_DIRECTIONS = %w(n s)
+      def initialize(orig, options={})
+        self.origin = orig
+        load_options(options)
+
+        download_options = {
+          :action => 'etd',
+          :cmd    => 'etd',
+          :orig   => origin,
+          :plat   => platform,
+          :dir    => direction,
+        }
+
+        xml = Util.download(download_options)
+        data = Hpricot(xml)
+
+        self.origin = (data/:abbr).inner_text
+        self.fetched_at = Time.parse((data/:time).inner_text)
+        self.trains = []
+        self.destinations = []
+
+        (data/:etd).map do |estimate|
+          destination = (estimate/:abbreviation).inner_text
+          self.destinations << destination
+          (estimate/:estimate).map do |train|
+            self.trains << Train.new(train, origin, destination)
+          end
+        end
+      end
+
+      def select(type, value=nil)
+        filters =
+          if type.class == Hash
+            type
+          else
+            { type => value }
+          end
+        trains.select do |train|
+          filters.all? do |type, value|
+            train.send(type) == value
+          end
+        end
+      end
+      alias :filter :select
+
+      private
+      def load_options(options)
+        self.platform  = options.delete(:platform)
+        self.direction = options.delete(:direction)
+
+        Util.validate_station(origin)
+        raise InvalidPlatform.new(platform)   unless platform.nil? || VALID_PLATFORMS.include?(platform.to_s)
+        raise InvalidDirection.new(direction) unless direction.nil? || VALID_DIRECTIONS.include?(direction.to_s)
+      end
+    end
+
+    class Train
+      attr_accessor :station, :destination, :minutes, :platform, :direction, :length, :color, :hexcolor, :bike_flag
+
+      def initialize(doc, orig, dest)
+        self.station      = orig
+        self.destination  = dest
+        self.minutes      = (doc/:minutes).inner_text.to_i
+        self.platform     = (doc/:platform).inner_text.to_i
+        self.direction    = (doc/:direction).inner_text[0,1].downcase
+        self.length       = (doc/:length).inner_text.to_i
+        self.color        = (doc/:color).inner_text.downcase
+        self.hexcolor     = (doc/:hexcolor).inner_text.downcase
+        self.bike_flag    = (doc/:bikeflag).inner_text == '1'
+      end
+    end
+
+    class InvalidPlatform   < RuntimeError; end
+    class InvalidDirection  < RuntimeError; end
+
+  end
+end

data/lib/bort/route.rb

@@ -0,0 +1,105 @@
+module Bort
+  module Route
+    class Route
+      attr_accessor :name, :abbreviation, :route_id, :number, :color
+      def self.parse(doc)
+        route = Route.new
+        route.name         = (doc/:name).inner_text
+        route.abbreviation = (doc/:abbr).inner_text
+        route.route_id     = (doc/:routeid).inner_text
+        route.number       = (doc/:number).inner_text.to_i
+        route.color        = (doc/:color).inner_text
+
+        route
+      end
+
+      def info(options={})
+        Info.new(number, options)
+      end
+
+      def schedule(options={})
+        Schedule::RouteSchedule.new(number, options)
+      end
+
+      def <=> other
+        self.number <=> other.number
+      end
+    end
+
+    def self.routes(options={})
+      Routes.new(options).routes
+    end
+
+    class Routes
+      attr_accessor :schedule, :date, :schedule_number, :routes
+
+      def initialize(options={})
+        load_options(options)
+
+        download_options = {
+          :action => 'route',
+          :cmd => 'routes',
+        }
+        download_options[:sched]  = schedule
+        download_options[:date]   = date
+
+        xml = Util.download(download_options)
+        data = Hpricot(xml)
+
+        self.schedule_number = (data/:sched_num).inner_text
+        self.routes = (data/:route).map do |route|
+          Route.parse(route)
+        end.sort
+      end
+
+      private
+      def load_options(options)
+        self.schedule = options.delete(:schedule)
+        # date does not appear to be supported by the current API
+        self.date     = options.delete(:date)
+
+        Util.validate_date(date)
+      end
+    end
+
+    class Info
+      attr_accessor :route_number, :schedule_number, :date, :name, :abbreviation,
+        :route_id, :origin, :destination, :color, :holidays, :stations
+
+      def initialize(number, options={})
+        self.route_number = number
+        load_options(options)
+
+        download_options = {
+          :action => 'route',
+          :cmd => 'routeinfo',
+          :route => route_number,
+        }
+        download_options[:sched]  = schedule_number
+        download_options[:date]   = date
+
+        xml = Util.download(download_options)
+        data = Hpricot(xml)
+
+        self.schedule_number  = (data/:sched_num).inner_text
+        self.name             = (data/:route/:name).inner_text
+        self.abbreviation     = (data/:route/:abbr).inner_text
+        self.route_number     = (data/:route/:number).inner_text
+        self.origin           = (data/:route/:origin).inner_text
+        self.destination      = (data/:route/:destination).inner_text
+        self.color            = (data/:route/:color).inner_text
+        self.holidays         = (data/:route/:holidays).inner_text
+        self.stations         = (data/:route/:config/:station).map(&:inner_text)
+      end
+
+      private
+      def load_options(options)
+        self.schedule_number  = options.delete(:schedule_number)
+        self.date             = options.delete(:date)
+
+        Util.validate_date(date)
+      end
+    end
+
+  end
+end

data/lib/bort/schedule.rb

@@ -0,0 +1,342 @@
+module Bort
+  module Schedule
+    def self.trips_by_arrival(orig, dest, options={})
+      Trips.new('arrive', orig, dest, options).trips
+    end
+
+    def self.trips_by_departure(orig, dest, options={})
+      Trips.new('depart', orig, dest, options).trips
+    end
+
+    class Trips
+      attr_accessor :origin, :destination, :time, :date, :before, :after,
+        :legend, :schedule_number, :trips
+
+      def initialize(command, orig, dest, options={})
+        self.origin = orig
+        self.destination = dest
+        load_options(options)
+
+        download_options = {
+          :action => 'sched',
+          :cmd    => command,
+          :orig   => origin,
+          :dest   => destination,
+          :time   => time,
+          :date   => date,
+          :b      => before,
+          :a      => after,
+          :l      => legend,
+        }
+
+        xml = Util.download(download_options)
+        data = Hpricot(xml)
+
+        self.date             = Date.parse((data/:date).inner_text)
+        self.time             = Time.parse("#{(data/:date).inner_text} #{(data/:time).inner_text}")
+        self.before           = (data/:before).inner_text.to_i
+        self.after            = (data/:after).inner_text.to_i
+        self.legend           = (data/:legend).inner_text
+        self.schedule_number  = (data/:sched_num).inner_text
+        self.trips            = (data/:trip).map{|trip| Trip.parse(trip)}
+      end
+
+      private
+      def load_options(options)
+        self.time   = options.delete(:time)
+        self.date   = options.delete(:date)
+        self.legend = options.delete(:legend)
+        self.before = options.delete(:before)
+        self.after  = options.delete(:after)
+
+        Util.validate_time(time)
+        Util.validate_date(date)
+
+        self.legend = [[0, legend.to_i].max, 1].min unless legend.nil?
+        self.before = [[0, before.to_i].max, 4].min unless before.nil?
+        self.after  = [[0, after.to_i].max,  4].min unless after.nil?
+      end
+    end
+
+    class Trip
+      attr_accessor :origin, :destination, :fare, :origin_time, :origin_date,
+        :destination_time, :destination_date, :legs
+
+      def self.parse(doc)
+        trip                  = Trip.new
+        trip.origin           = doc.attributes['origin']
+        trip.destination      = doc.attributes['destination']
+        trip.fare             = doc.attributes['fare'].to_f
+        trip.origin_date      = Date.parse(doc.attributes['origtimedate'])
+        trip.destination_date = Date.parse(doc.attributes['desttimedate'])
+        trip.origin_time      = Time.parse("#{doc.attributes['origtimedate']} #{doc.attributes['origtimemin']}")
+        trip.destination_time = Time.parse("#{doc.attributes['desttimedate']} #{doc.attributes['desttimemin']}")
+        trip.legs             = (doc/:leg).map{|leg| Leg.parse(leg)}
+
+        trip
+      end
+    end
+
+    class Leg
+      attr_accessor :order, :transfer_code, :origin, :destination,
+        :origin_time, :origin_date, :destination_time, :destination_date,
+        :line, :bike_flag, :train_head_station
+
+      def self.parse(doc)
+        leg                     = Leg.new
+        leg.order               = doc.attributes['order'].to_i
+        leg.transfer_code       = doc.attributes['transfercode']
+        leg.origin              = doc.attributes['origin']
+        leg.destination         = doc.attributes['destination']
+        leg.origin_date         = Date.parse(doc.attributes['origtimedate'])
+        leg.destination_date    = Date.parse(doc.attributes['desttimedate'])
+        leg.origin_time         = Time.parse("#{doc.attributes['origtimedate']} #{doc.attributes['origtimemin']}")
+        leg.destination_time    = Time.parse("#{doc.attributes['desttimedate']} #{doc.attributes['desttimemin']}")
+        leg.line                = doc.attributes['line']
+        leg.bike_flag           = doc.attributes['bikeflag'] == '1'
+        leg.train_head_station  = doc.attributes['trainheadstation']
+
+        leg
+      end
+    end
+
+    def self.fare(orig, dest, options={})
+      Fare.new(orig, dest, options).fare
+    end
+
+    class Fare
+      attr_accessor :origin, :destination, :date, :schedule_number, :fare
+
+      def initialize(orig, dest, options={})
+        self.origin = orig
+        self.destination = dest
+        load_options(options)
+
+        download_options = {
+          :action => 'sched',
+          :cmd    => 'fare',
+          :orig   => origin,
+          :dest   => destination,
+          :date   => date,
+          :sched  => schedule_number,
+        }
+
+        xml = Util.download(download_options)
+        data = Hpricot(xml)
+
+        self.schedule_number  = (data/:sched_num).inner_text.to_i
+        self.fare             = (data/:fare).inner_text.to_f
+      end
+
+      private
+      def load_options(options)
+        self.date             = options.delete(:date)
+        self.schedule_number  = options.delete(:schedule_number)
+
+        Util.validate_date(date)
+      end
+    end
+
+    def self.holidays
+      download_options = {
+        :action => 'sched',
+        :cmd    => 'holiday',
+      }
+
+      xml = Util.download(download_options)
+      data = Hpricot(xml)
+
+      (data/:holiday).map{|holiday|HolidayData.parse(holiday)}
+    end
+
+    class HolidayData
+      attr_accessor :name, :date, :schedule_type
+
+      def self.parse(doc)
+        data                = HolidayData.new
+        data.name           = (doc/:name).inner_text
+        data.date           = Date.parse((doc/:date).inner_text)
+        data.schedule_type  = (doc/:schedule_type).inner_text
+
+        data
+      end
+    end
+
+    class RouteSchedule
+      attr_accessor :route_number, :schedule_number, :date, :legend, :trains
+
+      def initialize(route_num, options={})
+        self.route_number = route_num
+        load_options(options)
+
+        download_options = {
+          :action => 'sched',
+          :cmd    => 'routesched',
+          :route  => route_number,
+          :sched  => schedule_number,
+          :date   => date,
+          :l      => legend,
+        }
+
+        xml = Util.download(download_options)
+        data = Hpricot(xml)
+
+        self.date             = Date.parse((data/:date).inner_text)
+        self.schedule_number  = (data/:sched_num).inner_text.to_i
+        self.trains           = (data/:train).map{|train| TrainSchedule.parse(train, date)}
+        self.legend           = (data/:legend).inner_text
+      end
+
+      private
+      def load_options(options)
+        self.date             = options.delete(:date)
+        self.schedule_number  = options.delete(:schedule_number)
+        self.legend           = options.delete(:legend)
+        self.date             = options.delete(:date)
+
+        Util.validate_date(date)
+      end
+    end
+
+    class TrainSchedule
+      attr_accessor :stops, :index
+
+      def self.parse(doc, date)
+        schedule        = TrainSchedule.new
+        schedule.index  = doc.attributes['index'].to_i
+        schedule.stops  = (doc/:stop).map{|stop| Stop.parse(stop, date)}
+
+        schedule
+      end
+    end
+
+    class Stop
+      attr_accessor :station, :origin_time, :bike_flag
+
+      def self.parse(doc, date)
+        stop              = Stop.new
+        stop.station      = doc.attributes['station']
+        stop.origin_time  = Time.parse("#{date.to_s} #{doc.attributes['origtime']}")
+        stop.bike_flag    = doc.attributes['bikeflag'] == '1'
+
+        stop
+      end
+    end
+
+    def self.schedules
+      download_options = {
+        :action => 'sched',
+        :cmd    => 'scheds',
+      }
+
+      xml = Util.download(download_options)
+      data = Hpricot(xml)
+
+      (data/:schedule).map{|schedule| Schedule.parse(schedule)}.sort
+    end
+
+    class Schedule
+      attr_accessor :schedule_id, :effective_date
+
+      def self.parse(doc)
+        schedule                = Schedule.new
+        schedule.schedule_id    = doc.attributes['id'].to_i
+        schedule.effective_date = Time.parse(doc.attributes['effectivedate'])
+
+        schedule
+      end
+
+      def <=> other
+        self.schedule_id <=> other.schedule_id
+      end
+    end
+
+    def self.special_schedules(print_legend=false)
+      download_options = {
+        :action => 'sched',
+        :cmd    => 'special',
+        :l      => print_legend ? '1' : '0',
+      }
+
+      xml = Util.download(download_options)
+      data = Hpricot(xml)
+
+      puts (data/:legend).inner_text if print_legend
+
+      (data/:special_schedule).map{|special| SpecialSchedule.parse(special)}
+    end
+
+    class SpecialSchedule
+      attr_accessor :start_date, :end_date, :start_time, :end_time,
+        :text, :link, :origin, :destination, :day_of_week, :routes_affected
+
+      def self.parse(doc)
+        schedule                  = SpecialSchedule.new
+        schedule.start_date       = Date.parse((doc/:start_date).inner_text)
+        schedule.end_date         = Date.parse((doc/:end_date).inner_text)
+        schedule.start_time       = Time.parse("#{schedule.start_date.to_s} #{(doc/:start_time).inner_text}")
+        schedule.end_time         = Time.parse("#{schedule.end_date.to_s} #{(doc/:end_time).inner_text}")
+        schedule.text             = (doc/:text).inner_text
+        schedule.link             = (doc/:link).inner_text
+        schedule.origin           = (doc/:orig).inner_text
+        schedule.destination      = (doc/:dest).inner_text
+        schedule.day_of_week      = (doc/:day_of_week).inner_text.split(',').map(&:to_i)
+        schedule.routes_affected  = (doc/:routes_affected).inner_text.split(',')
+
+        schedule
+      end
+    end
+
+    class StationSchedule
+      attr_accessor :origin, :date, :schedule_number, :name, :abbreviation, :schedules, :legend
+
+      def initialize(origin, options={})
+        load_options(options)
+
+        download_options = {
+          :action => 'sched',
+          :cmd    => 'stnsched',
+          :orig   => origin,
+          :date   => date,
+          :l      => legend,
+        }
+
+        xml = Util.download(download_options)
+        data = Hpricot(xml)
+
+        self.date             = Date.parse((data/:date).inner_text)
+        self.schedule_number  = (data/:sched_num).inner_text.to_i
+        self.name             = (data/:name).inner_text
+        self.abbreviation     = (data/:abbr).inner_text
+        self.legend           = (data/:legend).inner_text
+        self.schedules        = (data/:station/:item).map{|line| StationLine.parse(line, date)}
+      end
+
+      private
+      def load_options(options)
+        self.date   = options.delete(:date)
+        self.legend = options.delete(:legend)
+
+        Util.validate_date(date)
+      end
+    end
+
+    # TODO: DRY with Leg?
+    class StationLine
+
+      attr_accessor :name, :train_head_station, :origin_time, :destination_time, :index, :bike_flag
+      def self.parse(doc, date)
+        line                    = StationLine.new
+        line.name               = doc.attributes['line']
+        line.train_head_station = doc.attributes['trainheadstation']
+        line.origin_time        = Time.parse("#{date} #{doc.attributes['origtime']}")
+        line.destination_time   = Time.parse("#{date} #{doc.attributes['desttime']}")
+        line.index              = doc.attributes['trainidx'].to_i
+        line.bike_flag          = doc.attributes['bikeflag'] == '1'
+
+        line
+      end
+    end
+
+  end
+end

data/lib/bort/station.rb

@@ -0,0 +1,106 @@
+module Bort
+  module Station
+    class Station
+      attr_accessor :abbreviation, :destinations,
+        :north_platforms, :north_routes, :south_platforms, :south_routes, :platform_info,
+        :geo, :address, :city, :county, :state, :zip, :cross_street,
+        :bike_flag, :bike_station_flag, :bike_station_text,
+        :parking, :parking_flag, :transit_info, :car_share, :entering, :exiting,
+        :attraction, :shopping, :food, :intro, :locker_flag, :lockers, :fill_time, :link
+
+      def self.parse(doc)
+        station = Station.new
+        station.abbreviation      = (doc/:abbr).inner_text
+        station.destinations      = (doc/:destinations).inner_text
+
+        station.north_routes      = (doc/:north_routes/:route).map(&:inner_text)
+        station.south_routes      = (doc/:south_routes/:route).map(&:inner_text)
+        station.north_platforms   = (doc/:north_platforms/:platform).map(&:inner_text).map(&:to_i)
+        station.south_platforms   = (doc/:south_platforms/:platform).map(&:inner_text).map(&:to_i)
+        station.platform_info     = (doc/:platform_info).inner_text
+
+        latitude                  = (doc/:gtfs_latitude).inner_text
+        longitude                 = (doc/:gtfs_longitude).inner_text
+        station.geo               = [latitude, longitude] if latitude and longitude
+        station.address           = (doc/:address).inner_text
+        station.city              = (doc/:city).inner_text
+        station.county            = (doc/:county).inner_text
+        station.state             = (doc/:state).inner_text
+        station.zip               = (doc/:zipcode).inner_text
+        station.cross_street      = (doc/:cross_street).inner_text
+
+        station.bike_flag         = parse_flag(doc.attributes['bike_flag'])
+        station.bike_station_flag = parse_flag(doc.attributes['bike_station_flag'])
+        station.bike_station_text = (doc/:bike_station_text).inner_text
+        station.parking           = (doc/:parking).inner_text
+        station.parking_flag      = parse_flag(doc.attributes['parking_flag'])
+        station.transit_info      = (doc/:transit_info).inner_text
+        station.car_share         = (doc/:car_share).inner_text
+        station.entering          = (doc/:entering).inner_text
+        station.exiting           = (doc/:exiting).inner_text
+
+        station.attraction        = (doc/:attraction).inner_text
+        station.shopping          = (doc/:shopping).inner_text
+        station.food              = (doc/:food).inner_text
+        station.intro             = (doc/:intro).inner_text
+        station.locker_flag       = parse_flag(doc.attributes['locker_flag'])
+        station.lockers           = (doc/:lockers).inner_text
+        station.fill_time         = (doc/:fill_time).inner_text
+        station.link              = (doc/:link).inner_text
+
+        station
+      end
+
+      def self.parse_flag(flag)
+        case flag
+        when '1' then true
+        when '0' then false
+        else nil
+        end
+      end
+    end
+
+    def self.access_info(station, print_legend=false)
+
+      download_options = {
+        :action => 'stn',
+        :cmd => 'stnaccess',
+        :orig => station,
+        :l => print_legend ? '1' : '0',
+      }
+
+      xml = Util.download(download_options)
+      data = Hpricot(xml)
+
+      puts (data/:legend).inner_text if print_legend
+      Station.parse((data/:station).first)
+    end
+
+    def self.info(abbreviation)
+      download_options = {
+        :action => 'stn',
+        :cmd => 'stninfo',
+        :orig => abbreviation,
+      }
+
+      xml = Util.download(download_options)
+      data = Hpricot(xml)
+
+      Station.parse((data/:station).first)
+    end
+
+    def self.stations
+
+      download_options = {
+        :action => 'stn',
+        :cmd => 'stns',
+      }
+
+      xml = Util.download(download_options)
+      data = Hpricot(xml)
+
+      (data/:station).map{|station| Station.parse(station)}
+    end
+
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: bort
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- hc5duke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Bort makes BART API available in ruby.
+email: hc5duke@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/bort/realtime.rb
+- lib/bort/route.rb
+- lib/bort/schedule.rb
+- lib/bort/station.rb
+- lib/bort.rb
+has_rdoc: true
+homepage: https://github.com/hc5duke/bort
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: BART API ruby wrapper.
+test_files: []
+