cta_redux 0.1.0

data/lib/cta_redux/models/transfer.rb

@@ -0,0 +1,6 @@
+module CTA
+  class Transfer < Sequel::Model
+    many_to_one :from_stop, :class => 'CTA::Stop', :key => :from_stop_id
+    many_to_one :to_stop, :class => 'CTA::Stop', :key => :to_stop_id
+  end
+end

data/lib/cta_redux/models/trip.rb

@@ -0,0 +1,64 @@
+module CTA
+  class Trip < Sequel::Model
+    L_ROUTES = ["Brn", "G", "Pink", "P", "Org", "Red", "Blue", "Y"]
+    BUS_ROUTES = CTA::Trip.exclude(:route_id => L_ROUTES).select_map(:route_id).uniq
+    plugin :single_table_inheritance,
+           :route_id,
+           :model_map => proc { |v|
+             if L_ROUTES.include?(v)
+               'CTA::Train'
+             else
+               'CTA::Bus'
+             end
+           },
+           :key_map => proc { |klass|
+             if klass.name == 'CTA::Train'
+               L_ROUTES
+             else
+               BUS_ROUTES
+             end
+           }
+
+    set_primary_key :trip_id
+
+    many_to_one :calendar, :key => :service_id
+    one_to_many :stop_times, :key => :trip_id
+
+    many_to_one :route, :key => :route_id
+
+    many_to_many :stops, :left_key => :trip_id, :right_key => :stop_id, :join_table => :stop_times
+
+    # DRAGONS
+    # The CTA doesn't exactly honor the GTFS spec (nor do they return GTFS trip_ids
+    # in the API, grr). They specify multiple entries of # (schd_trip_id, block_id, service_id)
+    # so the only way to know which trip_id to pick is to join against stop_times and
+    # calendar dates, and # find out which run (according to stop_times) is happening *right now*.
+    # Of course, this will break if the train is delayed more the total time
+    # it takes to complete the run... so a delayed train will start to disappear
+    # as it progresses through the run. We allow for a 'fuzz factor' to account
+    # for this...
+    def self.find_active_run(run, timestamp, fuzz = false)
+      if self.to_s == "CTA::Train" # This is admittedly hacky.
+        join_str = "WHERE t.schd_trip_id = 'R#{run}'"
+      else
+        join_str = "WHERE t.route_id = '#{run}'"
+      end
+      d = timestamp.is_a?(DateTime) ? timestamp : DateTime.parse(timestamp)
+      wday = d.strftime("%A").downcase
+      end_ts = (fuzz ? (d.to_time + (60 * 60 * 6) - (90 * 60)) : d).strftime("%H:%M:%S")
+      Trip.with_sql(<<-SQL)
+        SELECT t.*
+        FROM trips t
+          JOIN stop_times st ON t.trip_id = st.trip_id
+          JOIN calendar   c  ON t.service_id = c.service_id
+        #{join_str}
+          AND c.start_date <= '#{d.to_s}'
+          AND c.end_date   >= '#{d.to_s}'
+          AND c.#{wday}
+        GROUP BY t.trip_id, st.departure_time
+        HAVING  MAX(st.departure_time) >= '#{end_ts}'
+      SQL
+    end
+
+  end
+end

data/lib/cta_redux/train_tracker.rb

@@ -0,0 +1,103 @@
+module CTA
+  class TrainTracker
+    def self.connection
+      raise "You need to set a developer key first. Try CTA::TrainTracker.key = 'foo'." unless @key
+
+      @connection ||= Faraday.new do |faraday|
+        faraday.url_prefix = 'http://lapi.transitchicago.com/api/1.0/'
+        faraday.params = { :key => @key }
+
+        faraday.use CTA::TrainTracker::Parser, !!@debug
+        faraday.response :caching, SimpleCache.new(Hash.new)
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def self.arrivals!(options={})
+      allowed_keys = [:route, :parent_station, :station, :limit]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal option!"
+      end
+
+      has_map  = options.has_key?(:parent_station)
+      has_stop = options.has_key?(:station)
+
+      route = Array.wrap(options[:route]).flatten.compact.uniq
+      map   = Array.wrap(options[:parent_station]).flatten.compact.uniq
+      stop  = Array.wrap(options[:station]).flatten.compact.uniq
+      limit = Array.wrap(options[:limit]).flatten.compact.uniq.first.to_i if options[:limit]
+
+      if route.size > 1
+        raise "No more than 1 route may be specified!"
+      end
+
+      if map.size > 1 || stop.size > 1
+        raise "No more than 1 station or parent_station may be specified!"
+      end
+
+      if !(has_map || has_stop)
+        raise "You must specify a station or a parent_station! Try arrivals(:station => 30280..."
+      end
+
+      params = {}
+      params.merge!({ :mapid => map.first }) if options[:parent_station]
+      params.merge!({ :stpid => stop.first }) if options[:station]
+      params.merge!({ :max => limit }) if options[:limit]
+      params.merge!({ :rt => route.first }) if route.any?
+
+      connection.get('ttarrivals.aspx', params)
+    end
+
+    def self.predictions!(options={})
+      self.arrivals!(options)
+    end
+
+    def self.follow!(options={})
+      raise "Must specify a run! Try follow(:run => 914)..." unless options.has_key?(:run)
+
+      runs = Array.wrap(options[:run]).flatten.compact.uniq
+
+      if runs.size > 1
+        raise "Only one run may be specified!"
+      end
+
+      connection.get('ttfollow.aspx', { :runnumber => runs.first })
+    end
+
+    def self.locations!(options={})
+      unless options.has_key?(:routes)
+        raise "Must specify at least one route! (Try locations(:routes => [:red, :blue]) )"
+      end
+
+      rt = Array.wrap(options[:routes]).flatten.compact.map { |r| (CTA::Train::FRIENDLY_L_ROUTES[r] || r).to_s }
+
+      if rt.size > 8
+        raise "No more than 8 routes may be specified!"
+      end
+
+      connection.get('ttpositions.aspx', { :rt => rt.join(',') })
+    end
+
+    def self.positions!(options={})
+      self.locations!(options)
+    end
+
+    def self.key
+      @key
+    end
+
+    def self.key=(key)
+      @key = key
+      @connection = nil
+    end
+
+    def self.debug
+      !!@debug
+    end
+
+    def self.debug=(debug)
+      @debug = debug
+      @connection = nil
+    end
+  end
+end

data/lib/cta_redux/version.rb

@@ -0,0 +1,3 @@
+module CTA
+  VERSION = "0.1.0"
+end

data/lib/cta_redux.rb

@@ -0,0 +1,50 @@
+require "cta_redux/version"
+require "sequel"
+require "sqlite3"
+require "faraday"
+require "faraday_middleware"
+require "multi_xml"
+require "zlib"
+
+module CTA
+  base_path = File.expand_path("..", __FILE__)
+  data_dir = File.join(File.expand_path("../..", __FILE__), 'data')
+  Dir.glob("#{base_path}/cta_redux/faraday_middleware/*") { |lib| require lib }
+  Dir.glob("#{base_path}/cta_redux/api/*") { |lib| require lib }
+  require "#{base_path}/cta_redux/train_tracker.rb"
+  require "#{base_path}/cta_redux/bus_tracker.rb"
+  require "#{base_path}/cta_redux/customer_alerts.rb"
+
+  db_filename = File.join(data_dir, 'cta-gtfs.db')
+
+  # First run
+  if !File.exists?(db_filename)
+    dbf = File.open(db_filename, 'wb')
+    Zlib::GzipReader.open("#{db_filename}.gz") do |gz|
+      dbf.puts gz.read
+    end
+    dbf.close
+  end
+
+  DB = Sequel.sqlite(:database => db_filename, :readonly => true)
+
+  Dir.glob("#{base_path}/cta_redux/models/*") do |lib|
+    next if lib =~ /train/ || lib =~ /bus/
+    require lib
+  end
+
+  require "#{base_path}/cta_redux/models/train.rb"
+  require "#{base_path}/cta_redux/models/bus.rb"
+end
+
+class Array
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/script/gtfs_to_sqlite.rb

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+
+require 'sqlite3'
+require 'csv'
+require 'date'
+
+KNOWN_COLUMN_TYPES = {
+  "calendar" => {
+    "service_id" => "INTEGER",
+    "monday" => "BOOLEAN",
+    "tuesday" => "BOOLEAN",
+    "wednesday" => "BOOLEAN",
+    "thursday" => "BOOLEAN",
+    "friday" => "BOOLEAN",
+    "saturday" => "BOOLEAN",
+    "sunday" => "BOOLEAN",
+    "start_date" => "DATE",
+    "end_date" => "DATE"
+  },
+  "routes" => {
+    "route_type" => "INTEGER"
+  },
+  "shapes" => {
+    "shape_id" => "INTEGER",
+    "shape_pt_lat" => "FLOAT",
+    "shape_pt_lon" => "FLOAT",
+    "shape_pt_sequence" => "INTEGER",
+    "shape_dist_traveled" => "INTEGER"
+  },
+  "stop_times" => {
+    "trip_id" => "INTEGER",
+    # This would be nice to store as a native SQL type,
+    # but ruby really has no notion of a time object w/o
+    # an associated date, because ruby stores time as epoch.
+    # so, in order to prevent ruby from attaching dates to our
+    # stop_times, we just let it store naturally as a string.
+    #"arrival_time" => "TIME",
+    #"departure_time" => "TIME",
+    "stop_id" => "INTEGER",
+    "stop_sequence" => "INTEGER",
+    "shape_dist_traveled" => "INTEGER",
+    "pickup_type" => "INTEGER"
+  },
+  "stops" => {
+    "stop_id" => "INTEGER",
+    "stop_code" => "INTEGER",
+    "stop_lat" => "FLOAT",
+    "stop_lon" => "FLOAT",
+    "location_type" => "INTEGER",
+    "parent_station" => "INTEGER",
+    "wheelchair_boarding" => "BOOLEAN"
+  },
+  "transfers" => {
+    "from_stop_id" => "INTEGER",
+    "to_stop_id" => "INTEGER",
+    "transfer_type" => "INTEGER"
+  },
+  "trips" => {
+    "service_id" => "INTEGER",
+    "trip_id" => "INTEGER",
+    "direction_id" => "INTEGER",
+    "block_id" => "INTEGER",
+    "shape_id" => "INTEGER",
+    "wheelchair_accessible" => "BOOLEAN"
+  }
+}
+
+def usage
+  "Usage: gtfs_to_sqlite.rb input_file output_db"
+end
+
+abort usage unless ARGV.size == 2
+
+base_path = File.expand_path("..", __FILE__)
+input_file = File.join(base_path, ARGV[0])
+output_db  = File.join(base_path, ARGV[1])
+
+table = input_file.split(File::SEPARATOR).last.gsub(".txt", "")
+
+puts input_file
+abort usage unless File.exists?(input_file)
+
+db = SQLite3::Database.new(output_db)
+
+first_row = true
+n = 0
+headers = nil
+
+print "Loading"
+CSV.foreach(input_file, :headers => true) do |row|
+  if n % 100 == 0
+    print "."
+  end
+  if n % 1000 == 0
+    print n
+  end
+
+  if first_row
+    columns = row.headers.map do |r|
+      if KNOWN_COLUMN_TYPES[table] && KNOWN_COLUMN_TYPES[table][r]
+        col = "#{r} #{KNOWN_COLUMN_TYPES[table][r]}"
+      else
+        col = r
+      end
+    end
+    stmt = "CREATE TABLE #{table} (#{columns.join(',')})"
+    db.execute(stmt)
+    first_row = false
+    headers = row.headers
+  end
+
+  stmt = "INSERT INTO #{table} (#{row.headers.join(',')}) VALUES (#{row.headers.map { '?' }.join(',')})"
+  if row.headers.any? { |h| h =~ /date/ }
+    fields = []
+    row.headers.each_with_index do |header, index|
+      if header =~ /date/
+        fields << DateTime.parse(row.fields[index]).to_s
+      else
+        fields << row.fields[index]
+      end
+    end
+  else
+    fields = row.fields
+  end
+  db.execute(stmt, fields)
+  n +=1
+end
+
+puts "\ndone"
+puts "Creating indices..."
+if headers
+  headers.each do |h|
+    if h =~ /_id/
+      db.execute("CREATE INDEX #{table}_#{h}_index ON #{table} (#{h})")
+    end
+  end
+end

data/spec/bus_tracker_spec.rb

@@ -0,0 +1,149 @@
+base_path = File.expand_path(File.dirname(__FILE__))
+data_path = File.expand_path(File.join(base_path, 'stubs'))
+
+require File.join(base_path, "..", "lib", "cta_redux")
+
+RSpec.describe CTA::BusTracker do
+  stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+    stub.get('/bustime/api/v2/gettime?key=') { |env| [200, {}, File.read(File.join(data_path, 'gettime_response.xml'))] }
+    stub.get('/bustime/api/v2/getvehicles?key=&rt=22') { |env| [200, {}, File.read(File.join(data_path, 'getvehicles_rt22_response.xml'))] }
+    stub.get('/bustime/api/v2/getvehicles?key=&vid=4394') { |env| [200, {}, File.read(File.join(data_path, 'getvehicles_vid4394_response.xml'))] }
+    stub.get('/bustime/api/v2/getroutes?key=') { |env| [200, {}, File.read(File.join(data_path, 'getroutes_response.xml'))] }
+    stub.get('/bustime/api/v2/getdirections?key=&rt=22') { |env| [200, {}, File.read(File.join(data_path, 'getdirections_response.xml'))] }
+    stub.get('/bustime/api/v2/getstops?key=&rt=22&dir=Northbound') { |env| [200, {}, File.read(File.join(data_path, 'getstops_response.xml'))] }
+    stub.get('/bustime/api/v2/getpatterns?key=&rt=22') { |env| [200, {}, File.read(File.join(data_path, 'getpatterns_rt22_response.xml'))] }
+    stub.get('/bustime/api/v2/getpredictions?key=&rt=22&stpid=15895&top=&vid=') { |env| [200, {}, File.read(File.join(data_path, 'getpredictions_rt22stpid15895_response.xml'))] }
+    stub.get('/bustime/api/v2/getpredictions?key=&vid=4361') { |env| [200, {}, File.read(File.join(data_path, 'getpredictions_vid4361_response.xml'))] }
+    stub.get('/bustime/api/v2/getservicebulletins?key=&rt=8') { |env| [200, {}, File.read(File.join(data_path, 'getservicebulletins_rt8_response.xml'))] }
+  end
+
+  CTA::BusTracker.key = ''
+  CTA::BusTracker.connection.instance_variable_get(:@builder).delete(Faraday::Adapter::NetHttp)
+  CTA::BusTracker.connection.adapter :test, stubs
+
+  describe "time!" do
+    result = CTA::BusTracker.time!
+
+    it "returns an error code" do
+      expect(result.error).to  be_instance_of(CTA::API::Error)
+      expect(result.error.code).to eq(0)
+      expect(result.error.message).to eq("OK")
+    end
+
+    it "returns a time" do
+      expect(result.timestamp).to be_instance_of(DateTime)
+      expect(result.timestamp.to_s).to eq("2015-02-14T11:31:13+00:00")
+    end
+  end
+
+  describe "vehicles!" do
+    it "returns vehicles for route 22" do
+      result = CTA::BusTracker.vehicles!(:routes => 22)
+
+      expect(result).to be_instance_of(CTA::BusTracker::VehiclesResponse)
+      expect(result.vehicles.size).to eq(13)
+
+      expect(result.vehicles.first.route).to be_instance_of(CTA::Route)
+      expect(result.vehicles.first.route.route_id).to eq("22")
+      expect(result.vehicles.first.vehicle_id).to eq(4394)
+      expect(result.vehicles.first.pattern_distance).to eq(115)
+    end
+
+    it "returns information about one vehicle" do
+      result = CTA::BusTracker.vehicles!(:vehicles => 4394)
+
+      expect(result).to be_instance_of(CTA::BusTracker::VehiclesResponse)
+      expect(result.vehicles.size).to eq(1)
+      expect(result.vehicles.first.route).to be_instance_of(CTA::Route)
+      expect(result.vehicles.first.route.route_id).to eq("22")
+      expect(result.vehicles.first.vehicle_id).to eq(4394)
+      expect(result.vehicles.first.heading).to eq(359)
+    end
+  end
+
+  describe "routes!" do
+    it "returns information about all routes" do
+      result = CTA::BusTracker.routes!
+
+      expect(result).to be_instance_of(CTA::BusTracker::RoutesResponse)
+      expect(result.routes.size).to eq(127)
+      expect(result.routes.first.route_id).to eq("1")
+    end
+  end
+
+  describe "directions!" do
+    it "returns two directions for route 22" do
+      result = CTA::BusTracker.directions!(:route => 22)
+
+      expect(result).to be_instance_of(CTA::BusTracker::DirectionsResponse)
+      expect(result.directions.size).to eq(2)
+      expect(result.directions.first.direction).to eq("Northbound")
+    end
+  end
+
+  describe "stops!" do
+    it "returns information about Northbound route 22 stops" do
+      result = CTA::BusTracker.stops!(:route => 22, :direction => :northbound)
+
+      expect(result).to be_instance_of(CTA::BusTracker::StopsResponse)
+      expect(result.stops.size).to eq(86)
+      expect(result.stops.first).to be_instance_of(CTA::Stop)
+      expect(result.stops.first.stop_name).to eq("Clark & Addison")
+    end
+  end
+
+  describe "patterns!" do
+    it "returns information about patterns for route 22" do
+      result = CTA::BusTracker.patterns!(:route => 22)
+
+      expect(result).to be_instance_of(CTA::BusTracker::PatternsResponse)
+      expect(result.patterns.first.direction).to be_instance_of(CTA::BusTracker::Direction)
+      expect(result.patterns.first.id).to eq(3936)
+      expect(result.patterns.first.points.size).to eq(124)
+      expect(result.patterns.first.points.first.sequence).to eq(1)
+      expect(result.patterns.first.points.first.stop).to be_instance_of(CTA::Stop)
+      expect(result.patterns.first.points.first.stop.stop_id).to eq(14096)
+      expect(result.patterns.first.points[1].lat).to eq(42.019043088282)
+      expect(result.patterns.first.points[1].type).to eq(:waypoint)
+      expect(result.patterns.first.points[1].sequence).to eq(2)
+    end
+  end
+
+  describe "predictions!" do
+    it "returns predictions for route 22 stop 15898" do
+      result = CTA::BusTracker.predictions!(:routes => 22, :stops => 15895)
+
+      expect(result).to be_instance_of(CTA::BusTracker::PredictionsResponse)
+      expect(result.vehicles.size).to eq(2)
+      expect(result.vehicles.first.route.route_id).to eq("22")
+      expect(result.predictions.size).to eq(2)
+      expect(result.predictions.first.type).to eq("D")
+      expect(result.predictions.first.minutes).to eq(5)
+      expect(result.predictions.first.arrival_time.to_s).to eq("2015-02-14T12:25:00+00:00")
+      expect(result.predictions.first.delayed).to eq(false)
+    end
+
+    it "returns predictions for vehicle 4361" do
+      result = CTA::BusTracker.predictions!(:vehicles => 4361)
+
+      expect(result).to be_instance_of(CTA::BusTracker::PredictionsResponse)
+      expect(result.vehicles.size).to eq(30)
+      expect(result.vehicles.first.route.route_id).to eq("22")
+      expect(result.predictions.size).to eq(30)
+      expect(result.predictions.first.type).to eq("A")
+      expect(result.predictions.first.minutes).to eq(2)
+      expect(result.predictions.first.arrival_time.to_s).to eq("2015-02-14T12:38:00+00:00")
+      expect(result.predictions.first.delayed).to eq(false)
+    end
+  end
+
+  it "returns bulletins for route 8" do
+    result = CTA::BusTracker.bulletins!(:routes => 8)
+
+    expect(result).to be_instance_of(CTA::BusTracker::ServiceBulletinsResponse)
+    expect(result.bulletins.size).to eq(6)
+    expect(result.bulletins.first.subject).to eq("#8 Halsted reroute Halsted/35th")
+    expect(result.bulletins.first.affected_services.size).to eq(1)
+    expect(result.bulletins.first.affected_services.first.route.route_id).to eq("8")
+  end
+end

data/spec/customer_alerts_spec.rb

@@ -0,0 +1,48 @@
+base_path = File.expand_path(File.dirname(__FILE__))
+data_path = File.expand_path(File.join(base_path, 'stubs'))
+
+require File.join(base_path, "..", "lib", "cta_redux")
+
+RSpec.describe CTA::TrainTracker do
+  stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+    stub.get('/api/1.0/routes.aspx?type=&routeid=&stationid=') { |env| [200, {}, File.read(File.join(data_path, 'routes_response.xml'))] }
+    stub.get('/api/1.0/routes.aspx?type=&routeid=8&stationid=') { |env| [200, {}, File.read(File.join(data_path, 'route_status8_response.xml'))] }
+    stub.get('/api/1.0/alerts.aspx') { |env| [200, {}, File.read(File.join(data_path, 'alerts_response.xml'))] }
+  end
+
+  CTA::CustomerAlerts.connection.instance_variable_get(:@builder).delete(Faraday::Adapter::NetHttp)
+  CTA::CustomerAlerts.connection.adapter :test, stubs
+
+  describe "status!" do
+    it "returns all status information" do
+      response = CTA::CustomerAlerts.status!
+
+      expect(response).to be_instance_of(CTA::CustomerAlerts::RouteStatusResponse)
+      expect(response.routes.size).to eq(140)
+      expect(response.routes.first.route.route_id).to eq("Red")
+      expect(response.routes.first.status).to eq("Planned Work w/Reroute")
+    end
+
+    it "returns status information for one route" do
+      response = CTA::CustomerAlerts.status!(:routes => 8)
+
+      expect(response).to be_instance_of(CTA::CustomerAlerts::RouteStatusResponse)
+      expect(response.routes.size).to eq(1)
+      expect(response.routes.first.route.route_id).to eq("8")
+      expect(response.routes.first.status).to eq("Bus Stop Relocation")
+    end
+  end
+
+  describe "alerts!" do
+    it "returns all alerts" do
+      response = CTA::CustomerAlerts.alerts!
+
+      expect(response).to be_instance_of(CTA::CustomerAlerts::AlertsResponse)
+      expect(response.alerts.size).to eq(44)
+      expect(response.alerts.first.alert_id).to eq(23322)
+      expect(response.alerts.first.category).to eq(:normal)
+      expect(response.alerts.first.major_alert).to eq(false)
+      expect(response.alerts.first.tbd).to eq(true)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 10
+  config.order = :random
+end