cqm-parsers 0.1.0

data/lib/hqmf-parser/2.0/data_criteria_helpers/dc_definition_from_template_or_type_extract.rb

@@ -0,0 +1,201 @@
+module HQMF2
+  # Extracts the type, and modifies the data criteria, based on the template id or definition
+  module DataCriteriaTypeAndDefinitionExtraction
+    VARIABLE_TEMPLATE = '0.1.2.3.4.5.6.7.8.9.1'
+    SATISFIES_ANY_TEMPLATE = '2.16.840.1.113883.10.20.28.3.108'
+    SATISFIES_ALL_TEMPLATE = '2.16.840.1.113883.10.20.28.3.109'
+    def extract_definition_from_template_or_type
+      # Try to determine what kind of data criteria we are dealing with
+      # First we look for a template id and if we find one just use the definition
+      # status and negation associated with that
+      # If no template id or not one we recognize then try to determine type from
+      # the definition element
+      extract_definition_from_type unless extract_definition_from_template_id
+    end
+
+    #  Given a template id, derive (if available) the definition for the template.
+    #  The definitions are stored in hqmf-model/data_criteria.json.
+    def extract_definition_from_template_id
+      found = false
+
+      @template_ids.each do |template_id|
+        defs = HQMF::DataCriteria.definition_for_template_id(template_id, 'r2')
+        if defs
+          @definition = defs['definition']
+          @status = defs['status'].length > 0 ? defs['status'] : nil
+          found ||= true
+        else
+          found ||= handle_known_template_id(template_id)
+        end
+      end
+
+      found
+    end
+
+    # Given a template id, modify the variables inside this data criteria to reflect the template
+    def handle_known_template_id(template_id)
+      case template_id
+      when VARIABLE_TEMPLATE
+        @derivation_operator = HQMF::DataCriteria::INTERSECT if @derivation_operator == HQMF::DataCriteria::XPRODUCT
+        @definition ||= 'derived'
+        @variable = true
+        @negation = false
+      when SATISFIES_ANY_TEMPLATE
+        @definition = HQMF::DataCriteria::SATISFIES_ANY
+        @negation = false
+      when SATISFIES_ALL_TEMPLATE
+        @definition = HQMF::DataCriteria::SATISFIES_ALL
+        @derivation_operator = HQMF::DataCriteria::INTERSECT
+        @negation = false
+      else
+        return false
+      end
+      true
+    end
+
+    # Extract the definition (sometimes status, sometimes other elements) of the data criteria based on the type
+    def extract_definition_from_type
+      # If we have a specific occurrence of a variable, pull attributes from the reference.
+      # IDEA set this up to be called from dc_specific_and_source_extract, the number of
+      #  fields changed by handle_specific_variable_ref may pose an issue.
+      extract_information_for_specific_variable if @variable && @specific_occurrence
+
+      if @entry.at_xpath('./cda:grouperCriteria')
+        @definition ||= 'derived'
+        return
+      end
+      # See if we can find a match for the entry definition value and status.
+      entry_type = attr_val('./*/cda:definition/*/cda:id/@extension')
+      handle_entry_type(entry_type)
+    end
+
+    # Extracts information from a reference for a specific
+    def extract_information_for_specific_variable
+      reference = @entry.at_xpath('./*/cda:outboundRelationship/cda:criteriaReference',
+                                  HQMF2::Document::NAMESPACES)
+      if reference
+        ref_id = strip_tokens(
+          "#{HQMF2::Utilities.attr_val(reference, 'cda:id/@extension')}_#{HQMF2::Utilities.attr_val(reference, 'cda:id/@root')}")
+      end
+      reference_criteria = @data_criteria_references[ref_id] if ref_id
+      # if the reference is derived, pull from the original variable
+      if reference_criteria && reference_criteria.definition == 'derived'
+        reference_criteria = @data_criteria_references["GROUP_#{ref_id}"]
+      end
+      return unless reference_criteria
+      handle_specific_variable_ref(reference_criteria)
+    end
+
+    # Apply additional information to a specific occurrence's elements from the criteria it references.
+    def handle_specific_variable_ref(reference_criteria)
+      # if there are no referenced children, then it's a variable representing
+      # a single data criteria, so just reference it
+      if reference_criteria.children_criteria.empty?
+        @children_criteria = [reference_criteria.id]
+      # otherwise pull all the data criteria info from the reference
+      else
+        @field_values = reference_criteria.field_values
+        @temporal_references = reference_criteria.temporal_references
+        @subset_operators = reference_criteria.subset_operators
+        @derivation_operator = reference_criteria.derivation_operator
+        @definition = reference_criteria.definition
+        @description = reference_criteria.description
+        @status = reference_criteria.status
+        @children_criteria = reference_criteria.children_criteria
+      end
+    end
+
+    # Generate the definition and/or status from the entry type in most cases.
+    # If the entry type is nil, and the value is a specific occurrence, more parsing may be necessary.
+    def handle_entry_type(entry_type)
+      # settings is required to trigger exceptions, which set the definition
+      HQMF::DataCriteria.get_settings_for_definition(entry_type, @status)
+      @definition = entry_type
+    rescue
+      # if no exact match then try a string match just using entry definition value
+      case entry_type
+      when 'Medication', 'Medications'
+        @definition = 'medication'
+        @status = 'active' unless @status
+      when 'RX'
+        @definition = 'medication'
+        @status = 'dispensed' unless @status
+      when nil
+        definition_for_nil_entry
+      else
+        @definition = extract_definition_from_entry_type(entry_type)
+      end
+    end
+
+    # If there is no entry type, extract the entry type from what it references, and extract additional information for
+    # specific occurrences. If there are no outbound references, print an error and mark it as variable.
+    def definition_for_nil_entry
+      reference = @entry.at_xpath('./*/cda:outboundRelationship/cda:criteriaReference', HQMF2::Document::NAMESPACES)
+      ref_id = nil
+      unless reference.nil?
+        ref_id = "#{HQMF2::Utilities.attr_val(reference, 'cda:id/@extension')}_#{HQMF2::Utilities.attr_val(reference, 'cda:id/@root')}"
+      end
+      reference_criteria = @data_criteria_references[strip_tokens(ref_id)] unless ref_id.nil?
+      if reference_criteria
+        # we only want to copy the reference criteria definition, status, and code_list_id if this is this is not a grouping criteria (i.e., there are no children)
+        if @children_criteria.blank?
+          @definition = reference_criteria.definition
+          @status = reference_criteria.status
+          if @specific_occurrence
+            @title = reference_criteria.title
+            @description = reference_criteria.description
+            @code_list_id = reference_criteria.code_list_id
+          end
+        else
+          # if this is a grouping data criteria (has children) mark it as derived and only pull title and description from the reference criteria
+          @definition = 'derived'
+          if @specific_occurrence
+            @title = reference_criteria.title
+            @description = reference_criteria.description
+          end
+        end
+      else
+        puts "MISSING_DC_REF: #{ref_id}" unless @variable
+        @definition = 'variable'
+      end
+    end
+
+    # Given an entry type (which describes the criteria's purpose) return the appropriate defintino
+    def extract_definition_from_entry_type(entry_type)
+      case entry_type
+      when 'Problem', 'Problems'
+        'diagnosis'
+      when 'Encounter', 'Encounters'
+        'encounter'
+      when 'LabResults', 'Results'
+        'laboratory_test'
+      when 'Procedure', 'Procedures'
+        'procedure'
+      when 'Demographics'
+        definition_for_demographic
+      when 'Derived'
+        'derived'
+      else
+        fail "Unknown data criteria template identifier [#{entry_type}]"
+      end
+    end
+
+    # Return the definition for a known subset of patient characteristics
+    def definition_for_demographic
+      demographic_type = attr_val('./cda:observationCriteria/cda:code/@code')
+      demographic_translation = {
+        '21112-8' => 'patient_characteristic_birthdate',
+        '424144002' => 'patient_characteristic_age',
+        '263495000' => 'patient_characteristic_gender',
+        '102902016' => 'patient_characteristic_languages',
+        '125680007' => 'patient_characteristic_marital_status',
+        '103579009' => 'patient_characteristic_race'
+      }
+      if demographic_translation[demographic_type]
+        demographic_translation[demographic_type]
+      else
+        fail "Unknown demographic identifier [#{demographic_type}]"
+      end
+    end
+  end
+end

data/lib/hqmf-parser/2.0/data_criteria_helpers/dc_post_processing.rb

@@ -0,0 +1,85 @@
+module HQMF2
+  # Processing on data criteria after the initial extractions have taken place
+  module DataCriteriaPostProcessing
+    # Handles settings values after (most) values have been setup
+    def post_processing
+      extract_code_list_path_and_result_value
+
+      # prefix ids that start with numerical values, and strip tokens from others
+      @id = strip_tokens(@id)
+      @children_criteria.map! { |cc| strip_tokens(cc) }
+
+      # append "_source" to the criteria since all the source criteria are separated from the non-source with the "_source" identifier
+      # "_source" is added to the SDC ids so that we are not duplicating ids between source and non source data criteria lists
+      # the derived source data criteria maintain their original ids since they are duplicated in the data criteria and source data criteria lists from the simple xml
+      @source_data_criteria = "#{@id}_source" unless (@definition == 'derived' || @definition == 'satisfies_all' || @definition == 'satisfies_any')
+      @source_data_criteria = strip_tokens(@source_data_criteria) unless @source_data_criteria.nil?
+      @specific_occurrence_const = strip_tokens(@specific_occurrence_const) unless @specific_occurrence_const.nil?
+      change_xproduct_to_intersection
+      handle_derived_specific_occurrences
+    end
+
+    # Extract the code_list_xpath and the criteria's value from either the location related to the specific occurrence,
+    # or from any of the template ids (if multiple exist)
+    def extract_code_list_path_and_result_value
+      if @template_ids.empty? && @specific_occurrence
+        template = @entry.document.at_xpath(
+          "//cda:id[@root='#{@source_data_criteria_root}' and @extension='#{@source_data_criteria_extension}']/../cda:templateId/cda:item/@root")
+        if template
+          mapping = ValueSetHelper.get_mapping_for_template(template.to_s)
+          handle_mapping_template(mapping)
+        end
+      end
+      @template_ids.each do |t|
+        mapping = ValueSetHelper.get_mapping_for_template(t)
+        handle_mapping_template(mapping)
+        break if mapping # quit if one template id with a mapping has set these values
+      end
+    end
+
+    # Set the value and code_list_xpath using the template mapping held in the ValueSetHelper class
+    def handle_mapping_template(mapping)
+      if mapping
+        if mapping[:valueset_path] && @entry.at_xpath(mapping[:valueset_path])
+          @code_list_xpath = mapping[:valueset_path]
+        end
+        @value = DataCriteriaMethods.parse_value(@entry, mapping[:result_path]) if mapping[:result_path]
+      end
+    end
+
+    # Changes XPRODUCT data criteria that has an associated tempalte(s) to an INTERSETION criteria.
+    # UNION is used for all other cases.
+    def change_xproduct_to_intersection
+      # Need to handle grouper criteria that do not have template ids -- these will be union of and intersection
+      # criteria
+      return unless @template_ids.empty?
+      # Change the XPRODUCT to an INTERSECT otherwise leave it as a UNION
+      @derivation_operator = HQMF::DataCriteria::INTERSECT if @derivation_operator == HQMF::DataCriteria::XPRODUCT
+      @description ||= (@derivation_operator == HQMF::DataCriteria::INTERSECT) ? 'Intersect' : 'Union'
+    end
+
+    # Apply some elements from the reference_criteria to the derived specific occurrence
+    def handle_derived_specific_occurrences
+      return unless @definition == 'derived'
+
+      # remove "_source" from source data critera. It gets added in in SpecificOccurrenceAndSource but
+      # when it gets added we have not yet determined the definition of the data criteria so we cannot
+      # skip adding it.  Determining the definition before SpecificOccurrenceAndSource processes doesn't
+      # work because we need to know if it is a specific occurrence to be able to figure out the definition
+      @source_data_criteria = @source_data_criteria.gsub("_source",'') if @source_data_criteria
+
+      # Adds a child if none exists (specifically the source criteria)
+      @children_criteria << @source_data_criteria if @children_criteria.empty?
+      return if @children_criteria.length != 1 ||
+                (@source_data_criteria.present? && @children_criteria.first != @source_data_criteria)
+      # if child.first is nil, it will be caught in the second statement
+      reference_criteria = @data_criteria_references[@children_criteria.first]
+      return if reference_criteria.nil?
+      @is_derived_specific_occurrence_variable = true # easier to track than all testing all features of these cases
+      @subset_operators ||= reference_criteria.subset_operators
+      @derivation_operator ||= reference_criteria.derivation_operator
+      @description = reference_criteria.description
+      @variable = reference_criteria.variable
+    end
+  end
+end

data/lib/hqmf-parser/2.0/data_criteria_helpers/dc_specific_occurrences_and_source_data_criteria_extract.rb

@@ -0,0 +1,117 @@
+module HQMF2
+  # Handles various tasks that the Data Criteria needs performed to obtain and
+  # modify secific occurrences
+  class SpecificOccurrenceAndSource
+    include HQMF2::Utilities
+
+    def initialize(entry, id, local_variable_name, data_criteria_references, occurrences_map)
+      @entry = entry
+      @id = id
+      @local_variable_name = local_variable_name
+      @occurrences_map = occurrences_map
+      @is_variable = DataCriteriaMethods.extract_variable(@local_variable_name, @id)
+      @data_criteria_references = data_criteria_references
+    end
+
+    # Retrieve the specific occurrence and source data criteria information (or just source if there is no specific)
+    def extract_specific_occurrences_and_source_data_criteria
+      specific_def = @entry.at_xpath('./*/cda:outboundRelationship[@typeCode="OCCR"]', HQMF2::Document::NAMESPACES)
+      source_def = @entry.at_xpath('./*/cda:outboundRelationship[cda:subsetCode/@code="SOURCE"]',
+                                   HQMF2::Document::NAMESPACES)
+      if specific_def
+        source_data_criteria_extension = HQMF2::Utilities.attr_val(specific_def,
+                                                                   './cda:criteriaReference/cda:id/@extension')
+        source_data_criteria_root = HQMF2::Utilities.attr_val(specific_def, './cda:criteriaReference/cda:id/@root')
+
+        occurrence_criteria = @data_criteria_references[strip_tokens("#{source_data_criteria_extension}_#{source_data_criteria_root}")]
+
+        return if occurrence_criteria.nil?
+        specific_occurrence_const = HQMF2::Utilities.attr_val(specific_def,
+                                                              './cda:localVariableName/@controlInformationRoot')
+        specific_occurrence = HQMF2::Utilities.attr_val(specific_def,
+                                                        './cda:localVariableName/@controlInformationExtension')
+
+        # FIXME: Remove debug statements after cleaning up occurrence handling
+        # build regex for extracting alpha-index of specific occurrences
+        occurrence_identifier = obtain_occurrence_identifier(strip_tokens(@id),
+                                                             strip_tokens(@local_variable_name) || '',
+                                                             strip_tokens(source_data_criteria_extension),
+                                                             @is_variable)
+
+        handle_specific_and_source(occurrence_identifier, source_data_criteria_extension, source_data_criteria_root,
+                                   specific_occurrence_const, specific_occurrence)
+
+      elsif source_def
+        extension = HQMF2::Utilities.attr_val(source_def, './cda:criteriaReference/cda:id/@extension')
+        root = HQMF2::Utilities.attr_val(source_def, './cda:criteriaReference/cda:id/@root')
+        ["#{extension}_#{root}_source", root, extension] # return the soruce data criteria itself, the rest will be blank
+      end
+    end
+
+    # Handle setting the specific and source instance variables with a given occurrence identifier
+    def handle_specific_and_source(occurrence_identifier, source_data_criteria_extension, source_data_criteria_root,
+                                   specific_occurrence_const, specific_occurrence)
+      source_data_criteria = "#{source_data_criteria_extension}_#{source_data_criteria_root}_source"
+      if !occurrence_identifier.blank?
+        # if it doesn't exist, add extracted occurrence to the map
+        # puts "\tSetting #{@source_data_criteria}-#{@source_data_criteria_root} to #{occurrence_identifier}"
+        @occurrences_map[strip_tokens(source_data_criteria)] ||= occurrence_identifier
+        specific_occurrence ||= occurrence_identifier
+        specific_occurrence_const = "#{source_data_criteria}".upcase
+      else
+        # create variable occurrences that do not already exist
+        if @is_variable
+          # puts "\tSetting #{@source_data_criteria}-#{@source_data_criteria_root} to #{occurrence_identifier}"
+          @occurrences_map[strip_tokens(source_data_criteria)] ||= occurrence_identifier
+        end
+        occurrence = @occurrences_map.try(:[], strip_tokens(source_data_criteria))
+        unless occurrence
+          fail "Could not find occurrence mapping for #{source_data_criteria}, #{source_data_criteria_root}"
+        end
+        # puts "\tUsing #{occurrence} for #{@id}"
+        specific_occurrence ||= occurrence
+      end
+
+      specific_occurrence = 'A' unless specific_occurrence
+      specific_occurrence_const = source_data_criteria.upcase unless specific_occurrence_const
+      [source_data_criteria, source_data_criteria_root, source_data_criteria_extension,
+       specific_occurrence, specific_occurrence_const]
+    end
+
+    # Using the id, source data criteria id, and local variable name (and whether or not it's a variable),
+    #  extract the occurrence identifiter (if one exists).
+    def obtain_occurrence_identifier(stripped_id, stripped_lvn, stripped_sdc, is_variable)
+      if is_variable || (stripped_sdc.include? 'qdm_var')
+        occurrence_lvn_regex = 'occ[A-Z]of_qdm_var'
+        occurrence_id_regex = 'occ[A-Z]of_qdm_var'
+        occ_index = 3
+        return handle_occurrence_var(stripped_id, stripped_lvn, stripped_sdc, occurrence_id_regex, occurrence_lvn_regex, occ_index)
+      else
+        occurrence_lvn_regex = 'Occurrence[A-Z]of'
+        occurrence_id_regex = 'Occurrence[A-Z]_'
+        occ_index = 10
+
+        occurrence_identifier = handle_occurrence_var(
+          stripped_id, stripped_lvn, stripped_sdc,
+          "#{occurrence_id_regex}#{stripped_sdc}", "#{occurrence_lvn_regex}#{stripped_sdc}",
+          occ_index)
+        return occurrence_identifier if occurrence_identifier.present?
+
+        stripped_sdc[occ_index] if stripped_sdc.match(
+          /(^#{occurrence_id_regex}| ^#{occurrence_id_regex}qdm_var_| ^#{occurrence_lvn_regex})| ^#{occurrence_lvn_regex}qdm_var_/)
+      end
+    end
+
+    # If the occurrence is a variable, extract the occurrence identifier (if present)
+    def handle_occurrence_var(stripped_id, stripped_lvn, stripped_sdc, occurrence_id_compare, occurrence_lvn_compare, occ_index)
+      # TODO: Handle specific occurrences of variables that don't self-reference?
+      if stripped_id.match(/^#{occurrence_id_compare}/)
+        return stripped_id[occ_index]
+      elsif stripped_lvn.match(/^#{occurrence_lvn_compare}/)
+        return stripped_lvn[occ_index]
+      elsif stripped_sdc.match(/^#{occurrence_id_compare}/)
+        return stripped_sdc[occ_index]
+      end
+    end
+  end
+end

data/lib/hqmf-parser/2.0/document.rb

@@ -0,0 +1,304 @@
+module HQMF2
+  # Class representing an HQMF document
+  class Document
+    include HQMF2::Utilities, HQMF2::DocumentUtilities
+    NAMESPACES = { 'cda' => 'urn:hl7-org:v3',
+                   'xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+                   'qdm' => 'urn:hhs-qdm:hqmf-r2-extensions:v1' }
+
+    attr_reader :measure_period, :id, :hqmf_set_id, :hqmf_version_number, :populations, :attributes,
+                :source_data_criteria
+
+    # Create a new HQMF2::Document instance by parsing the given HQMF contents
+    # @param [String] containing the HQMF contents to be parsed
+    def initialize(hqmf_contents, use_default_measure_period = true)
+      setup_default_values(hqmf_contents, use_default_measure_period)
+
+      extract_criteria
+
+      # Extract the population criteria and population collections
+      pop_helper = HQMF2::DocumentPopulationHelper.new(@entry, @doc, self, @id_generator, @reference_ids)
+      @populations, @population_criteria = pop_helper.extract_populations_and_criteria
+
+      # Remove any data criteria from the main data criteria list that already has an equivalent member
+      #  and no references to it. The goal of this is to remove any data criteria that should not
+      #  be purely a source.
+      @data_criteria.reject! do |dc|
+        criteria_covered_by_criteria?(dc)
+      end
+    end
+
+    # Get the title of the measure
+    # @return [String] the title
+    def title
+      @doc.at_xpath('cda:QualityMeasureDocument/cda:title/@value', NAMESPACES).inner_text
+    end
+
+    # Get the description of the measure
+    # @return [String] the description
+    def description
+      description = @doc.at_xpath('cda:QualityMeasureDocument/cda:text/@value', NAMESPACES)
+      description.nil? ? '' : description.inner_text
+    end
+
+    # Get all the population criteria defined by the measure
+    # @return [Array] an array of HQMF2::PopulationCriteria
+    def all_population_criteria
+      @population_criteria
+    end
+
+    # Get a specific population criteria by id.
+    # @param [String] id the population identifier
+    # @return [HQMF2::PopulationCriteria] the matching criteria, raises an Exception if not found
+    def population_criteria(id)
+      find(@population_criteria, :id, id)
+    end
+
+    # Get all the data criteria defined by the measure
+    # @return [Array] an array of HQMF2::DataCriteria describing the data elements used by the measure
+    def all_data_criteria
+      @data_criteria
+    end
+
+    # Get a specific data criteria by id.
+    # @param [String] id the data criteria identifier
+    # @return [HQMF2::DataCriteria] the matching data criteria, raises an Exception if not found
+    def data_criteria(id)
+      find(@data_criteria, :id, id)
+    end
+
+    # Adds data criteria to the Document's criteria list
+    # needed so data criteria can be added to a document from other objects
+    def add_data_criteria(dc)
+      @data_criteria << dc
+    end
+
+    # Finds a data criteria by it's local variable name
+    def find_criteria_by_lvn(local_variable_name)
+      find(@data_criteria, :local_variable_name, local_variable_name)
+    end
+
+    # Get ids of data criteria directly referenced by others
+    # @return [Array] an array of ids of directly referenced data criteria
+    def all_reference_ids
+      @reference_ids
+    end
+
+    # Adds id of a data criteria to the list of reference ids
+    def add_reference_id(id)
+      @reference_ids << id
+    end
+
+    # Parse an XML document from the supplied contents
+    # @return [Nokogiri::XML::Document]
+    def self.parse(hqmf_contents)
+      doc = hqmf_contents.is_a?(Nokogiri::XML::Document) ? hqmf_contents : Nokogiri::XML(hqmf_contents)
+      doc.root.add_namespace_definition('cda', 'urn:hl7-org:v3')
+      doc
+    end
+
+    # Generates this classes hqmf-model equivalent
+    def to_model
+      dcs = all_data_criteria.collect(&:to_model)
+      pcs = all_population_criteria.collect(&:to_model)
+      sdc = source_data_criteria.collect(&:to_model)
+      HQMF::Document.new(@id, @id, @hqmf_set_id, @hqmf_version_number, @cms_id,
+                         title, description, pcs, dcs, sdc,
+                         @attributes, @measure_period, @populations)
+    end
+
+    # Finds an element within the collection given that has an instance variable or method of "attribute" with a value
+    # of "value"
+    def find(collection, attribute, value)
+      collection.find { |e| e.send(attribute) == value }
+    end
+
+    private
+
+    # Handles setup of the base values of the document, defined here as ones that are either
+    #  obtained from the xml directly or with limited parsing
+    def setup_default_values(hqmf_contents, use_default_measure_period)
+      @id_generator = IdGenerator.new
+      @doc = @entry = Document.parse(hqmf_contents)
+
+      @id = attr_val('cda:QualityMeasureDocument/cda:id/@extension') ||
+            attr_val('cda:QualityMeasureDocument/cda:id/@root').upcase
+      @hqmf_set_id = attr_val('cda:QualityMeasureDocument/cda:setId/@extension') ||
+                     attr_val('cda:QualityMeasureDocument/cda:setId/@root').upcase
+      @hqmf_version_number = attr_val('cda:QualityMeasureDocument/cda:versionNumber/@value')
+
+      # TODO: -- figure out if this is the correct thing to do -- probably not, but is
+      # necessary to get the bonnie comparison to work.  Currently
+      # defaulting measure period to a period of 1 year from 2012 to 2013 this is overriden during
+      # calculation with correct year information .  Need to investigate parsing mp from meaures.
+      @measure_period = extract_measure_period_or_default(use_default_measure_period)
+
+      # Extract measure attributes
+      # TODO: Review
+      @attributes = @doc.xpath('/cda:QualityMeasureDocument/cda:subjectOf/cda:measureAttribute', NAMESPACES)
+                    .collect do |attribute|
+        read_attribute(attribute)
+      end
+
+      @data_criteria = []
+      @source_data_criteria = []
+      @data_criteria_references = {}
+      @occurrences_map = {}
+
+      # Used to keep track of referenced data criteria ids
+      @reference_ids = []
+    end
+
+    # Extracts a measure period from the document or returns the default measure period
+    #  (if the default value is set to true).
+    def extract_measure_period_or_default(default)
+      if default
+        mp_low = HQMF::Value.new('TS', nil, '201201010000', nil, nil, nil)
+        mp_high = HQMF::Value.new('TS', nil, '201212312359', nil, nil, nil)
+        mp_width = HQMF::Value.new('PQ', 'a', '1', nil, nil, nil)
+        HQMF::EffectiveTime.new(mp_low, mp_high, mp_width)
+      else
+        measure_period_def = @doc.at_xpath('cda:QualityMeasureDocument/cda:controlVariable/cda:measurePeriod/cda:value',
+                                           NAMESPACES)
+        EffectiveTime.new(measure_period_def).to_model if measure_period_def
+      end
+    end
+
+    # Handles parsing the attributes of the document
+    def read_attribute(attribute)
+      id = attribute.at_xpath('./cda:id/@root', NAMESPACES).try(:value)
+      code = attribute.at_xpath('./cda:code/@code', NAMESPACES).try(:value)
+      name = attribute.at_xpath('./cda:code/cda:displayName/@value', NAMESPACES).try(:value)
+      value = attribute.at_xpath('./cda:value/@value', NAMESPACES).try(:value)
+
+      id_obj = nil
+      if attribute.at_xpath('./cda:id', NAMESPACES)
+        id_obj = HQMF::Identifier.new(attribute.at_xpath('./cda:id/@xsi:type', NAMESPACES).try(:value),
+                                      id,
+                                      attribute.at_xpath('./cda:id/@extension', NAMESPACES).try(:value))
+      end
+
+      code_obj = nil
+      if attribute.at_xpath('./cda:code', NAMESPACES)
+        code_obj, null_flavor, o_text = handle_attribute_code(attribute, code, name)
+
+        # Mapping for nil values to align with 1.0 parsing
+        code = null_flavor if code.nil?
+        name = o_text if name.nil?
+
+      end
+
+      value_obj = nil
+      value_obj = handle_attribute_value(attribute, value) if attribute.at_xpath('./cda:value', NAMESPACES)
+
+      # Handle the cms_id - changed to eCQM in MAT 5.4 (QDM 5.3)
+      @cms_id = "CMS#{value}v#{@hqmf_version_number.to_i}" if (name.include? 'eMeasure Identifier') || (name.include? 'eCQM Identifier')
+
+      HQMF::Attribute.new(id, code, value, nil, name, id_obj, code_obj, value_obj)
+    end
+
+    # Extracts the code used by a particular attribute
+    def handle_attribute_code(attribute, code, name)
+      null_flavor = attribute.at_xpath('./cda:code/@nullFlavor', NAMESPACES).try(:value)
+      o_text = attribute.at_xpath('./cda:code/cda:originalText/@value', NAMESPACES).try(:value)
+      code_obj = HQMF::Coded.new(attribute.at_xpath('./cda:code/@xsi:type', NAMESPACES).try(:value) || 'CD',
+                                 attribute.at_xpath('./cda:code/@codeSystem', NAMESPACES).try(:value),
+                                 code,
+                                 attribute.at_xpath('./cda:code/@valueSet', NAMESPACES).try(:value),
+                                 name,
+                                 null_flavor,
+                                 o_text)
+      [code_obj, null_flavor, o_text]
+    end
+
+    # Extracts the value used by a particular attribute
+    def handle_attribute_value(attribute, value)
+      type = attribute.at_xpath('./cda:value/@xsi:type', NAMESPACES).try(:value)
+      case type
+      when 'II'
+        if value.nil?
+          value = attribute.at_xpath('./cda:value/@extension', NAMESPACES).try(:value)
+        end
+        HQMF::Identifier.new(type,
+                             attribute.at_xpath('./cda:value/@root', NAMESPACES).try(:value),
+                             attribute.at_xpath('./cda:value/@extension', NAMESPACES).try(:value))
+      when 'ED'
+        HQMF::ED.new(type, value, attribute.at_xpath('./cda:value/@mediaType', NAMESPACES).try(:value))
+      when 'CD'
+        HQMF::Coded.new('CD',
+                        attribute.at_xpath('./cda:value/@codeSystem', NAMESPACES).try(:value),
+                        attribute.at_xpath('./cda:value/@code', NAMESPACES).try(:value),
+                        attribute.at_xpath('./cda:value/@valueSet', NAMESPACES).try(:value),
+                        attribute.at_xpath('./cda:value/cda:displayName/@value', NAMESPACES).try(:value))
+      else
+        value.present? ? HQMF::GenericValueContainer.new(type, value) : HQMF::AnyValue.new(type)
+      end
+    end
+
+    def extract_criteria
+      # Extract the data criteria
+      extracted_criteria = []
+      @doc.xpath('cda:QualityMeasureDocument/cda:component/cda:dataCriteriaSection/cda:entry', NAMESPACES)
+        .each do |entry|
+        extracted_criteria << entry
+      end
+
+      # Extract the source data criteria from data criteria
+      @source_data_criteria, collapsed_source_data_criteria = SourceDataCriteriaHelper.get_source_data_criteria_list(
+        extracted_criteria, @data_criteria_references, @occurrences_map)
+
+      extracted_criteria.each do |entry|
+        criteria = DataCriteria.new(entry, @data_criteria_references, @occurrences_map)
+        handle_data_criteria(criteria, collapsed_source_data_criteria)
+        @data_criteria << criteria
+      end
+    end
+
+    def handle_data_criteria(criteria, collapsed_source_data_criteria)
+      # Sometimes there are multiple criteria with the same ID, even though they're different; in the HQMF
+      # criteria refer to parent criteria via outboundRelationship, using an extension (aka ID) and a root;
+      # we use just the extension to follow the reference, and build the lookup hash using that; since they
+      # can repeat, we wind up overwriting some content. This becomes important when we want, for example,
+      # the code_list_id and we overwrite the parent with the code_list_id with a child with the same ID
+      # without the code_list_id. As a temporary approach, we only overwrite a data criteria reference if
+      # it doesn't have a code_list_id. As a longer term approach we may want to use the root for lookups.
+      if criteria && (@data_criteria_references[criteria.id].try(:code_list_id).nil?)
+        @data_criteria_references[criteria.id] = criteria
+      end
+      if collapsed_source_data_criteria.key?(criteria.id)
+        candidate = find(all_data_criteria, :id, collapsed_source_data_criteria[criteria.id])
+        # derived criteria should not be collapsed... they do not have enough info to be collapsed and may cross into the wrong criteria
+        # only add the collapsed as a source for derived if it is stripped of any temporal references, fields, etc. to make sure we don't cross into an incorrect source
+        if ((criteria.definition != 'derived') || (!candidate.nil? && SourceDataCriteriaHelper.already_stripped?(candidate)))
+          criteria.instance_variable_set(:@source_data_criteria, collapsed_source_data_criteria[criteria.id])
+        end
+      end
+
+      handle_variable(criteria, collapsed_source_data_criteria) if criteria.variable
+      handle_specific_source_data_criteria_reference(criteria)
+      @reference_ids.concat(criteria.children_criteria)
+      if criteria.temporal_references
+        criteria.temporal_references.each do |tr|
+          @reference_ids << tr.reference.id if tr.reference.id != HQMF::Document::MEASURE_PERIOD_ID
+        end
+      end
+    end
+
+    # For specific occurrence data criteria, make sure the source data criteria reference points
+    # to the correct source data criteria.
+    def handle_specific_source_data_criteria_reference(criteria)
+      original_sdc = find(@source_data_criteria, :id, criteria.source_data_criteria)
+      updated_sdc = find(@source_data_criteria, :id, criteria.id)
+      if !updated_sdc.nil? && !criteria.specific_occurrence.nil? && (original_sdc.nil? || original_sdc.specific_occurrence.nil?)
+        criteria.instance_variable_set(:@source_data_criteria, criteria.id)
+      end
+      return if original_sdc.nil?
+      if (criteria.specific_occurrence && !original_sdc.specific_occurrence)
+        original_sdc.instance_variable_set(:@specific_occurrence, criteria.specific_occurrence)
+        original_sdc.instance_variable_set(:@specific_occurrence_const, criteria.specific_occurrence_const)
+        original_sdc.instance_variable_set(:@code_list_id, criteria.code_list_id)
+      end
+    end
+
+  end
+end