rail_feeds 0.0.1

data/lib/rail_feeds/network_rail/http_client.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+
+module RailFeeds
+  module NetworkRail
+    # A wrapper class for ::Net::HTTP
+    class HTTPClient
+      include Logging
+
+      HOST = 'datafeeds.networkrail.co.uk'
+
+      # Initialize a new http client.
+      # @param [RailFeeds::NetworkRail::Credentials] credentials
+      #   The credentials for connecting to the feed.
+      # @param [Logger] logger
+      #   The logger for outputting evetns, if nil the global logger will be used.
+      def initialize(credentials: Credentials, logger: nil)
+        @credentials = credentials
+        self.logger = logger unless logger.nil?
+      end
+
+      # Fetch path from network rail server.
+      # @param [String] path The path to fetch.
+      # @yield [file] Once the block has run the temp file will be deleted.
+      #   @yieldparam [Tempfile] file The content of the file.
+      def fetch(path)
+        logger.debug "fetch(#{path.inspect})"
+        uri = URI("https://#{HOST}/#{path}")
+        yield uri.open(http_basic_authentication: @credentials.to_a)
+      end
+
+      # Fetch path from network rail server and unzip it.
+      # @param [String] path The path to fetch.
+      # @yield [reader] Once the block has run the temp file will be deleted.
+      #   @yieldparam [Zlib::GzipReader] reader The unzippable content of the file.
+      def fetch_unzipped(path)
+        logger.debug "get_unzipped(#{path.inspect})"
+        fetch(path) do |gz_file|
+          yield Zlib::GzipReader.open(gz_file.path)
+        end
+      end
+
+      # Download path from netwrok rail server.
+      # @param [String] path The path to download.
+      # @param [String] file The path to the file to save the contents in.
+      def download(path, file)
+        logger.debug "download(#{path.inspect}, #{file.inspect})"
+        fetch(path) do |src|
+          File.open(file, 'w') do |dst|
+            IO.copy_stream src, dst
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rail_feeds/network_rail/schedule/association.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module RailFeeds
+  module NetworkRail
+    module Schedule
+      # rubocop:disable Metrics/ClassLength
+      # A class for holding information about an association between many trains.
+      class Association
+        include Comparable
+        include Schedule::Days
+        include Schedule::STPIndicator
+
+        # @!attribute [rw] main_train_uid
+        #   @return [String] The UID of the main train in the association.
+        # @!attribute [rw] associated_train_uid
+        #   @return [String] The UID of the associated train in the association.
+        # @!attribute [rw] category
+        #   @return [String] The category of the association:
+        #   * JJ - join
+        #   * VV - divide
+        #   * NP - next
+        # @!attribute [rw] start_date
+        #   @return [Date] When the schedule starts.
+        # @!attribute [rw] end_date
+        #   @return [Date] When the schedule ends.
+        # @!attribute [rw] date_indicator
+        #   @return [String] When the assocation happens:
+        #   * S - same day
+        #   * N - over next midnight
+        #   * P - over previous midnight
+        # @!attribute [rw] days
+        #   @return [Array<Boolean>] The days on which the service runs.
+        #   [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
+        # @!attribute [rw] tiploc
+        #   @return [String] The TIPLOC of the location the association occurs.
+        # @!attribute [rw] base_location_suffix
+        #   @return [String, nil]
+        #   Together with the tiploc uniquely identifies the association
+        #   on the base_uid.
+        # @!attribute [rw] associated_location_suffix
+        #   @return [String, nil]
+        #   Together with the tiploc uniquely identifies the association
+        #   on the associated_uid.
+        # @!attribute [rw] stp_indicator
+        #   @return [String]
+        #   * C - cancellation of permanent schedule
+        #   * N - new STP schedule
+        #   * O - STP overlay of permanent schedule
+        #   * P - permanent
+
+        attr_accessor :main_train_uid, :associated_train_uid, :category,
+                      :start_date, :end_date, :date_indicator,
+                      :tiploc, :main_location_suffix, :associated_location_suffix
+        # Attributes from modules :days, :stp_indicator
+
+        def initialize(**attributes)
+          attributes.each do |attribute, value|
+            send "#{attribute}=", value
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        # Initialize a new association from a CIF file line
+        def self.from_cif(line)
+          unless %w[AAN AAR AAD].include?(line[0..2])
+            fail ArgumentError, "Invalid line:\n#{line}"
+          end
+
+          new(
+            main_train_uid: line[3..8].strip,
+            associated_train_uid: line[9..14].strip,
+            start_date: Schedule.make_date(line[15..20]),
+            end_date: Schedule.make_date(line[21..26], allow_nil: line[2].eql?('D')),
+            days: days_from_cif(line[27..33]),
+            category: Schedule.nil_or_strip(line[34..35]),
+            date_indicator: Schedule.nil_or_strip(line[36]),
+            tiploc: line[37..43].strip,
+            main_location_suffix: Schedule.nil_or_i(line[44]),
+            associated_location_suffix: Schedule.nil_or_i(line[45]),
+            stp_indicator: stp_indicator_from_cif(line[79])
+          )
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
+
+        # rubocop:disable Metrics/AbcSize
+        # Initialize a new association from a JSON file line
+        def self.from_json(line)
+          data = ::JSON.parse(line)['JsonAssociationV1']
+
+          new(
+            main_train_uid: data['main_train_uid'],
+            associated_train_uid: data['assoc_train_uid'],
+            start_date: Date.parse(data['assoc_start_date']),
+            end_date: data['assoc_end_date'] ? Date.parse(data['assoc_end_date']) : nil,
+            days: days_from_cif(data['assoc_days']),
+            category: Schedule.nil_or_strip(data['category']),
+            date_indicator: Schedule.nil_or_strip(data['date_indicator']),
+            tiploc: data['location'],
+            main_location_suffix: Schedule.nil_or_i(data['base_location_suffix']),
+            associated_location_suffix: Schedule.nil_or_i(data['assoc_location_suffix']),
+            stp_indicator: stp_indicator_from_cif(data['CIF_stp_indicator'])
+          )
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # Test if this is a join association.
+        def join?
+          category.eql?('JJ')
+        end
+
+        # Test if this is a divide association.
+        def divide?
+          category.eql?('VV')
+        end
+
+        # Test if this is a next association.
+        def next?
+          category.eql?('NP')
+        end
+
+        # Test if the association happens on the same day.
+        def same_day?
+          date_indicator.eql?('S')
+        end
+
+        # Test if the association happens over the next midnight.
+        def over_next_midnight?
+          date_indicator.eql?('N')
+        end
+
+        # Test if the association happens over the previous midnight.
+        def over_previous_midnight?
+          date_indicator.eql?('P')
+        end
+
+        # Uniquely identifies the event on the main_train_uid
+        def main_train_event_id
+          "#{tiploc}-#{main_location_suffix}"
+        end
+
+        # Uniquely identifies the event on the associated_train_uid
+        def associated_train_event_id
+          "#{tiploc}-#{associated_location_suffix}"
+        end
+
+        def ==(other)
+          main_train_event_id == other&.main_train_event_id &&
+            associated_train_event_id == other&.associated_train_event_id
+        end
+
+        def <=>(other)
+          start_date <=> other&.start_date
+        end
+
+        def hash
+          "#{tiploc}-#{main_location_suffix}-#{associated_location_suffix}"
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def to_cif
+          format('%-80.80s', [
+            'AAN',
+            format('%-6.6s', main_train_uid),
+            format('%-6.6s', associated_train_uid),
+            # rubocop:disable Style/FormatStringToken
+            format('%-6.6s', start_date&.strftime('%y%m%d')),
+            format('%-6.6s', end_date&.strftime('%y%m%d')),
+            # rubocop:enable Style/FormatStringToken
+            days_to_cif,
+            format('%-2.2s', category),
+            format('%-1.1s', date_indicator),
+            format('%-7.7s', tiploc),
+            format('%-1.1s', main_location_suffix),
+            format('%-1.1s', associated_location_suffix),
+            'T                                ',
+            stp_indicator_to_cif
+          ].join) + "\n"
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # rubocop:disable Metrics/MethodLength
+        def to_json
+          {
+            'JsonAssociationV1' => {
+              'transaction_type' => 'Create',
+              'main_train_uid' => main_train_uid,
+              'assoc_train_uid' => associated_train_uid,
+              'assoc_start_date' => start_date.strftime('%Y-%m-%dT00:00:00Z'),
+              'assoc_end_date' => end_date.strftime('%Y-%m-%dT00:00:00Z'),
+              'assoc_days' => days_to_cif,
+              'category' => category,
+              'date_indicator' => date_indicator,
+              'location' => tiploc,
+              'base_location_suffix' => main_location_suffix,
+              'assoc_location_suffix' => associated_location_suffix,
+              'diagram_type' => 'T',
+              'CIF_stp_indicator' => stp_indicator_to_cif
+            }
+          }.to_json
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/rail_feeds/network_rail/schedule/data.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module RailFeeds
+  module NetworkRail
+    module Schedule
+      # rubocop:disable Metrics/ClassLength
+      # A class for holding schedule data read from schedule file(s).
+      class Data
+        include Logging
+
+        # @!attribute [r] last_header The last header added.
+        # @return [RailFeeds::NetworkRail::Schedule::Header::CIF]
+        # @!attribute [r] associations
+        # @return [Hash<RailFeeds::NetworkRail::Schedule::Association>]
+        # @!attribute [r] tiplocs
+        # @return [Hash<RailFeeds::NetworkRail::Schedule::Tiploc>]
+        # @!attribute [r] trains
+        # @return [Hash{String=>RailFeeds::NetworkRail::Schedule::TrainSchedule}]
+        # Schedules grouped by the train's UID
+
+        attr_accessor :last_header, :associations, :tiplocs, :trains
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        # Initialize a new data.
+        # @param [Logger, nil] logger
+        #   The logger for outputting events, if nil the global logger is used.
+        def initialize(logger: nil)
+          self.logger = logger unless logger.nil?
+          @parser = Parser::CIF.new(
+            logger: logger,
+            on_header: proc { |*args| do_header(*args) },
+            on_trailer: proc { |*args| do_trailer(*args) },
+            on_tiploc_create: proc { |*args| do_tiploc_create(*args) },
+            on_tiploc_update: proc { |*args| do_tiploc_update(*args) },
+            on_tiploc_delete: proc { |*args| do_tiploc_delete(*args) },
+            on_association_create: proc { |*args| do_association_create(*args) },
+            on_association_update: proc { |*args| do_association_update(*args) },
+            on_association_delete: proc { |*args| do_association_delete(*args) },
+            on_train_schedule_create: proc { |*args| do_train_schedule_create(*args) },
+            on_train_schedule_update: proc { |*args| do_train_schedule_update(*args) },
+            on_train_schedule_delete: proc { |*args| do_train_schedule_delete(*args) }
+          )
+          reset_data
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
+
+        # Load data files into the parser, of types:
+        #  * Full CIF file - the data will be replaced
+        #  * Update CIF file - the data will be changed
+        # @param [IO] file
+        #   The file to load data from.
+        def load_cif_file(file)
+          @parser.parse_cif_file file
+
+          logger.info "Currently have #{associations.count} associations, " \
+                      "#{tiplocs.count} tiplocs, #{trains.count} trains."
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        # Get the contained data in CIF format
+        # Expects a block to receive each line
+        def generate_cif
+          fail 'No loaded data' if last_header.nil?
+
+          header = Header::CIF.new(
+            extracted_at: last_header.extracted_at,
+            update_indicator: 'F',
+            start_date: last_header.start_date,
+            end_date: last_header.end_date
+          )
+
+          yield "/!! Start of file\n"
+          yield "/!! Generated: #{header.extracted_at.utc&.strftime('%d/%m/%Y %H:%M')}\n"
+          yield header.to_cif
+          tiplocs.values.sort.each { |tiploc| yield tiploc.to_cif }
+          associations.values.sort.each { |association| yield association.to_cif }
+          trains.values.flatten.sort.each do |train_schedule|
+            train_schedule.to_cif.each_line { |line| yield line }
+          end
+          yield "ZZ#{' ' * 78}\n"
+          yield "/!! End of file\n"
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
+
+        # Fetch data over the web.
+        # Gets the feed of all trains.
+        # @param [RailFeeds::NetworkRail::Credentials] credentials
+        #   The credentials for connecting to the feed.
+        # @return [RailFeeds::NetworkRail::Schedule::Header::CIF]
+        #   The header of the last file added.
+        def fetch_data(credentials: Credentials)
+          fetcher = Fetcher.new credentials: credentials
+
+          method = if last_header.nil? ||
+                      last_header.extracted_at.to_date < Date.today - 6
+                     # Need to get a full andthen updates
+                     :fetch_all
+                   else
+                     # Can only get updates
+                     :fetch_all_updates
+                   end
+
+          fetcher.send(method, :cif) do |file|
+            load_cif_file file
+          end
+        end
+
+        private
+
+        def reset_data
+          @last_header = nil
+          @associations = {}
+          @tiplocs = {}
+          @trains = {}
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/PerceivedComplexity
+        def ensure_correct_update_order(header)
+          if last_header.nil?
+            # No data whatsoever - this must be a full extract
+            unless header.full?
+              fail ArgumentError,
+                   'Update can\'t be loaded before loading a full extract.'
+            end
+
+          elsif last_header.update? && header.update?
+            # Check against last update
+            if header.extracted_at < last_header.extracted_at
+              fail ArgumentError,
+                   'Update is too old, it is before the last applied update.'
+            end
+            if header.previous_file_reference != last_header.current_file_reference
+              fail ArgumentError,
+                   'Missing update(s). Last applied update is ' \
+                   "#{last_header.current_file_reference.inspect}, " \
+                   "this update requires #{header.previous_file_reference.inspect} " \
+                   'to be the previous applied update.'
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        # Header record
+        def do_header(_parser, header)
+          ensure_correct_update_order header
+          reset_data if header.full?
+          @last_header = header
+        end
+
+        # TIPLOC Insert record
+        def do_tiploc_create(_parser, tiploc)
+          tiplocs[tiploc.hash] = tiploc
+        end
+
+        # TIPLOC Amend record
+        def do_tiploc_update(_parser, tiploc_id, tiploc)
+          tiplocs[tiploc_id] = tiploc
+        end
+
+        # TIPLOC Delete record
+        def do_tiploc_delete(_parser, tiploc)
+          tiplocs.delete tiploc.hash
+        end
+
+        # Association New record
+        def do_association_create(_parser, association)
+          associations[association.hash] = association
+        end
+
+        # Association Revise record
+        def do_association_update(_parser, association)
+          associations[association.hash] = association
+        end
+
+        # Association Delete record
+        def do_association_delete(_parser, association)
+          associations.delete association.hash
+        end
+
+        # New Train received
+        def do_train_schedule_create(_parser, train_schedule)
+          trains[train_schedule.uid] ||= []
+          trains[train_schedule.uid].push train_schedule
+        end
+
+        # Revise Train received
+        def do_train_schedule_update(parser, train_schedule)
+          trains[train_schedule.uid] ||= []
+          index = trains[train_schedule.uid].index train_schedule
+          return do_train_schedule_create(parser, train_schedule) if index.nil?
+          trains[train_schedule.uid][index] = train_schedule
+        end
+
+        # Delete Train record
+        def do_train_schedule_delete(_parser, train_schedule)
+          trains[train_schedule.uid]&.delete train_schedule
+        end
+
+        # Trailer record
+        def do_trailer(_parser); end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/rail_feeds/network_rail/schedule/days.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RailFeeds
+  module NetworkRail
+    module Schedule
+      # A collection of methods for working with a days array.
+      # Provides a days attribute to the class.
+      module Days
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        # @return [Array<Boolean, nil>] What days the record applies to
+        # (Monday -> Sunday).
+        def days
+          @days ||= Array.new(7, nil)
+        end
+
+        # @param [Array<Boolean, nil>, #to_s] value What days the record applies to.
+        # (Monday -> Sunday).
+        def days=(value)
+          value = days_from_cif(value) unless value.is_a?(Array)
+          (0..6).each do |i|
+            days[i] = value[i]&.&(true)
+          end
+          days
+        end
+
+        # Query if the record applies on Mondays
+        # @return [Boolean, nil]
+        def mondays?
+          days[0]
+        end
+
+        # Query if the record applies on Tuesdays
+        # @return [Boolean, nil]
+        def tuesdays?
+          days[1]
+        end
+
+        # Query if the record applies on Wednesdays
+        # @return [Boolean, nil]
+        def wednesdays?
+          days[2]
+        end
+
+        # Query if the record applies on Thursdays
+        # @return [Boolean, nil]
+        def thursdays?
+          days[3]
+        end
+
+        # Query if the record applies on Fridays
+        # @return [Boolean, nil]
+        def fridays?
+          days[4]
+        end
+
+        # Query if the record applies on Saturdays
+        # @return [Boolean, nil]
+        def saturdays?
+          days[5]
+        end
+
+        # Query if the record applies on Sundays
+        # @return [Boolean, nil]
+        def sundays?
+          days[6]
+        end
+
+        protected
+
+        def days_to_cif
+          self.class.days_to_cif days
+        end
+
+        def days_from_cif(value)
+          self.days = self.class.days_from_cif value
+        end
+
+        module ClassMethods # :nodoc:
+          def days_to_cif(value)
+            value.map { |d| d ? '1' : '0' }.join
+          end
+
+          def days_from_cif(value)
+            return [nil, nil, nil, nil, nil, nil, nil] if value.nil?
+            Array.new(7) { |i| value[i]&.eql?('1') }
+          end
+        end
+        private_constant :ClassMethods
+      end
+    end
+  end
+end