hln_ice 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80a72761b4c53974d8784c926ca86d27953488ac8c6e99e9bdb386447b8a3f98
-  data.tar.gz: 3952414a0bf97c45cc2a7009c4b16b1a016bb866697821c1bf69c1b60bcc05ac
+  metadata.gz: 963f6531ca9e78e0f66d8ede2c7b7e34cc57676726ff7fe8069ceeec03a5b304
+  data.tar.gz: b164c7a89a955be98cca09d1f4d685166702549bcfec82e1c8e0e6502c359206
 SHA512:
-  metadata.gz: 2389561c18f1c9d88f486214bf4bcd5eb6b9b3bc92f08b08fc7d6ac360ccc07360646cece3ddde6c26c5a6a5dddb2026bea28f211ce5f700ace3f1baad4179c8
-  data.tar.gz: bd197b89a993c6df99f2fad1d586a3da4ce31715388a541f4679ad96a26c2c9635cdebeeef502ba67808fbbb9427c14338bc9fcd0692ca9a84f9ef242128761c
+  metadata.gz: 87e3e121398de525f6649c3852694f6a64dbc7a6e49c5cc16e3f88ec7e060686b29b68b8e1bd8083fa05cb35874be8412531dd06411b5620522ca3b40b5aafff
+  data.tar.gz: c9b81008070ad31a93db22e27805db8d355e8f066fb7a45d25e5d778f75385cbe54f78dd6c2baed8f0623ad35a91a8c95dc8c52ddd838e38b69071c6a99c691b

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-13
+
+- **Fix recommendations getting the wrong status when the ICE server outputs series information** (`ICE_OUTPUTSERIESINFORMATION`). The parser took the first coded observation anywhere in a proposal, which could be the selected series instead of the status. When it was, the recommendation's `status` was a series code (e.g. `HEP_B_ADULT_3_DOSE_SERIES`) and its `reasons` were empty, so `simplified_status` reported that vaccine group as `"overdue"` whatever ICE recommended. ICE orders these blocks differently from one request to the next, so which vaccine groups were affected varied. Upgrade before turning series output on.
+- Read every value from the observation it belongs to, by its `observationFocus` code system and code, instead of by position or with descendant searches. This applies to recommendation status and reasons, schedule authorities, dose evaluation status, and the patient and proposal elements. Responses from servers without series output parse exactly as before.
+- Expose the series ICE selected for each recommendation under `series` (`code`, `name`, and `selection`: `"unambiguous"`, `"best_guess"`, or `"alternative"`), its `season` for seasonal vaccines (`code`, `name`, `starts_on`, and `ends_on`), and `doses_remaining` when the server has `ICE_OUTPUTNUMBEROFDOSESREMAINING` enabled. `doses_remaining` is an Integer for a plain count and ICE's text otherwise (e.g. `"Recurring"`). Each evaluation gets the `series` the dose was evaluated against. All new keys are left out when ICE does not send them.
+- Season `starts_on` and `ends_on` are ISO dates read from the trailing `(MM/DD/YYYY - MM/DD/YYYY)` of ICE's season display name, because ICE sends no structured season dates. Both are `nil` if the name does not end in a valid range, e.g. if ICE changes that format. They are passed through as ICE sends them: an `ends_on` of `2100-01-01` is ICE's open-ended end date, and for influenza ICE may return a default season code and label (e.g. `20152016_INFLUENZA_SEASON`) with the current season's dates. Rely on the dates, not the code.
+
 ## [0.4.0] - 2026-10-06
 
 - Expose ICE's per-dose evaluations under `evaluations` in the result, with one entry per administered dose and vaccine group it counts toward (so a combination vaccine has several). Each entry has the caller's event id, CVX, administration date, vaccine group, dose number, validity, evaluation status, and reasons. Codes are passed through as ICE returns them. `recommendations` and `simplified_status` are unchanged.

data/README.md

@@ -6,7 +6,7 @@ Given a patient's demographics and immunization history, `HlnIce` builds the
 VMR (Virtual Medical Record) request, calls the ICE evaluation endpoint, and
 parses the response into:
 
-- a full list of **recommendations** (one per vaccine group, with status, reasons, and administration intervals),
+- a full list of **recommendations** (one per vaccine group, with status, reasons, administration intervals, and, when the ICE server outputs them, schedule authorities, series, season, and doses remaining),
 - the **evaluations** of each administered dose (per vaccine group, with dose number, validity, and reasons), and
 - a **simplified status** map keyed by vaccine group — e.g. `{ ipv_opv: "overdue", mmr: "compliant" }`.
 
@@ -115,7 +115,26 @@ On success:
         schedule_authorities: [
           { code: "ACIP_CDC", name: "Advisory Committee on Immunization Practices / Centers for Disease Control and Prevention" },
           { code: "AAP", name: "American Academy of Pediatrics" }
-        ]
+        ],
+        # Only present when the ICE server has ICE_OUTPUTSERIESINFORMATION enabled.
+        # selection is "unambiguous", "best_guess", or "alternative".
+        series: { code: "...", name: "...", selection: "best_guess" }, # e.g. HEP_B_ADULT_3_DOSE_SERIES
+        # Only present for seasonal vaccines (e.g. influenza, COVID-19) with series output on
+        # starts_on/ends_on are read from the end of ICE's season name, e.g.
+        # "2026-2027 COVID-19 Season (08/28/2026 - 01/01/2100)", because ICE sends
+        # no structured season dates. They are nil if the name is not in that format.
+        # ICE uses an end of 2100-01-01 for an open-ended season. For influenza, ICE
+        # may send a default code and label (e.g. 20152016_INFLUENZA_SEASON) with the
+        # current season's dates; the dates are the ones to rely on.
+        season: {
+          code: "COVID_19_AUG_2026_SEASON",
+          name: "2026-2027 COVID-19 Season (08/28/2026 - 01/01/2100)",
+          starts_on: "2026-08-28",
+          ends_on: "2100-01-01"
+        },
+        # Only present when ICE_OUTPUTNUMBEROFDOSESREMAINING is also enabled. An Integer
+        # for a plain count, otherwise ICE's text, e.g. "Recurring".
+        doses_remaining: 3
       }
     ],
     # One entry per administered dose and vaccine group it counts toward, so a
@@ -129,7 +148,9 @@ On success:
         dose_number: 1, # nil if ICE omits it
         valid: true,
         status: { code: "VALID", name: "Valid Dose" }, # e.g. VALID, INVALID, ACCEPTED
-        reasons: [] # e.g. [{ code: "BELOW_MINIMUM_INTERVAL", name: "Below Minimum Interval" }]
+        reasons: [], # e.g. [{ code: "BELOW_MINIMUM_INTERVAL", name: "Below Minimum Interval" }]
+        # The series the dose was evaluated against. Only present with series output on.
+        series: { code: "...", name: "...", selection: "unambiguous" } # e.g. MMR_2_DOSE_SERIES
       }
     ],
     simplified_status: { ipv_opv: "overdue" }
@@ -145,6 +166,10 @@ On failure (service error, timeout after retries, or unparseable response):
 
 Always branch on `result[:success]` before reading `result[:data]`.
 
+Optional keys (`intervals`, `schedule_authorities`, `series`, `season`,
+`doses_remaining`) are left out when ICE does not send them, so reading one
+returns `nil`.
+
 ### Simplified status values
 
 `simplified_status` maps each recognized vaccine group to one of:

data/hln_ice.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "lib/hln_ice/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "hln_ice"
+  spec.version = HlnIce::VERSION
+  spec.authors = ["Sam Sohn"]
+  spec.email = ["sam@primary.health"]
+
+  spec.summary = "Ruby client for the HLN ICE (Immunization Calculation Engine) OpenCDS service."
+  spec.description = "Evaluates a patient's immunization history against the HLN ICE forecasting " \
+                     "rules and returns both the raw recommendations and a simplified status mapping."
+  spec.homepage = "https://github.com/PrimaryDotHealth/hln_ice"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "base64", "~> 0.2"
+  spec.add_dependency "httparty", "~> 0.21"
+  spec.add_dependency "nokogiri", "~> 1.15"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/hln_ice/evaluations_parser.rb

@@ -16,8 +16,8 @@ module HlnIce
       events = patient.xpath("./clinicalStatements/substanceAdministrationEvents/substanceAdministrationEvent")
 
       events.flat_map do |event|
-        event_id = event.xpath("./id").first&.[]("root")
-        cvx = event.xpath("./substance/substanceCode").first&.[]("code")
+        event_id = event.at_xpath("./id")&.[]("root")
+        cvx = event.at_xpath("./substance/substanceCode")&.[]("code")
 
         event.xpath("./relatedClinicalStatement/substanceAdministrationEvent").filter_map do |component|
           parse_evaluation(component, event_id:, cvx:)
@@ -31,19 +31,20 @@ module HlnIce
       # Build the evaluation for one vaccine group from a nested event.
       # Returns nil when the event has no evaluation status observation.
       def parse_evaluation(component, event_id:, cvx:)
-        observation = component.xpath("./relatedClinicalStatement/observationResult[observationValue/concept]").first
-        return unless observation
+        observation = vaccine_group_observation(component)
+        status = observation&.at_xpath("./observationValue/concept")
+        return unless status
 
-        focus = observation.xpath("./observationFocus").first
-        status = observation.xpath("./observationValue/concept").first
-        dose_number = component.xpath("./doseNumber").first&.[]("value")
-        valid = component.xpath("./isValid").first&.[]("value")
+        focus = observation.at_xpath("./observationFocus")
+        dose_number = component.at_xpath("./doseNumber")&.[]("value")
+        valid = component.at_xpath("./isValid")&.[]("value")
+        series = SeriesParser.new(component).series
 
-        {
+        evaluation = {
           event_id:,
           cvx:,
-          administered_on: format_ice_date(component.xpath("./administrationTimeInterval").first&.[]("low")),
-          vaccine_group: { code: focus&.[]("code"), name: focus&.[]("displayName") },
+          administered_on: format_ice_date(component.at_xpath("./administrationTimeInterval")&.[]("low")),
+          vaccine_group: { code: focus["code"], name: focus["displayName"] },
           dose_number: dose_number&.to_i,
           valid: valid.nil? ? nil : valid == "true",
           status: { code: status["code"], name: status["displayName"] },
@@ -51,6 +52,8 @@ module HlnIce
             { code: interpretation["code"], name: interpretation["displayName"] }
           end
         }
+        evaluation[:series] = series if series
+        evaluation
       end
   end
 end

data/lib/hln_ice/response_parser.rb

@@ -33,132 +33,125 @@ module HlnIce
       attr_reader :response_body
 
       def parse_xml_response(xml_string)
-        # Parse the XML
         doc = Nokogiri::XML(xml_string)
 
         # Remove namespaces to simplify parsing
         doc.remove_namespaces!
 
-        # Extract patient information
-        patient = doc.xpath("//patient").first
+        patient = doc.at_xpath("/cdsOutput/vmrOutput/patient")
         return { raw_xml: xml_string } unless patient
 
-        patient_id = patient.xpath("./id").first&.[]("extension")
-        birth_time = patient.xpath("./demographics/birthTime").first&.[]("value")
-        gender = patient.xpath("./demographics/gender").first&.[]("code")
-
-        # Format birth date if present
-        birth_date = format_ice_date(birth_time)
-
-        # Extract vaccine recommendations
-        all_recommendations = []
-
-        doc.xpath("//substanceAdministrationProposal").each do |proposal|
-          # Get the substance code and name
-          substance_element = proposal.xpath("./substance/substanceCode").first
-          next unless substance_element
-
-          vaccine_code        = substance_element["code"]
-          vaccine_name        = substance_element["displayName"]
-          vaccine_code_system = substance_element["codeSystem"]
-
-          # Get the clinical observation result carrying the recommendation status.
-          # A proposal may contain other observation results (e.g. schedule
-          # authorities), in any order, so select the one with a status concept.
-          observation = proposal.xpath(".//observationResult[observationValue/concept]").first
-          next unless observation
-
-          # Get recommendation status
-          status_element = observation.xpath(".//observationValue/concept").first
-
-          status_code = status_element["code"]
-          status_name = status_element["displayName"]
-
-          # Get interpretation reasons
-          reasons = []
-          observation.xpath(".//interpretation").each do |interpretation|
-            reason = {
-              code: interpretation["code"],
-              name: interpretation["displayName"]
-            }
-
-            # Add supplemental text if available
-            reason[:supplemental_text] = interpretation["originalText"] if interpretation["originalText"]
-
-            reasons << reason
-          end
-
-          # Get administration time intervals if available
-          proposed_interval = proposal.xpath("./proposedAdministrationTimeInterval").first
-          valid_interval = proposal.xpath("./validAdministrationTimeInterval").first
-
-          intervals = {}
-          if proposed_interval
-            intervals[:proposed] = {
-              low: format_ice_date(proposed_interval["low"]),
-              high: format_ice_date(proposed_interval["high"])
-            }.compact
-          end
-
-          if valid_interval
-            intervals[:valid] = {
-              low: format_ice_date(valid_interval["low"]),
-              high: format_ice_date(valid_interval["high"])
-            }.compact
-          end
-
-          # Build the recommendation object
-          recommendation = {
-            vaccine: {
-              code: vaccine_code,
-              code_system: vaccine_code_system,
-              name: vaccine_name
-            },
-            status: {
-              code: status_code,
-              name: status_name
-            },
-            reasons:
-          }
+        recommendations = parse_recommendations(patient)
+
+        {
+          raw_xml: xml_string,
+          patient: parse_patient(patient),
+          recommendations:,
+          evaluations: EvaluationsParser.new(patient).evaluations,
+          simplified_status: SimplifiedStatus.new(recommendations).to_h
+        }
+      end
+
+      def parse_patient(patient)
+        birth_time = patient.at_xpath("./demographics/birthTime")&.[]("value")
+
+        {
+          id: patient.at_xpath("./id")&.[]("extension"),
+          birth_date: format_ice_date(birth_time) || birth_time,
+          gender: patient.at_xpath("./demographics/gender")&.[]("code")
+        }.compact
+      end
 
-          # Only add intervals if they exist
-          recommendation[:intervals] = intervals if present?(intervals)
+      def parse_recommendations(patient)
+        proposals = patient.xpath(
+          "./clinicalStatements/substanceAdministrationProposals/substanceAdministrationProposal"
+        )
 
-          # Only add schedule authorities if the service returned them
-          # (requires the ICE outputScheduleAuthorities property)
-          schedule_authorities = parse_schedule_authorities(proposal)
-          recommendation[:schedule_authorities] = schedule_authorities if present?(schedule_authorities)
+        proposals.filter_map { |proposal| parse_recommendation(proposal) }
+      end
 
-          all_recommendations << recommendation
+      # Returns nil when the proposal has no vaccine group status observation.
+      def parse_recommendation(proposal)
+        substance = proposal.at_xpath("./substance/substanceCode")
+        observation = vaccine_group_observation(proposal)
+        status = observation&.at_xpath("./observationValue/concept")
+        return unless substance && status
+
+        recommendation = {
+          vaccine: {
+            code: substance["code"],
+            code_system: substance["codeSystem"],
+            name: substance["displayName"]
+          },
+          status: {
+            code: status["code"],
+            name: status["displayName"]
+          },
+          reasons: parse_reasons(observation)
+        }
+
+        intervals = parse_intervals(proposal)
+        recommendation[:intervals] = intervals if present?(intervals)
+
+        # Only add schedule authorities if the service returned them
+        # (requires the ICE outputScheduleAuthorities property)
+        schedule_authorities = parse_schedule_authorities(proposal)
+        recommendation[:schedule_authorities] = schedule_authorities if present?(schedule_authorities)
+
+        recommendation.merge(parse_series(proposal))
+      end
+
+      def parse_reasons(observation)
+        observation.xpath("./interpretation").map do |interpretation|
+          reason = {
+            code: interpretation["code"],
+            name: interpretation["displayName"]
+          }
+          reason[:supplemental_text] = interpretation["originalText"] if interpretation["originalText"]
+          reason
         end
+      end
 
-        # Build the final result structure
+      def parse_intervals(proposal)
         {
-          raw_xml: xml_string,
-          patient: {
-            id: patient_id,
-            birth_date: birth_date || birth_time,
-            gender:
-          }.compact,
-          recommendations: all_recommendations, # Keep the original flat list for backward compatibility
-          evaluations: EvaluationsParser.new(patient).evaluations,
-          simplified_status: SimplifiedStatus.new(all_recommendations).to_h
-        }
+          proposed: parse_interval(proposal.at_xpath("./proposedAdministrationTimeInterval")),
+          valid: parse_interval(proposal.at_xpath("./validAdministrationTimeInterval"))
+        }.compact
+      end
+
+      def parse_interval(interval)
+        return unless interval
+
+        {
+          low: format_ice_date(interval["low"]),
+          high: format_ice_date(interval["high"])
+        }.compact
       end
 
       # Extract the schedule authorities (e.g. ACIP_CDC, AAP) for a proposal.
       # Returns an empty array when the service did not include them.
       def parse_schedule_authorities(proposal)
-        authorities = proposal.xpath(
-          ".//observationResult[observationFocus/@code='ICE_VACCINE_GROUP_SCHEDULE_AUTHORITIES']/interpretation"
-        )
+        observations = related_observations(proposal, focus_code_system: ICE_OUTPUT_FOCUS_CODE_SYSTEM,
+                                                      focus_code: "ICE_VACCINE_GROUP_SCHEDULE_AUTHORITIES")
 
-        authorities.map do |interpretation|
+        observations.xpath("./interpretation").map do |interpretation|
           {
             code: interpretation["code"],
             name: interpretation["displayName"]
           }
         end
       end
+
+      # Only the fields ICE sent, so responses without series output parse as
+      # before.
+      def parse_series(proposal)
+        series = SeriesParser.new(proposal)
+
+        {
+          series: series.series,
+          season: series.season,
+          doses_remaining: series.doses_remaining
+        }.compact
+      end
   end
 end

data/lib/hln_ice/series_parser.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module HlnIce
+  # Extracts the series ICE selected for display from a recommendation or dose
+  # evaluation, along with its season and doses remaining. ICE only sends these
+  # when the ICE_OUTPUTSERIESINFORMATION and ICE_OUTPUTNUMBEROFDOSESREMAINING
+  # service settings are on; each value is nil when ICE did not send it.
+  class SeriesParser
+    include Support
+
+    SERIES_DISPLAY_TYPE_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.501"
+    SERIES_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.10"
+    SEASON_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.11"
+    SEASON_DATE_RANGE = %r{\((\d{2}/\d{2}/\d{4}) - (\d{2}/\d{2}/\d{4})\)\z}
+
+    # In order of preference, so a selected series wins over an alternative.
+    SELECTIONS = {
+      "SERIES_DISPLAY_UNAMBIGUOUS" => "unambiguous",
+      "SERIES_DISPLAY_BEST_GUESS" => "best_guess",
+      "SERIES_DISPLAY_ALTERNATIVE" => "alternative"
+    }.freeze
+
+    def initialize(statement)
+      @statement = statement
+    end
+
+    def series
+      concept = selected_observation&.at_xpath("./observationValue/concept[@codeSystem='#{SERIES_CODE_SYSTEM}']")
+      return unless concept
+
+      {
+        code: concept["code"],
+        name: concept["displayName"],
+        selection: SELECTIONS.fetch(selection_code(selected_observation))
+      }
+    end
+
+    def season
+      concept = selected_observation_detail("SEASON", SEASON_CODE_SYSTEM)
+                &.at_xpath("./observationValue/concept[@codeSystem='#{SEASON_CODE_SYSTEM}']")
+      return unless concept
+
+      starts_on, ends_on = season_dates(concept["displayName"])
+
+      {
+        code: concept["code"],
+        name: concept["displayName"],
+        starts_on:,
+        ends_on:
+      }
+    end
+
+    # An Integer when ICE sends a plain count, otherwise ICE's text as is
+    # (e.g. "Recurring").
+    def doses_remaining
+      value = selected_observation_detail("NUMBER_OF_DOSES_REMAINING", SERIES_CODE_SYSTEM)
+              &.at_xpath("./observationValue/text")&.[]("value")
+
+      value&.match?(/\A\d+\z/) ? value.to_i : value
+    end
+
+    private
+      attr_reader :statement
+
+      # ICE sends no structured season dates, only a trailing
+      # "(MM/DD/YYYY - MM/DD/YYYY)" in the season's display name. Returns ISO
+      # dates, or nils when the name does not end in a valid range.
+      def season_dates(name)
+        range = SEASON_DATE_RANGE.match(name.to_s)
+        return [nil, nil] unless range
+
+        range.captures.map { |date| Date.strptime(date, "%m/%d/%Y").iso8601 }
+      rescue Date::Error
+        [nil, nil]
+      end
+
+      def selected_observation
+        return @selected_observation if defined?(@selected_observation)
+
+        @selected_observation = series_selections.min_by do |observation|
+          SELECTIONS.keys.index(selection_code(observation))
+        end
+      end
+
+      def series_selections
+        options = related_observations(statement, focus_code_system: ICE_OUTPUT_FOCUS_CODE_SYSTEM,
+                                                  focus_code: "SERIES_DISPLAY_OPTIONS")
+
+        selections = options.flat_map do |option|
+          related_observations(option, focus_code_system: SERIES_DISPLAY_TYPE_CODE_SYSTEM).to_a
+        end
+
+        selections.select { |observation| SELECTIONS.key?(selection_code(observation)) }
+      end
+
+      def selection_code(observation)
+        observation.at_xpath("./observationFocus")["code"]
+      end
+
+      def selected_observation_detail(focus_code, focus_code_system)
+        return unless selected_observation
+
+        related_observations(selected_observation, focus_code_system:, focus_code:).first
+      end
+  end
+end

data/lib/hln_ice/support.rb

@@ -6,7 +6,26 @@ module HlnIce
   # Helpers shared by the request builder and response parsers. Included as
   # private instance methods.
   module Support
+    VACCINE_GROUP_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.1"
+    ICE_OUTPUT_FOCUS_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.500"
+
     private
+      # The observations a vMR statement relates directly to, selected by their
+      # observationFocus rather than by position: ICE orders them differently
+      # from one request to the next, and nests further observations in them.
+      def related_observations(statement, focus_code_system:, focus_code: nil)
+        focus = "@codeSystem='#{focus_code_system}'"
+        focus += " and @code='#{focus_code}'" if focus_code
+
+        statement.xpath("./relatedClinicalStatement/observationResult[observationFocus[#{focus}]]")
+      end
+
+      # The observation carrying ICE's status for the vaccine group, e.g. a
+      # recommendation or dose evaluation status. ICE sends one per statement.
+      def vaccine_group_observation(statement)
+        related_observations(statement, focus_code_system: VACCINE_GROUP_CODE_SYSTEM).first
+      end
+
       # Plain-Ruby equivalent of ActiveSupport's `blank?`.
       def blank?(value)
         return true if value.nil?

data/lib/hln_ice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HlnIce
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/hln_ice.rb

@@ -3,6 +3,7 @@
 require_relative "hln_ice/version"
 require_relative "hln_ice/support"
 require_relative "hln_ice/request_builder"
+require_relative "hln_ice/series_parser"
 require_relative "hln_ice/evaluations_parser"
 require_relative "hln_ice/simplified_status"
 require_relative "hln_ice/response_parser"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hln_ice
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Sam Sohn
 bindir: exe
 cert_chain: []
-date: 2026-10-07 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -66,11 +66,13 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- hln_ice.gemspec
 - lib/hln_ice.rb
 - lib/hln_ice/client.rb
 - lib/hln_ice/evaluations_parser.rb
 - lib/hln_ice/request_builder.rb
 - lib/hln_ice/response_parser.rb
+- lib/hln_ice/series_parser.rb
 - lib/hln_ice/simplified_status.rb
 - lib/hln_ice/support.rb
 - lib/hln_ice/version.rb