njtransit 1.0.0

data/lib/njtransit/gtfs/models/route.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module NJTransit
+  module GTFS
+    module Models
+      class Route
+        class << self
+          attr_accessor :db
+
+          def all
+            db[:routes].all.map { |row| new(row) }
+          end
+
+          def find(identifier)
+            row = db[:routes].where(route_id: identifier).first
+            row ||= db[:routes].where(route_short_name: identifier).first
+            row ? new(row) : nil
+          end
+
+          def where(conditions)
+            db[:routes].where(conditions).all.map { |row| new(row) }
+          end
+        end
+
+        attr_reader :route_id, :agency_id, :route_short_name, :route_long_name, :route_type, :route_color
+
+        def initialize(attributes)
+          @route_id = attributes[:route_id]
+          @agency_id = attributes[:agency_id]
+          @route_short_name = attributes[:route_short_name]
+          @route_long_name = attributes[:route_long_name]
+          @route_type = attributes[:route_type]
+          @route_color = attributes[:route_color]
+        end
+
+        def short_name
+          route_short_name
+        end
+
+        def long_name
+          route_long_name
+        end
+
+        def to_h
+          {
+            route_id: route_id,
+            agency_id: agency_id,
+            route_short_name: route_short_name,
+            route_long_name: route_long_name,
+            short_name: short_name,
+            long_name: long_name,
+            route_type: route_type,
+            route_color: route_color
+          }
+        end
+      end
+    end
+  end
+end

data/lib/njtransit/gtfs/models/stop.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module NJTransit
+  module GTFS
+    module Models
+      class Stop
+        class << self
+          attr_accessor :db
+
+          def all
+            db[:stops].all.map { |row| new(row) }
+          end
+
+          def find(stop_id)
+            row = db[:stops].where(stop_id: stop_id).first
+            row ? new(row) : nil
+          end
+
+          def find_by_code(stop_code)
+            row = db[:stops].where(stop_code: stop_code).first
+            row ? new(row) : nil
+          end
+
+          def where(conditions)
+            db[:stops].where(conditions).all.map { |row| new(row) }
+          end
+        end
+
+        attr_reader :stop_id, :stop_code, :stop_name, :stop_lat, :stop_lon, :zone_id
+
+        def initialize(attributes)
+          @stop_id = attributes[:stop_id]
+          @stop_code = attributes[:stop_code]
+          @stop_name = attributes[:stop_name]
+          @stop_lat = attributes[:stop_lat]
+          @stop_lon = attributes[:stop_lon]
+          @zone_id = attributes[:zone_id]
+        end
+
+        def lat
+          stop_lat
+        end
+
+        def lon
+          stop_lon
+        end
+
+        def to_h
+          {
+            stop_id: stop_id,
+            stop_code: stop_code,
+            stop_name: stop_name,
+            stop_lat: stop_lat,
+            stop_lon: stop_lon,
+            lat: lat,
+            lon: lon,
+            zone_id: zone_id
+          }
+        end
+      end
+    end
+  end
+end

data/lib/njtransit/gtfs/queries/routes_between.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module NJTransit
+  module GTFS
+    module Queries
+      class RoutesBetween
+        attr_reader :db, :from, :to
+
+        def initialize(db, from:, to:)
+          @db = db
+          @from = from
+          @to = to
+        end
+
+        def call
+          from_stop_id = resolve_stop_id(from)
+          to_stop_id = resolve_stop_id(to)
+
+          return [] if from_stop_id.nil? || to_stop_id.nil?
+
+          route_ids = find_common_route_ids(from_stop_id, to_stop_id)
+          return [] if route_ids.empty?
+
+          route_short_names(route_ids)
+        end
+
+        private
+
+        def find_common_route_ids(from_stop_id, to_stop_id)
+          common_trips = find_common_trips(from_stop_id, to_stop_id)
+          return [] if common_trips.empty?
+
+          db[:trips].where(trip_id: common_trips).select_map(:route_id).uniq
+        end
+
+        def find_common_trips(from_stop_id, to_stop_id)
+          from_trips = trips_at_stop(from_stop_id)
+          to_trips = trips_at_stop(to_stop_id)
+          from_trips & to_trips
+        end
+
+        def trips_at_stop(stop_id)
+          db[:stop_times].where(stop_id: stop_id).select_map(:trip_id)
+        end
+
+        def route_short_names(route_ids)
+          db[:routes].where(route_id: route_ids).select_map(:route_short_name).uniq
+        end
+
+        def resolve_stop_id(identifier)
+          # Try as stop_id first
+          stop = db[:stops].where(stop_id: identifier).first
+          return identifier if stop
+
+          # Try as stop_code
+          stop = db[:stops].where(stop_code: identifier).first
+          stop&.dig(:stop_id)
+        end
+      end
+    end
+  end
+end

data/lib/njtransit/gtfs/queries/schedule.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module NJTransit
+  module GTFS
+    module Queries
+      class Schedule
+        attr_reader :db, :route, :stop, :date
+
+        def initialize(db, route:, stop:, date:)
+          @db = db
+          @route = route
+          @stop = stop
+          @date = date
+        end
+
+        def call
+          route_id = resolve_route_id
+          stop_id = resolve_stop_id
+          service_ids = active_service_ids
+
+          return [] if route_id.nil? || stop_id.nil? || service_ids.empty?
+
+          trip_ids = find_trip_ids(route_id, service_ids)
+          return [] if trip_ids.empty?
+
+          fetch_stop_times(trip_ids, stop_id)
+        end
+
+        private
+
+        def find_trip_ids(route_id, service_ids)
+          db[:trips]
+            .where(route_id: route_id, service_id: service_ids)
+            .select_map(:trip_id)
+        end
+
+        def fetch_stop_times(trip_ids, stop_id)
+          db[:stop_times]
+            .where(trip_id: trip_ids, stop_id: stop_id)
+            .order(:arrival_time)
+            .all
+            .map { |row| format_stop_time(row) }
+        end
+
+        def format_stop_time(row)
+          {
+            trip_id: row[:trip_id],
+            arrival_time: row[:arrival_time],
+            departure_time: row[:departure_time],
+            stop_sequence: row[:stop_sequence]
+          }
+        end
+
+        def resolve_route_id
+          route_row = db[:routes].where(route_id: route).first
+          route_row ||= db[:routes].where(route_short_name: route).first
+          route_row&.dig(:route_id)
+        end
+
+        def resolve_stop_id
+          stop_row = db[:stops].where(stop_id: stop).first
+          stop_row ||= db[:stops].where(stop_code: stop).first
+          stop_row&.dig(:stop_id)
+        end
+
+        def active_service_ids
+          date_str = date.strftime("%Y%m%d")
+          db[:calendar_dates]
+            .where(date: date_str, exception_type: 1)
+            .select_map(:service_id)
+        end
+      end
+    end
+  end
+end

data/lib/njtransit/gtfs.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "gtfs/database"
+require_relative "gtfs/importer"
+require_relative "gtfs/models/stop"
+require_relative "gtfs/models/route"
+require_relative "gtfs/queries/routes_between"
+require_relative "gtfs/queries/schedule"
+
+module NJTransit
+  module GTFS
+    SEARCH_PATHS = [
+      "./bus_data",
+      "./vendor/bus_data",
+      "./docs/api/njtransit/bus_data"
+    ].freeze
+
+    class << self
+      def import(source_path, force: false)
+        importer = Importer.new(source_path, database_path)
+        validate_gtfs_directory!(importer, source_path)
+        importer.import(force: force)
+      end
+
+      def status
+        path = database_path
+        return { imported: false, path: path } unless Database.exists?(path)
+
+        build_status_hash(path)
+      end
+
+      def new
+        path = database_path
+
+        unless Database.exists?(path)
+          detected = detect_gtfs_path
+          raise GTFSNotImportedError.new(detected_path: detected)
+        end
+
+        QueryInterface.new(path)
+      end
+
+      def detect_gtfs_path
+        SEARCH_PATHS.find do |path|
+          File.directory?(path) && File.exist?(File.join(path, "agency.txt"))
+        end
+      end
+
+      def clear!
+        Database.connection(database_path)
+        Database.clear!
+        Database.disconnect
+        FileUtils.rm_f(database_path)
+      end
+
+      private
+
+      def database_path
+        NJTransit.configuration.gtfs_database_path
+      end
+
+      def validate_gtfs_directory!(importer, source_path)
+        return if importer.valid_gtfs_directory?
+
+        raise NJTransit::Error, "Invalid GTFS directory: #{source_path}. Must contain agency.txt, routes.txt, stops.txt"
+      end
+
+      def build_status_hash(path)
+        Database.connection(path)
+        db = Database.connection
+
+        { imported: true, path: path }.merge(table_counts(db)).merge(metadata_info(db))
+      end
+
+      def table_counts(db)
+        { routes: db[:routes].count, stops: db[:stops].count,
+          trips: db[:trips].count, stop_times: db[:stop_times].count }
+      end
+
+      def metadata_info(db)
+        metadata = db[:import_metadata].order(Sequel.desc(:id)).first
+        { imported_at: metadata&.dig(:imported_at), source_path: metadata&.dig(:source_path) }
+      end
+    end
+
+    class QueryInterface
+      attr_reader :db
+
+      def initialize(db_path)
+        Database.connection(db_path)
+        @db = Database.connection
+        setup_models
+      end
+
+      def stops
+        Models::Stop
+      end
+
+      def routes
+        Models::Route
+      end
+
+      def routes_between(from:, to:)
+        Queries::RoutesBetween.new(db, from: from, to: to).call
+      end
+
+      def schedule(route:, stop:, date:)
+        Queries::Schedule.new(db, route: route, stop: stop, date: date).call
+      end
+
+      private
+
+      def setup_models
+        Models::Stop.db = db
+        Models::Route.db = db
+      end
+    end
+  end
+end

data/lib/njtransit/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module NJTransit
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "njtransit/tasks.rb"
+    end
+  end
+end

data/lib/njtransit/resources/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module NJTransit
+  module Resources
+    class Base
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      def get(path, params = {})
+        client.get(path, params)
+      end
+
+      def post(path, body = {})
+        client.post(path, body)
+      end
+
+      def put(path, body = {})
+        client.put(path, body)
+      end
+
+      def patch(path, body = {})
+        client.patch(path, body)
+      end
+
+      def delete(path, params = {})
+        client.delete(path, params)
+      end
+    end
+  end
+end

data/lib/njtransit/resources/bus/enrichment.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module NJTransit
+  module Resources
+    # GTFS enrichment for Bus API responses
+    module BusEnrichment
+      private
+
+      def ensure_gtfs_available!
+        gtfs
+      end
+
+      def gtfs
+        @gtfs ||= GTFS.new
+      end
+
+      def enrich_stops(stops)
+        return stops unless stops.is_a?(Array)
+
+        stops.each { |stop| enrich_stop_record(stop) }
+      end
+
+      def enrich_stop_record(stop)
+        stop_code = stop["stop_id"] || stop[:stop_id]
+        return unless stop_code
+
+        gtfs_stop = gtfs.stops.find_by_code(stop_code.to_s)
+        return unless gtfs_stop
+
+        stop["stop_lat"] = gtfs_stop.lat
+        stop["stop_lon"] = gtfs_stop.lon
+        stop["zone_id"] = gtfs_stop.zone_id
+      end
+
+      def enrich_stop_name(result, stop_number)
+        gtfs_stop = gtfs.stops.find_by_code(stop_number.to_s)
+        return result unless gtfs_stop
+
+        if result.is_a?(Hash)
+          result["stop_lat"] = gtfs_stop.lat
+          result["stop_lon"] = gtfs_stop.lon
+        end
+        result
+      end
+
+      def enrich_departures(departures)
+        return departures unless departures.is_a?(Array)
+
+        departures.each { |dep| enrich_departure_record(dep) }
+      end
+
+      def enrich_departure_record(dep)
+        enrich_departure_stop(dep)
+        enrich_departure_route(dep)
+      end
+
+      def enrich_departure_stop(dep)
+        stop_code = dep["stop_id"] || dep[:stop_id]
+        return unless stop_code
+
+        gtfs_stop = gtfs.stops.find_by_code(stop_code.to_s)
+        return unless gtfs_stop
+
+        dep["stop_lat"] = gtfs_stop.lat
+        dep["stop_lon"] = gtfs_stop.lon
+      end
+
+      def enrich_departure_route(dep)
+        route_name = dep["route"] || dep[:route]
+        return unless route_name
+
+        gtfs_route = gtfs.routes.find(route_name.to_s)
+        dep["route_long_name"] = gtfs_route.long_name if gtfs_route
+      end
+
+      def enrich_stops_nearby(stops)
+        return stops unless stops.is_a?(Array)
+
+        stops.each { |stop| enrich_stop_zone(stop) }
+      end
+
+      def enrich_stop_zone(stop)
+        stop_code = stop["stop_id"] || stop[:stop_id]
+        return unless stop_code
+
+        gtfs_stop = gtfs.stops.find_by_code(stop_code.to_s)
+        stop["zone_id"] = gtfs_stop.zone_id if gtfs_stop
+      end
+
+      def enrich_vehicles(vehicles)
+        return vehicles unless vehicles.is_a?(Array)
+
+        vehicles.each { |vehicle| enrich_vehicle_route(vehicle) }
+      end
+
+      def enrich_vehicle_route(vehicle)
+        route_name = vehicle["route"] || vehicle[:route]
+        return unless route_name
+
+        gtfs_route = gtfs.routes.find(route_name.to_s)
+        vehicle["route_long_name"] = gtfs_route.long_name if gtfs_route
+      end
+    end
+  end
+end

data/lib/njtransit/resources/bus.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "bus/enrichment"
+
+module NJTransit
+  module Resources
+    class Bus < Base
+      include BusEnrichment
+
+      MODE = "BUS"
+      VALID_MODES = %w[BUS NLR HBLR RL ALL].freeze
+
+      def locations(mode: MODE)
+        post_form("/api/BUSDV2/getLocations", mode: validate_mode(mode))
+      end
+
+      def routes(mode: MODE)
+        post_form("/api/BUSDV2/getBusRoutes", mode: validate_mode(mode))
+      end
+
+      def directions(route:)
+        post_form("/api/BUSDV2/getBusDirectionsData", route: route)
+      end
+
+      def stops(route:, direction:, name_contains: nil, enrich: true)
+        ensure_gtfs_available! if enrich
+        params = { route: route, direction: direction }
+        params[:namecontains] = name_contains if name_contains
+        result = post_form("/api/BUSDV2/getStops", params)
+        enrich ? enrich_stops(result) : result
+      end
+
+      def stop_name(stop_number:, enrich: true)
+        ensure_gtfs_available! if enrich
+        result = post_form("/api/BUSDV2/getStopName", stopnum: stop_number)
+        enrich ? enrich_stop_name(result, stop_number) : result
+      end
+
+      def route_trips(location:, route:)
+        post_form("/api/BUSDV2/getRouteTrips", location: location, route: route)
+      end
+
+      def departures(stop:, route: nil, direction: nil, enrich: true)
+        ensure_gtfs_available! if enrich
+        params = { stop: stop }
+        params[:route] = route if route
+        params[:direction] = direction if direction
+        result = post_form("/api/BUSDV2/getBusDV", params)
+        enrich ? enrich_departures(result) : result
+      end
+
+      def trip_stops(internal_trip_number:, sched_dep_time:, timing_point_id: nil)
+        params = {
+          internal_trip_number: internal_trip_number,
+          sched_dep_time: sched_dep_time
+        }
+        params[:timing_point_id] = timing_point_id if timing_point_id
+        post_form("/api/BUSDV2/getTripStops", params)
+      end
+
+      def stops_nearby(lat:, lon:, radius:, mode: MODE, enrich: true, **options)
+        ensure_gtfs_available! if enrich
+        params = { lat: lat, lon: lon, radius: radius, mode: validate_mode(mode) }
+        params[:route] = options[:route] if options[:route]
+        params[:direction] = options[:direction] if options[:direction]
+        result = post_form("/api/BUSDV2/getBusLocationsData", params)
+        enrich ? enrich_stops_nearby(result) : result
+      end
+
+      def vehicles_nearby(lat:, lon:, radius:, mode: MODE, enrich: true)
+        ensure_gtfs_available! if enrich
+        result = post_form(
+          "/api/BUSDV2/getVehicleLocations",
+          lat: lat, lon: lon, radius: radius, mode: validate_mode(mode)
+        )
+        enrich ? enrich_vehicles(result) : result
+      end
+
+      private
+
+      def validate_mode(mode)
+        mode = mode.to_s.upcase
+        return mode if VALID_MODES.include?(mode)
+
+        raise ArgumentError,
+              "Invalid mode: #{mode}. Valid modes: #{VALID_MODES.join(", ")}"
+      end
+
+      def post_form(path, params = {})
+        params[:token] = client.token
+        client.post_form(path, params)
+      end
+    end
+  end
+end

data/lib/njtransit/resources/bus_gtfs.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module NJTransit
+  module Resources
+    class BusGTFS < Base
+      DEFAULT_PREFIX = "/api/GTFS"
+
+      def initialize(client, api_prefix: DEFAULT_PREFIX)
+        super(client)
+        @api_prefix = api_prefix
+      end
+
+      # Returns GTFS static schedule data as ZIP binary
+      def schedule_data
+        client.post_form_raw("#{@api_prefix}/getGTFS")
+      end
+
+      # Returns GTFS-RT alerts as protobuf binary
+      def alerts
+        client.post_form_raw("#{@api_prefix}/getAlerts")
+      end
+
+      # Returns GTFS-RT trip updates as protobuf binary
+      def trip_updates
+        client.post_form_raw("#{@api_prefix}/getTripUpdates")
+      end
+
+      # Returns GTFS-RT vehicle positions as protobuf binary
+      def vehicle_positions
+        client.post_form_raw("#{@api_prefix}/getVehiclePositions")
+      end
+    end
+  end
+end

data/lib/njtransit/resources/rail.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module NJTransit
+  module Resources
+    class Rail < Base
+      def stations
+        post_form("/api/TrainData/getStationList")
+      end
+
+      def station_messages(station: nil, line: nil)
+        post_form("/api/TrainData/getStationMSG",
+                  station: station || "", line: line || "")
+      end
+
+      def station_schedule(station:, njtonly: "1")
+        post_form("/api/TrainData/getStationSchedule",
+                  station: station, NJT_Only: njtonly)
+      end
+
+      def train_schedule(station:, njtonly: "1")
+        post_form("/api/TrainData/getTrainSchedule",
+                  station: station, NJT_Only: njtonly)
+      end
+
+      def train_schedule_19(station:, njtonly: "1")
+        post_form("/api/TrainData/getTrainSchedule19Rec",
+                  station: station, NJT_Only: njtonly)
+      end
+
+      def train_stop_list(train_id:)
+        post_form("/api/TrainData/getTrainStopList",
+                  trainID: train_id)
+      end
+
+      def vehicle_data
+        post_form("/api/TrainData/getVehicleData")
+      end
+
+      private
+
+      def post_form(path, params = {})
+        params[:token] = client.token
+        client.post_form(path, params)
+      end
+    end
+  end
+end