swiss-netex 1.0.0

data/lib/swiss_netex/filter/frames.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module SwissNetex
+  class Filter
+    # Per-frame rewrite rules once journey refs are known.
+    # Each method returns XmlSieve::Result (tempfile IO + counters).
+    #
+    # Unknown large entity types are listed as filterable and denied by default so
+    # a future national export that adds Route / JourneyPattern / ServiceLink does
+    # not pass millions of unreferenced entities through.
+    module Frames
+      module_function
+
+      SERVICE_ENTITIES = %w[
+        Line DestinationDisplay ScheduledStopPoint PassengerStopAssignment
+        Notice DefaultConnection SiteConnection Direction
+        Route JourneyPattern ServiceLink ServiceJourneyPattern TimingLink
+      ].freeze
+
+      SITE_ENTITIES = %w[StopPlace TopographicPlace Quay].freeze
+
+      RESOURCE_ENTITIES = %w[
+        Operator ResponsibilitySet TypeOfProductCategory VehicleType TypeOfNotice
+      ].freeze
+
+      CALENDAR_ENTITIES = %w[AvailabilityCondition DayType DayTypeAssignment].freeze
+
+      def service(source, refs)
+        rewrite(source, SERVICE_ENTITIES) { |entity| keep_service_entity?(entity, refs) }
+      end
+
+      def site(source, refs)
+        rewrite(source, SITE_ENTITIES) do |entity|
+          case entity.local_name
+          when "TopographicPlace"
+            true # small fixed/shared set in Swiss exports
+          when "StopPlace"
+            # Nested quays travel with kept StopPlace outer_xml; no extra ref buckets.
+            refs.include?(:stop_places, entity.id)
+          else
+            false
+          end
+        end
+      end
+
+      def resource(source, refs)
+        rewrite(source, RESOURCE_ENTITIES) do |entity|
+          case entity.local_name
+          when "TypeOfNotice" then true # small catalogue
+          when "Operator" then refs.include?(:operators, entity.id)
+          when "ResponsibilitySet" then refs.include?(:responsibility_sets, entity.id)
+          when "TypeOfProductCategory" then refs.include?(:type_of_product_categories, entity.id)
+          when "VehicleType" then refs.include?(:vehicle_types, entity.id)
+          else false
+          end
+        end
+      end
+
+      def common(source, refs)
+        CommonFrame.new(refs).call(source)
+      end
+
+      def service_calendar(source, refs)
+        rewrite(source, CALENDAR_ENTITIES) do |entity|
+          case entity.local_name
+          when "AvailabilityCondition" then refs.include?(:availability_conditions, entity.id)
+          when "DayType" then refs.include?(:day_types, entity.id)
+          when "DayTypeAssignment" then day_type_assignment_keep?(entity.outer_xml, refs)
+          else false
+          end
+        end
+      end
+
+      def rewrite(source, filterable, &)
+        XmlSieve.new(filterable: filterable).call(source, &)
+      end
+
+      def keep_service_entity?(entity, refs)
+        case entity.local_name
+        when "Line" then refs.include?(:lines, entity.id)
+        when "DestinationDisplay" then refs.include?(:destination_displays, entity.id)
+        when "ScheduledStopPoint" then refs.include?(:scheduled_stop_points, entity.id)
+        when "Notice" then refs.include?(:notices, entity.id)
+        when "Direction" then true # small fixed set in Swiss exports
+        when "PassengerStopAssignment" then ssp_ref_kept?(entity.outer_xml, refs)
+        when "DefaultConnection" then stop_place_ref_kept?(entity.outer_xml, refs)
+        when "SiteConnection" then site_connection_kept?(entity.outer_xml, refs)
+        else false
+        end
+      end
+
+      def ssp_ref_kept?(xml, refs)
+        ref = first_ref(xml, "ScheduledStopPointRef")
+        ref && refs.include?(:scheduled_stop_points, ref)
+      end
+
+      def stop_place_ref_kept?(xml, refs)
+        ref = first_ref(xml, "StopPlaceRef")
+        ref && refs.include?(:stop_places, ref)
+      end
+
+      # Keep walk transfers only when both ends are in the filtered stop set.
+      def site_connection_kept?(xml, refs)
+        refs_list = all_refs(xml, "StopPlaceRef")
+        !refs_list.empty? && refs_list.all? { |ref| refs.include?(:stop_places, ref) }
+      end
+
+      def first_ref(xml, element_name)
+        all_refs(xml, element_name).first
+      end
+
+      def all_refs(xml, element_name)
+        text = xml.to_s
+        text.scan(/<#{element_name}\b[^>]*\bref="([^"]+)"/).flatten +
+          text.scan(/<[^:>]+:#{element_name}\b[^>]*\bref="([^"]+)"/).flatten
+      end
+
+      def day_type_assignment_keep?(xml, refs)
+        ref = first_ref(xml, "DayTypeRef")
+        ref && refs.include?(:day_types, ref)
+      end
+    end
+  end
+end

data/lib/swiss_netex/filter/refs.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module SwissNetex
+  class Filter
+    # Mutable sets of NeTEx ids collected while filtering, used for transitive keep.
+    class Refs
+      ATTRS = %i[
+        operators
+        lines
+        scheduled_stop_points
+        stop_places
+        destination_displays
+        notices
+        availability_conditions
+        day_types
+        responsibility_sets
+        type_of_product_categories
+        type_of_services
+        vehicle_types
+        service_facility_sets
+        train_numbers
+        journeys
+      ].freeze
+
+      REF_BUCKETS = {
+        "OperatorRef" => :operators,
+        "LineRef" => :lines,
+        "ScheduledStopPointRef" => :scheduled_stop_points,
+        "StopPlaceRef" => :stop_places,
+        "DestinationDisplayRef" => :destination_displays,
+        "NoticeRef" => :notices,
+        "AvailabilityConditionRef" => :availability_conditions,
+        "DayTypeRef" => :day_types,
+        "TypeOfProductCategoryRef" => :type_of_product_categories,
+        "TypeOfServiceRef" => :type_of_services,
+        "VehicleTypeRef" => :vehicle_types,
+        "ServiceFacilitySetRef" => :service_facility_sets,
+        "TrainNumberRef" => :train_numbers,
+        "ResponsibilitySetRef" => :responsibility_sets
+      }.freeze
+
+      attr_reader(*ATTRS)
+
+      def initialize
+        ATTRS.each { |name| instance_variable_set(:"@#{name}", {}) }
+      end
+
+      def add(collection, *ids)
+        set = public_send(collection)
+        ids.flatten.each do |id|
+          text = id.to_s.strip
+          set[text] = true unless text.empty?
+        end
+      end
+
+      def include?(collection, id)
+        public_send(collection).key?(id.to_s)
+      end
+
+      def size(collection)
+        public_send(collection).size
+      end
+
+      def merge_from_xml(xml)
+        xml.to_s.scan(/<([A-Za-z0-9:]+)[^>]*\bref="([^"]+)"/) do |raw_name, ref|
+          bucket = REF_BUCKETS[local_name(raw_name)]
+          add(bucket, ref) if bucket
+        end
+        extract_responsibility_set(xml)
+      end
+
+      # Compact export for IPC (fork workers) / merging batch deltas.
+      def export
+        ATTRS.each_with_object({}) do |name, hash|
+          keys = public_send(name).keys
+          hash[name] = keys unless keys.empty?
+        end
+      end
+
+      def merge_export(data)
+        return self unless data
+
+        data.each do |name, ids|
+          add(name.to_sym, ids) if ATTRS.include?(name.to_sym)
+        end
+        self
+      end
+
+      def counts
+        ATTRS.to_h { |name| [name, public_send(name).size] }
+      end
+
+      private
+
+      def local_name(name)
+        name.to_s.split(":", 2).last
+      end
+
+      def extract_responsibility_set(xml)
+        xml.to_s.scan(/\bresponsibilitySetRef="([^"]+)"/) do |ref,|
+          add(:responsibility_sets, ref)
+        end
+      end
+    end
+  end
+end

data/lib/swiss_netex/filter/service_lines.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "stringio"
+
+module SwissNetex
+  class Filter
+    # First SERVICE pass: choose Line ids for the selected operators (and optional
+    # line aliases) without rewriting the frame yet.
+    class ServiceLines
+      Line = Data.define(
+        :id,
+        :operator_id,
+        :public_code,
+        :short_name,
+        :slnid,
+        :name
+      )
+
+      def initialize(operator_ids:, line_aliases: [], refs: nil)
+        @operator_ids = operator_ids.to_h { |id| [id.to_s, true] }
+        @line_aliases = normalize_aliases(line_aliases)
+        @refs = refs
+      end
+
+      def call(source)
+        kept = {}
+        each_line_xml(source) do |xml|
+          line = parse_line(xml)
+          next unless line && keep_line?(line)
+
+          kept[line.id] = line
+          remember(line.id, xml)
+        end
+        kept
+      end
+
+      private
+
+      def remember(id, xml)
+        return unless @refs
+
+        @refs.add(:lines, id)
+        @refs.merge_from_xml(xml)
+      end
+
+      def keep_line?(line)
+        return false unless @operator_ids.key?(line.operator_id)
+        return true if @line_aliases.empty?
+
+        line_matches_alias?(line)
+      end
+
+      def line_matches_alias?(line)
+        [
+          line.id,
+          line.public_code,
+          line.short_name,
+          line.slnid,
+          line.name
+        ].compact.map { |value| normalize(value) }.any? { |key| @line_aliases.key?(key) }
+      end
+
+      def each_line_xml(source)
+        reader = Nokogiri::XML::Reader(to_io(source))
+        while reader.read
+          next unless line_element?(reader)
+
+          xml = reader.outer_xml
+          yield xml if xml && !xml.empty?
+        end
+      end
+
+      def line_element?(reader)
+        reader.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT &&
+          reader.local_name == "Line"
+      end
+
+      def parse_line(xml)
+        root = Nokogiri::XML(xml).root
+        return unless root
+
+        id = root["id"].to_s.strip
+        return if id.empty?
+
+        Line.new(
+          id: id,
+          operator_id: attr_ref(root, "OperatorRef"),
+          public_code: text_at(root, "PublicCode"),
+          short_name: text_at(root, "ShortName"),
+          slnid: key_value(root, "SLNID"),
+          name: text_at(root, "Name")
+        )
+      end
+
+      def attr_ref(node, element_name)
+        child = node.at_xpath(".//*[local-name()=#{element_name.inspect}]")
+        blank_to_nil(child&.[]("ref")&.strip)
+      end
+
+      def text_at(node, element_name)
+        child = node.at_xpath(".//*[local-name()=#{element_name.inspect}]")
+        blank_to_nil(child&.text&.strip)
+      end
+
+      def key_value(node, key_name)
+        node.xpath(".//*[local-name()='KeyValue']").each do |kv|
+          key = kv.at_xpath(".//*[local-name()='Key']")&.text&.strip
+          next unless key&.casecmp?(key_name)
+
+          return blank_to_nil(kv.at_xpath(".//*[local-name()='Value']")&.text&.strip)
+        end
+        nil
+      end
+
+      def blank_to_nil(text)
+        text.nil? || text.empty? ? nil : text
+      end
+
+      def normalize_aliases(aliases)
+        Array(aliases).each_with_object({}) do |value, hash|
+          key = normalize(value)
+          hash[key] = true unless key.empty?
+        end
+      end
+
+      def normalize(value)
+        value.to_s.strip.downcase
+      end
+
+      def to_io(source)
+        return StringIO.new(source) if source.is_a?(String)
+        return source if source.respond_to?(:read)
+
+        raise Error, "ServiceLines expects a String or IO-like object"
+      end
+    end
+  end
+end