cta_redux 0.1.0

data/lib/cta_redux/bus_tracker.rb

@@ -0,0 +1,183 @@
+module CTA
+  class BusTracker
+    def self.connection
+      raise "You need to set a developer key first. Try CTA::BusTracker.key = 'foo'." unless @key
+
+      @connection ||= Faraday.new do |faraday|
+        faraday.url_prefix = 'http://www.ctabustracker.com/bustime/api/v2/'
+        faraday.params = { :key => @key }
+
+        faraday.use CTA::BusTracker::Parser, !!@debug
+        faraday.response :caching, SimpleCache.new(Hash.new)
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def self.time!
+      connection.get('gettime')
+    end
+
+    def self.vehicles!(options={})
+      allowed_keys = [:vehicles, :routes]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal option!"
+      end
+
+      has_vehicle = options.has_key?(:vehicles)
+      has_route   = options.has_key?(:routes)
+
+      if !(has_vehicle || has_route) || (has_vehicle && has_route)
+        raise "Must specify either vehicle OR route options! Try vehicles(:routes => 37)"
+      end
+
+      vehicles = Array.wrap(options[:vehicles]).flatten.compact.uniq.join(',')
+      routes   = Array.wrap(options[:routes]).flatten.compact.uniq.join(',')
+
+      connection.get('getvehicles', { :rt => routes, :vid => vehicles })
+    end
+
+    def self.routes!
+      connection.get('getroutes')
+    end
+
+    def self.directions!(options={})
+      allowed_keys = [:route]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal option!"
+      end
+
+      unless options.has_key?(:route)
+        raise "Must specify a route! (Try directions(:route => 914) )"
+      end
+
+      routes = Array.wrap(options[:route]).flatten.compact.uniq
+
+      if routes.size > 1
+        raise "Only one route may be specified!"
+      end
+      connection.get('getdirections', { :rt => routes.first })
+    end
+
+    def self.stops!(options={})
+      allowed_keys = [:route, :direction]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal option!"
+      end
+
+      has_route     = options.has_key?(:route)
+      has_direction = options.has_key?(:direction)
+
+      if !(has_direction && has_route)
+        raise "Must specify both direction and route options! Try stops(:route => 37, :direction => :northbound)"
+      end
+
+      routes     = Array.wrap(options[:route]).flatten.compact.uniq
+      directions = Array.wrap(options[:direction]).flatten.compact.uniq
+      if routes.size > 1
+        raise "Only one route may be specified!"
+      end
+
+      if directions.size > 1
+        raise "Only one direction may be specified!"
+      end
+
+      connection.get('getstops', { :rt => routes.first, :dir => directions.first.to_s.capitalize })
+    end
+
+    def self.patterns!(options={})
+      allowed_keys = [:route, :patterns]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal option!"
+      end
+
+      has_route   = options.has_key?(:route)
+      has_pattern = options.has_key?(:patterns)
+
+      if !(has_pattern || has_route) || (has_pattern && has_route)
+        raise "Must specify a pattern OR route option! Try patterns(:route => 37)"
+      end
+
+      routes   = Array.wrap(options[:route]).flatten.compact.uniq
+      patterns = Array.wrap(options[:patterns]).flatten.compact.uniq.join(',')
+      if routes.size > 1
+        raise "Only one route may be specified!"
+      end
+
+      connection.get('getpatterns', { :pid => patterns, :rt => routes.first })
+    end
+
+    def self.predictions!(options={})
+      allowed_keys = [:vehicles, :stops, :routes, :limit]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal option!"
+      end
+
+      has_vehicle = options.has_key?(:vehicles)
+      has_stop    = options.has_key?(:stops)
+
+      if !(has_stop || has_vehicle) || (has_stop && has_vehicle)
+        raise "Must specify a stop (and optionally route), or vehicles! Try predictions(:stops => 6597)"
+      end
+
+      routes   = Array.wrap(options[:routes]).flatten.compact.uniq.join(',')
+      stops    = Array.wrap(options[:stops]).flatten.compact.uniq.join(',')
+      vehicles = Array.wrap(options[:vehicles]).flatten.compact.uniq.join(',')
+      limit    = Array.wrap(options[:limit]).first.to_i if options.has_key?(:limit)
+
+      connection.get('getpredictions', { :rt => routes, :vid => vehicles, :stpid => stops, :top => limit })
+    end
+
+    def self.bulletins!(options={})
+      allowed_keys = [:routes, :directions, :stop]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal option!"
+      end
+
+      has_route = options.has_key?(:routes)
+      has_stop  = options.has_key?(:stop)
+
+      if !(has_route || has_stop)
+        raise "Must provide at least a route or a stop! Try bulletins(:routes => 22)"
+      end
+
+      directions = Array.wrap(options[:direction]).flatten.compact.uniq
+      routes     = Array.wrap(options[:routes]).flatten.compact.uniq
+      stops      = Array.wrap(options[:stop]).flatten.compact.uniq
+
+      if directions.size > 1
+        raise "Only one direction may be specified!"
+      end
+
+      if directions.any? && routes.size != 1
+        raise "Must specify one and only one route when combined with a direction"
+      end
+
+      if (directions.any? || routes.any?) && stops.size > 1
+        raise "Cannot specify more than one stop when combined with a route and direction"
+      end
+
+      routes = routes.join(',')
+      stops = stops.join(',')
+
+      connection.get('getservicebulletins', { :rt => routes, :stpid => stops, :dir => directions.first })
+    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/customer_alerts.rb

@@ -0,0 +1,72 @@
+module CTA
+  class CustomerAlerts
+
+    def self.connection
+      @connection ||= Faraday.new do |faraday|
+        faraday.url_prefix = 'http://www.transitchicago.com/api/1.0/'
+        faraday.use CTA::CustomerAlerts::Parser, !!@debug
+        faraday.response :caching, SimpleCache.new(Hash.new)
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def self.status!(options = {})
+      allowed_keys = [:routes, :stations]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal argument!"
+      end
+
+      routes   = Array.wrap(options[:routes]).flatten.compact.uniq.join(',')
+      stations = Array.wrap(options[:stations]).flatten.compact.uniq
+
+      if stations.size > 1
+        raise "Can only specify one station!"
+      end
+
+      connection.get('routes.aspx', { :type => options[:type], :routeid => routes, :stationid => stations.first })
+    end
+
+    def self.alerts!(options = {})
+      allowed_keys = [:active, :accessibility, :planned, :routes, :station, :recent_days, :before]
+      if options.keys.any? { |k| !allowed_keys.include?(k) }
+        raise "Illegal argument!"
+      end
+
+      params = {}
+      params.merge!({ :activeonly => options[:active] }) if options[:active]
+      params.merge!({ :accessibility => options[:accessiblity] }) if options[:accessibility]
+      params.merge!({ :planned => options[:planned] }) if options[:planned]
+
+      routes = Array.wrap(options[:routes]).flatten.compact.uniq
+      stations = Array.wrap(options[:station]).flatten.compact.uniq
+
+      if stations.size > 1
+        raise "Can only specify one station!"
+      end
+
+      if routes.any? && stations.any?
+        raise "Cannot use route and station together!"
+      end
+
+      if options[:recent_days] && options[:before]
+        raise "Cannot use recent_days and before together!"
+      end
+
+      params.merge!({ :stationid => stations.first }) if stations.any?
+      params.merge!({ :routeid => routes.join(',') }) if routes.any?
+      params.merge!({ :recentdays => options[:recent_days] }) if options[:recent_days]
+      params.merge!({ :bystartdate => options[:before] }) if options[:before]
+
+      connection.get('alerts.aspx', params)
+    end
+
+    def self.debug
+      !!@debug
+    end
+
+    def self.debug=(debug)
+      @debug = debug
+      @connection = nil
+    end
+  end
+end

data/lib/cta_redux/faraday_middleware/bus_tracker_parser.rb

@@ -0,0 +1,46 @@
+module CTA
+  class BusTracker
+    class Parser < Faraday::Response::Middleware
+      def initialize(app, debug)
+        @debug = debug
+        super(app)
+      end
+
+      def call(request_env)
+        api_response = nil
+        @app.call(request_env).on_complete do |response_env|
+          parsed_body = ::MultiXml.parse(response_env.body)
+
+          if has_errors?(parsed_body)
+            api_response = CTA::API::Response.new(parsed_body, response_env.body, @debug)
+          else
+            case response_env.url.to_s
+            when /bustime\/.+\/getvehicles/
+              api_response = VehiclesResponse.new(parsed_body, response_env.body, @debug)
+            when /bustime\/.+\/gettime/
+              api_response = TimeResponse.new(parsed_body, response_env.body, @debug)
+            when /bustime\/.+\/getroutes/
+              api_response = RoutesResponse.new(parsed_body, response_env.body, @debug)
+            when /bustime\/.+\/getdirections/
+              api_response = DirectionsResponse.new(parsed_body, response_env.body, @debug)
+            when /bustime\/.+\/getstops/
+              api_response = StopsResponse.new(parsed_body, response_env.body, @debug)
+            when /bustime\/.+\/getpatterns/
+              api_response = PatternsResponse.new(parsed_body, response_env.body, @debug)
+            when /bustime\/.+\/getpredictions/
+              api_response = PredictionsResponse.new(parsed_body, response_env.body, @debug)
+            when /bustime\/.+\/getservicebulletins/
+              api_response = ServiceBulletinsResponse.new(parsed_body, response_env.body, @debug)
+            end
+          end
+        end
+
+        api_response
+      end
+
+      def has_errors?(parsed_body)
+        !parsed_body.has_key?("bustime_response") || parsed_body["bustime_response"].has_key?("error")
+      end
+    end
+  end
+end

data/lib/cta_redux/faraday_middleware/customer_alerts_parser.rb

@@ -0,0 +1,39 @@
+module CTA
+  class CustomerAlerts
+    class Parser < Faraday::Response::Middleware
+      def initialize(app, debug)
+        @debug = debug
+        super(app)
+      end
+
+      def call(request_env)
+        api_response = nil
+
+        @app.call(request_env).on_complete do |response_env|
+          parsed_body = ::MultiXml.parse(response_env.body)
+
+          if has_errors?(parsed_body)
+            api_response = CTA::API::Response.new(parsed_body, response_env.body, @debug)
+          else
+            case response_env.url.to_s
+            when /routes\.aspx/
+              api_response = RouteStatusResponse.new(parsed_body, response_env.body, @debug)
+            when /alerts\.aspx/
+              api_response = AlertsResponse.new(parsed_body, response_env.body, @debug)
+            end
+          end
+        end
+
+        api_response
+      end
+
+      def has_errors?(parsed_body)
+        if parsed_body["CTARoutes"]
+          Array.wrap(parsed_body["CTARoutes"]["ErrorCode"]).flatten.compact.uniq.first.to_i != 0
+        else
+          Array.wrap(parsed_body["CTAAlerts"]["ErrorCode"]).flatten.compact.uniq.first.to_i != 0
+        end
+      end
+    end
+  end
+end

data/lib/cta_redux/faraday_middleware/simple_cache.rb

@@ -0,0 +1,32 @@
+class SimpleCache
+  def initialize(cache)
+    @cache = cache
+  end
+
+  def fetch(name, options = nil)
+    entry = read(name, options)
+
+    if !entry && block_given?
+    	entry = yield
+    	write(name, entry)
+    elsif !entry
+      entry = read(name, options)
+    end
+
+    entry
+  end
+
+  def read(name, options = nil)
+    entry = @cache[name]
+
+    if entry && entry[:expiration] < Time.now
+      entry = @cache[name] = nil
+    end
+
+    entry ? entry[:value] : entry
+  end
+
+  def write(name, value)
+    @cache[name] = { :expiration => (Time.now + 60), :value => value }
+  end
+end

data/lib/cta_redux/faraday_middleware/train_tracker_parser.rb

@@ -0,0 +1,37 @@
+module CTA
+  class TrainTracker
+    class Parser < Faraday::Response::Middleware
+      def initialize(app, debug)
+        @debug = debug
+        super(app)
+      end
+
+      def call(request_env)
+        api_response = nil
+
+        @app.call(request_env).on_complete do |response_env|
+          parsed_body = ::MultiXml.parse(response_env.body)
+
+          if has_errors?(parsed_body)
+            api_response = CTA::API::Response.new(parsed_body, response_env.body, @debug)
+          else
+            case response_env.url.to_s
+            when /ttarrivals\.aspx/
+              api_response = ArrivalsResponse.new(parsed_body, response_env.body, @debug)
+            when /ttfollow\.aspx/
+              api_response = FollowResponse.new(parsed_body, response_env.body, @debug)
+            when /ttpositions\.aspx/
+              api_response = PositionsResponse.new(parsed_body, response_env.body, @debug)
+            end
+          end
+        end
+
+        api_response
+      end
+
+      def has_errors?(parsed_body)
+        parsed_body["ctatt"]["errCd"] != "0"
+      end
+    end
+  end
+end

data/lib/cta_redux/models/agency.rb

@@ -0,0 +1,4 @@
+module CTA
+  class Agency < Sequel::Model(:agency)
+  end
+end

data/lib/cta_redux/models/bus.rb

@@ -0,0 +1,46 @@
+module CTA
+  class Bus < CTA::Trip
+    def predictions!(options = {})
+      opts = (self.vehicle_id ? { :vehicles => self.vehicle_id } : { :routes => self.route_id })
+      puts opts
+      CTA::BusTracker.predictions!(options.merge(opts))
+    end
+
+    def live!(position, predictions = [])
+      class << self
+        attr_reader :lat, :lon, :vehicle_id, :heading, :pattern_id, :pattern_distance, :route, :delayed, :speed, :predictions
+      end
+
+      @lat = position["lat"].to_f
+      @lon = position["lon"].to_f
+      @heading = position["hdg"].to_i
+      @vehicle_id = position["vid"].to_i
+      @pattern_id = position["pid"].to_i
+      @pattern_distance = position["pdist"].to_i
+      @route = CTA::Route.where(:route_id => position["rt"]).first
+      @delayed = (position["dly"] == "true")
+      @speed = position["spd"].to_i
+
+      @predictions = Array.wrap(predictions).map { |p| Prediction.new(p) }
+    end
+
+    class Prediction
+      attr_reader :type, :stop, :distance, :route, :direction, :destination,
+                  :prediction_generated_at, :arrival_time, :delayed, :minutes, :seconds
+
+      def initialize(data)
+        @type = data["typ"]
+        @stop = CTA::Stop.where(:stop_id => data["stpid"]).first || CTA::Stop.new_from_api_response(data)
+        @distance = data["dstp"].to_i
+        @route = CTA::Route.where(:route_id => data["rt"]).first
+        @direction = CTA::BusTracker::Direction.new(data["rtdir"])
+        @destination = data["des"]
+        @prediction_generated_at = DateTime.parse(data["tmstmp"])
+        @arrival_time = DateTime.parse(data["prdtm"])
+        @seconds = @arrival_time.to_time - @prediction_generated_at.to_time
+        @minutes = (@seconds / 60).ceil
+        @delayed = (data["dly"] == "true")
+      end
+    end
+  end
+end

data/lib/cta_redux/models/calendar.rb

@@ -0,0 +1,7 @@
+module CTA
+  class Calendar < Sequel::Model(:calendar)
+    set_primary_key :service_id
+
+    one_to_many :trips, :key => :service_id
+  end
+end

data/lib/cta_redux/models/route.rb

@@ -0,0 +1,62 @@
+module CTA
+  class Route < Sequel::Model
+    set_primary_key :route_id
+
+    one_to_many :trips, :key => :route_id
+
+    def self.[](*args)
+      potential_route = args.first.downcase.to_sym
+      if CTA::Train::FRIENDLY_L_ROUTES.has_key?(potential_route)
+        super(Array.wrap(CTA::Train::FRIENDLY_L_ROUTES[potential_route].capitalize))
+      else
+        super(args)
+      end
+    end
+
+    def stops
+      # Gosh, I wish SQLite could do "SELECT DISTINCT ON..."
+      CTA::Stop.with_sql(<<-SQL)
+        SELECT s.*
+        FROM stops s
+        WHERE s.stop_id IN (
+          SELECT DISTINCT st.stop_id
+          FROM stop_times st
+            JOIN trips t ON st.trip_id = t.trip_id
+          WHERE t.route_id = '#{self.route_id}'
+        )
+      SQL
+    end
+
+    def live!(vehicles)
+      class << self
+        attr_reader :vehicles
+      end
+
+      @vehicles = vehicles
+    end
+
+    def predictions!(options = {})
+      if CTA::Train::L_ROUTES.keys.include?(self.route_id.downcase)
+        CTA::TrainTracker.predictions!(options.merge({:route => self.route_id.downcase}))
+      else
+        CTA::BusTracker.predictions!(options.merge({:route => self.route_id}))
+      end
+    end
+
+    def locations!(options = {})
+      if CTA::Train::L_ROUTES.keys.include?(self.route_id.downcase)
+        CTA::TrainTracker.locations!(options.merge({:routes => self.route_id.downcase}))
+      else
+        raise "CTA BusTracker has no direct analog of the TrainTracker locations api. Try predictions instead."
+      end
+    end
+
+    def status!
+      CTA::CustomerAlerts.status!(:routes => self.route_id).routes.first
+    end
+
+    def alerts!
+      CTA::CustomerAlerts.alerts!(:route => self.route_id).alerts
+    end
+  end
+end

data/lib/cta_redux/models/shape.rb

@@ -0,0 +1,4 @@
+module CTA
+  class Shape < Sequel::Model
+  end
+end

data/lib/cta_redux/models/stop.rb

@@ -0,0 +1,66 @@
+module CTA
+  class Stop < Sequel::Model
+    set_primary_key :stop_id
+
+    one_to_many :child_stops, :class => self, :key => :parent_station
+    many_to_one :parent_stop, :class => self, :key => :parent_station
+
+    one_to_many :transfers_from, :class => 'CTA::Transfer', :key => :from_stop_id
+    one_to_many :transfers_to, :class => 'CTA::Transfer', :key => :to_stop_id
+
+    many_to_many :trips, :left_key => :stop_id, :right_key => :trip_id, :join_table => :stop_times
+
+    def routes
+      CTA::Route.with_sql(<<-SQL)
+        SELECT r.*
+        FROM routes r
+        WHERE r.route_id IN (
+          SELECT DISTINCT t.route_id
+          FROM stop_times st
+            JOIN trips t ON st.trip_id = t.trip_id
+          WHERE st.stop_id = '#{self.stop_id}'
+        )
+      SQL
+    end
+
+    # Some CTA routes are seasonal, and are missing from the GTFS feed.
+    # However, the API still returns that info. So, we create a dummy CTA::Stop
+    # to fill in the gaps. I've emailed CTA developer support for clarification.
+    def self.new_from_api_response(s)
+      CTA::Stop.unrestrict_primary_key
+      stop = CTA::Stop.new({
+        :stop_id => s["stpid"].to_i,
+        :stop_name => s["stpnm"],
+        :stop_lat => s["lat"].to_f,
+        :stop_lon => s["lon"].to_f,
+        :location_type => 3, # Bus in GTFS-land
+        :stop_desc => "#{s["stpnm"]} (seasonal, generated from API results - missing from GTFS feed)"
+      })
+      CTA::Stop.restrict_primary_key
+
+      stop
+    end
+
+    def stop_type
+      if self.stop_id < 30000
+        :bus
+      elsif self.stop_id < 40000
+        :rail
+      else
+        :parent_station
+      end
+    end
+
+    def predictions!(options = {})
+      if self.stop_type == :bus
+        CTA::BusTracker.predictions!(options.merge({:stops => self.stop_id}))
+      else
+        if self.stop_type == :rail
+          CTA::TrainTracker.predictions!(options.merge({:station => self.stop_id}))
+        else
+          CTA::TrainTracker.predictions!(options.merge({:parent_station => self.stop_id}))
+        end
+      end
+    end
+  end
+end

data/lib/cta_redux/models/stop_time.rb

@@ -0,0 +1,6 @@
+module CTA
+  class StopTime < Sequel::Model
+    many_to_one :trip, :key => :trip_id
+    many_to_one :stop, :key => :stop_id
+  end
+end

data/lib/cta_redux/models/train.rb

@@ -0,0 +1,74 @@
+module CTA
+  class Train < CTA::Trip
+    L_ROUTES = {
+      "red"   => { :name => "Red",
+                   :directions => { "1" => "Howard-bound", "5" => "95th/Dan Ryan-bound" }
+      },
+      "blue"  => { :name => "Blue",
+                   :directions => { "1" => "O'Hare-bound", "5" => "Forest Park-bound" }
+      },
+      "brn"   => { :name => "Brown",
+                   :directions => { "1" => "Kimball-bound", "5" => "Loop-bound" }
+      },
+      "g"     => { :name => "Green",
+                   :directions => { "1" => "Harlem/Lake-bound", "5" => "Ashland/63rd- or Cottage Grove-bound (toward 63rd St destinations)" }
+      },
+      "org"   => { :name => "Orange",
+                   :directions => { "1" => "Loop-bound", "5" => "Midway-bound" }
+      },
+      "p"     => { :name => "Purple",
+                   :directions => { "1" => "Linden-bound", "5" => "Howard- or Loop-bound" }
+      },
+      "pink"  => { :name => "Pink",
+                   :directions => { "1" => "Loop-bound", "5" => "54th/Cermak-bound" }
+      },
+      "y"     => { :name => "Yellow",
+                   :directions => { "1" => "Skokie-bound", "5" => "Howard-bound" }
+      },
+    }
+    FRIENDLY_L_ROUTES = Hash[L_ROUTES.values.map { |r| r[:name].downcase.to_sym }.zip(L_ROUTES.keys)]
+
+    def follow!
+      CTA::TrainTracker.follow!(:run => self.schd_trip_id.gsub("R", ""))
+    end
+
+    def live!(position, predictions)
+      class << self
+        attr_reader :lat, :lon, :heading, :predictions
+      end
+
+      @lat = position["lat"].to_f
+      @lon = position["lon"].to_f
+      @heading = position["heading"].to_i
+
+      @predictions = Array.wrap(predictions).map { |p| Prediction.new(p) }
+    end
+
+    class Prediction
+      attr_reader :run, :trip, :destination, :direction, :next_station,
+                  :prediction_generated_at, :arrival_time, :minutes, :seconds,
+                  :approaching, :scheduled, :delayed, :flags, :route, :lat, :lon,
+                  :heading, :route, :direction
+
+      def initialize(data)
+        @run = data["rn"]
+        @trip = CTA::Trip.where(:schd_trip_id => "R#{@run}").first
+        @destination = CTA::Stop.where(:stop_id => data["destSt"]).first
+        @next_station = CTA::Stop.where(:stop_id => (data["staId"] || data["nextStaId"])).first
+        @prediction_generated_at = DateTime.parse(data["prdt"])
+        @arrival_time = DateTime.parse(data["arrT"])
+        @seconds = @arrival_time.to_time - @prediction_generated_at.to_time
+        @minutes = (@seconds / 60).ceil
+        @approaching = (data["isApp"] == "1")
+        @delayed = (data["isDly"] == "1")
+        @scheduled = (data["isSch"] == "1")
+        @flags = data["flags"]
+        @lat = data["lat"].to_f
+        @lon = data["lon"].to_f
+        @heading = data["heading"].to_i
+        @route = @trip.route
+        @direction = L_ROUTES[@route.route_id.downcase][:directions][data["trDr"]]
+      end
+    end
+  end
+end