cta_redux 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ebdfcb117df8f4fe78aba18570093bca3b31889
-  data.tar.gz: 73b88fc7bcdd14a3841514c849028f4383fda0b4
+  metadata.gz: 520e277cc8d9ccbb7ab6f9a619df57f2ada3c246
+  data.tar.gz: c6c9ec28887958b1dcd36cccdc0597365ce885f5
 SHA512:
-  metadata.gz: a319534c7da09c458a6ed0224bfc1fb2da0e74fb44ee191d96a6cc1690563f2fbbfff94849e7893193b3a2f400b5dbf62d191b47c4e454870ba62b9321e1fc98
-  data.tar.gz: 5588efc46e16b89723bda4b58a62a71d787dd3bf760f890ba1f5493eb99853a87241e765e084e85297a2f806d402855649f977e2a3100a213528b90f76828b0b
+  metadata.gz: 002852493532fcd7c94e623575bf22c0d8f5ef788932e81525bfe8115dd78efcf4c98e15e81f0fffa1a5cd9fbcb0c87e61ad92ee5d950f49588b8c8adec13cec
+  data.tar.gz: 448b788a0ba92cabf6722a58f8b598bbcdc47956740acf8e94e2b0c056fc701c5bcb325a386ae3970d0ba620c9e77a9c38ec80154abbbd13c5909cdcf16323b6

data/lib/cta_redux/api/bus_tracker.rb

@@ -13,7 +13,7 @@ module CTA
       def initialize(parsed_body, raw_body, debug)
         super(parsed_body, raw_body, debug)
         @vehicles = Array.wrap(parsed_body["bustime_response"]["vehicle"]).map do |v|
-          bus = CTA::Bus.find_active_run(v["rt"], v["tmstmp"], (v["dly"] == "true")).first
+          bus = CTA::Bus.find_active_run(v["rt"], v["tmstmp"], (v["dly"] == "true"), v["rtdir"]).first
           bus.live = CTA::Bus::Live.new(v)
 
           bus
@@ -91,7 +91,7 @@ module CTA
       def initialize(parsed_body, raw_body, debug)
         super(parsed_body, raw_body, debug)
         @vehicles = Array.wrap(parsed_body["bustime_response"]["prd"]).map do |p|
-          bus = CTA::Bus.find_active_run(p["rt"], p["tmstmp"], (p["dly"] == "true")).first
+          bus = CTA::Bus.find_active_run(p["rt"], p["tmstmp"], (p["dly"] == "true"), p["rtdir"]).first
           bus.live = CTA::Bus::Live.new(p, p)
 
           bus

data/lib/cta_redux/api/train_tracker.rb

@@ -22,9 +22,9 @@ module CTA
 
         @routes = eta_map.map do |rt, etas|
           trains = etas.map do |t|
-            train = CTA::Train.find_active_run(t["rn"], self.timestamp, (t["isDly"] == "1")).first
+            train = CTA::Train.find_active_run(t["rn"], self.timestamp, (t["isDly"] == "1"), t["destNm"]).first
             if !train
-              train = CTA::Train.find_active_run(t["rn"], self.timestamp, true).first
+              train = CTA::Train.find_active_run(t["rn"], self.timestamp, true, t["destNm"]).first
             end
             position = t.select { |k,v| ["lat", "lon", "heading"].include?(k) }
             train.live = CTA::Train::Live.new(position, t)
@@ -54,9 +54,9 @@ module CTA
         super(parsed_body, raw_body, debug)
 
         train_info = Array.wrap(parsed_body["ctatt"]["eta"]).first
-        @train = CTA::Train.find_active_run(train_info["rn"], self.timestamp, (train_info["isDly"] == "1")).first
+        @train = CTA::Train.find_active_run(train_info["rn"], self.timestamp, (train_info["isDly"] == "1"), train_info["destNm"]).first
         if !@train
-          @train = CTA::Train.find_active_run(train_info["rn"], self.timestamp, true).first
+          @train = CTA::Train.find_active_run(train_info["rn"], self.timestamp, true, train_info['destNm']).first
         end
         @train.live = CTA::Train::Live.new(parsed_body["ctatt"]["position"], parsed_body["ctatt"]["eta"])
         @predictions = @train.live.predictions
@@ -79,9 +79,9 @@ module CTA
           rt = Route.where(:route_id => route["name"].capitalize).first
 
           trains = Array.wrap(route["train"]).map do |train|
-            t = CTA::Train.find_active_run(train["rn"], self.timestamp, (train["isDly"] == "1")).first
+            t = CTA::Train.find_active_run(train["rn"], self.timestamp, (train["isDly"] == "1"), train['destNm']).first
             if !t # Sometimes the CTA doesn't report things as delayed even when they ARE
-              t = CTA::Train.find_active_run(train["rn"], self.timestamp, true).first
+              t = CTA::Train.find_active_run(train["rn"], self.timestamp, true, train['destNm']).first
             end
 
             if !t

data/lib/cta_redux/models/bus.rb

@@ -30,6 +30,43 @@ module CTA
     alias_method :scheduled_trip_id, :schd_trip_id
     alias_method :run, :schd_trip_id
 
+    # Find a {CTA::Trip} that should be happening, given a timestamp and a route or run.
+    # The CTA does not return GTFS trip_id information in either the BusTracker or TrainTracker API, so
+    # it is actually somewhat difficult to associate an API response to a {CTA::Trip}. However, we
+    # know what *should* be happening at any given time. This method attempts a fuzzy find - internally,
+    # we often first try to find the exact Trip that should be happening according to the schedule, and
+    # then failing that we assume that the CTA is running late and look for trips that should have
+    # ended within the past 90 minutes. This almost always finds something.
+    # That said, however, it means we may sometimes find a {CTA::Trip} that's incorrect. In practical usage
+    # however, that doesn't matter too much - most Trips for a run service the same stops.
+    # However, to be safe, your program may wish to compare certain other bits of the API responses to ensure
+    # we found something valid. For example, almost all Brown line trains service the same stops, so
+    # finding the wrong Trip doesn't matter too much. However, a handful of Brown line runs throughout the dat
+    # actually change to Orange line trains at Midway - so, you may wish to verify that the destination of the
+    # Trip matches the reported destination of the API.
+    # Suggestions on how to approach this problem are most welcome (as are patches for better behavior).
+    # @param [String] run The run or route to search for
+    # @param [DateTime, String] timestamp The timestamp to search against.
+    # @param [true,false] fuzz Whether or not to do an exact schedule search or a fuzzy search.
+    def self.find_active_run(run, timestamp, fuzz = false, direction = nil)
+      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
+        WHERE t.route_id = '#{run}'
+        #{direction ? "  AND t.direction = '#{direction.gsub("bound", "")}'" : '' }
+          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
+
     # Returns predictions for this {CTA::Bus}. Accepts all options for {CTA::BusTracker.predictions!}, and will merge in
     # it's own vehicle_id or route_id if present.
     # @param [Hash] options

data/lib/cta_redux/models/shape.rb

@@ -4,6 +4,8 @@ module CTA
   # GTFS feed, though the CTA does not fully implement the standard.
   # @note Current columns: [:shape_id, :shape_pt_lat, :shape_pt_lon, :shape_pt_sequence, :shape_dist_traveled]
   class Shape < Sequel::Model
+    set_primary_key :shape_id
+
     # @!method shape_id
     #  @return [Integer]
     # @!method shape_pt_lat
@@ -20,5 +22,9 @@ module CTA
     alias_method :sequence, :shape_pt_sequence
     alias_method :distance, :shape_dist_traveled
     alias_method :distance_traveled, :shape_dist_traveled
+
+    # @!method trips
+    #   @return [Array<CTA::Trip>] All {CTA::Trip}s related to this {CTA::Shape}
+    one_to_many :trips, :key => :shape_id
   end
 end

data/lib/cta_redux/models/train.rb

@@ -36,6 +36,22 @@ module CTA
     }
     FRIENDLY_L_ROUTES = Hash[L_ROUTES.values.map { |r| r[:name].downcase.to_sym }.zip(L_ROUTES.keys)]
 
+    ANNOYING_GREEN_RUNS = CTA::DB[:stop_times].with_sql(<<-SQL).select_map(:schd_trip_id)
+      SELECT DISTINCT t.schd_trip_id
+      FROM stop_times st
+        JOIN trips t ON st.trip_id = t.trip_id
+      WHERE t.route_id = 'G'
+        AND st.stop_headsign = ''
+    SQL
+
+    HEADSIGNS = {
+      "54th/Cermak"   => "54 / Cermak",
+      "Ashland/63rd"  => "Ashland / 63",
+      "UIC-Halsted"   => "UIC",
+      "Harlem/Lake"   => "Harlem",
+      "95th/Dan Ryan" => "95th",
+    }
+
     # @!method route_id
     #  @return [String]
     # @!method service_id
@@ -58,6 +74,62 @@ module CTA
     alias_method :scheduled_trip_id, :schd_trip_id
     alias_method :run, :schd_trip_id
 
+    # Find a {CTA::Trip} that should be happening, given a timestamp and a route or run.
+    # The CTA does not return GTFS trip_id information in either the BusTracker or TrainTracker API, so
+    # it is actually somewhat difficult to associate an API response to a {CTA::Trip}. However, we
+    # know what *should* be happening at any given time. This method attempts a fuzzy find - internally,
+    # we often first try to find the exact Trip that should be happening according to the schedule, and
+    # then failing that we assume that the CTA is running late and look for trips that should have
+    # ended within the past 90 minutes. This almost always finds something.
+    # That said, however, it means we may sometimes find a {CTA::Trip} that's incorrect. In practical usage
+    # however, that doesn't matter too much - most Trips for a run service the same stops.
+    # However, to be safe, your program may wish to compare certain other bits of the API responses to ensure
+    # we found something valid. For example, almost all Brown line trains service the same stops, so
+    # finding the wrong Trip doesn't matter too much. However, a handful of Brown line runs throughout the dat
+    # actually change to Orange line trains at Midway - so, you may wish to verify that the destination of the
+    # Trip matches the reported destination of the API.
+    # Suggestions on how to approach this problem are most welcome (as are patches for better behavior).
+    # @param [String] run The run or route to search for
+    # @param [DateTime, String] timestamp The timestamp to search against.
+    # @param [true,false] fuzz Whether or not to do an exact schedule search or a fuzzy search.
+    # @param [String] direction The stop headsign. Highly recommended to use because otherwise results may be inaccurate.
+    def self.find_active_run(run, timestamp, fuzz = false, direction = nil)
+      # The TrainTracker API sets the stop_headsign to 'Cottage Grove' but GTFS has it as blank...
+      if run == "516"
+        puts run
+        puts timestamp.to_s
+        puts fuzz.inspect
+        puts direction
+      end
+      if ANNOYING_GREEN_RUNS.any? { |r| r =~ /#{run}/ } && false
+        direction_str = <<-EOF
+          AND (st.stop_headsign = '#{(HEADSIGNS[direction] || direction).gsub("'", "''")}'
+            OR (t.route_id = 'G' AND st.stop_headsign = ''))
+        EOF
+      elsif direction
+        direction_str = "AND st.stop_headsign = '#{(HEADSIGNS[direction] || direction).gsub("'", "''")}'"
+      else
+        direction_str = ''
+      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
+        WHERE t.schd_trip_id = 'R#{run}'
+          #{direction_str}
+          AND c.start_date <= '#{d.to_s}'
+          AND c.end_date   >= '#{d.to_s}'
+          AND c.#{wday}
+        GROUP BY t.trip_id
+        HAVING MAX(st.departure_time) >= '#{end_ts}'
+        ORDER BY st.departure_time ASC
+      SQL
+    end
+
     # Follows a train, using the TrainTracker follow API
     # @return [CTA::TrainTracker::FollowResponse] A {CTA::TrainTracker::FollowResponse} with predictions for this train
     def follow!

data/lib/cta_redux/models/trip.rb

@@ -42,6 +42,10 @@ module CTA
     #   @return [Array<CTA::Stop>] All {CTA::Stop}s serviced on this {CTA::Trip}
     many_to_many :stops, :left_key => :trip_id, :right_key => :stop_id, :join_table => :stop_times
 
+    # @!method shapes
+    #   @return [Array<CTA::Shape>] All {CTA::Shape}s related to this {CTA::Trip}
+    many_to_many :shapes, :left_key => :trip_id, :right_key => :shape_id, :join_table => :trips
+
     # @!method route_id
     #  @return [String]
     # @!method service_id
@@ -63,47 +67,5 @@ module CTA
     alias_method :id, :route_id
     alias_method :scheduled_trip_id, :schd_trip_id
     alias_method :run, :schd_trip_id
-
-    # Find a {CTA::Trip} that should be happening, given a timestamp and a route or run.
-    # The CTA does not return GTFS trip_id information in either the BusTracker or TrainTracker API, so
-    # it is actually somewhat difficult to associate an API response to a {CTA::Trip}. However, we
-    # know what *should* be happening at any given time. This method attempts a fuzzy find - internally,
-    # we often first try to find the exact Trip that should be happening according to the schedule, and
-    # then failing that we assume that the CTA is running late and look for trips that should have
-    # ended within the past 90 minutes. This almost always finds something.
-    # That said, however, it means we may sometimes find a {CTA::Trip} that's incorrect. In practical usage
-    # however, that doesn't matter too much - most Trips for a run service the same stops.
-    # However, to be safe, your program may wish to compare certain other bits of the API responses to ensure
-    # we found something valid. For example, almost all Brown line trains service the same stops, so
-    # finding the wrong Trip doesn't matter too much. However, a handful of Brown line runs throughout the dat
-    # actually change to Orange line trains at Midway - so, you may wish to verify that the destination of the
-    # Trip matches the reported destination of the API.
-    # Suggestions on how to approach this problem are most welcome (as are patches for better behavior).
-    # @param [String] run The run or route to search for
-    # @param [DateTime, String] timestamp The timestamp to search against.
-    # @param [true,false] fuzz Whether or not to do an exact schedule search or a fuzzy search.
-    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/version.rb

@@ -1,3 +1,3 @@
 module CTA
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

data/spec/train_tracker_spec.rb

@@ -60,11 +60,18 @@ RSpec.describe CTA::TrainTracker do
       expect(response.routes.size).to eq(8)
       expect(response.trains.size).to eq(80)
 
-      expect(response.trains.last.route.route_id).to eq("Y")
+      expect(response.trains.last.route.route_id).to eq("P")
       expect(response.trains.first.live.lon).to eq(-87.65338)
       expect(response.predictions.first.route.route_id).to eq("Red")
       expect(response.predictions.first.destination.stop_id).to eq(30173)
       expect(response.predictions.first.trip.service_id).to eq(104701)
     end
   end
+
+  describe "bugs" do
+    it "uses proper station IDs for Green line runs, which are wrong from the CTA GTFS feed" do
+      trip = CTA::Trip[47085599996]
+      expect(trip.stops.map(&:stop_id)).to include(30033)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cta_redux
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Andrew Hayworth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-16 00:00:00.000000000 Z
+date: 2015-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler