hqmf-parser 1.0.0

data/lib/hqmf-model/utilities.rb

@@ -0,0 +1,52 @@
+
+module HQMF
+  module Conversion
+    module Utilities
+      def build_hash(source, elements)
+        hash = {}
+        elements.each do |element|
+          value = source.send(element)
+          hash[element] = value unless value.nil?
+        end
+        hash
+      end
+
+      def json_array(elements) 
+        return nil if elements.nil?
+        array = []
+        elements.each do |element| 
+          if (element.is_a? OpenStruct)
+            array << openstruct_to_json(element)
+          else
+            array << element.to_json 
+          end
+        end
+        array.compact!
+        (array.empty?) ? nil : array
+      end
+      
+      def openstruct_to_json(element)
+        json = {}
+        element.marshal_dump.each do |key,value|
+          if value.is_a? OpenStruct
+            json[key] = openstruct_to_json(value) 
+          elsif (value.class.to_s.split("::").first.start_with? 'HQMF')
+            json[key] = value.to_json
+          else
+            json[key] = value
+          end
+        end
+        json
+      end
+      
+      def check_equality(left,right)
+        same = true
+        left.instance_variables.each do |variable|
+          same &&= left.instance_variable_get(variable) == right.instance_variable_get(variable)
+        end
+        same
+      end
+      
+    end
+  end
+end

data/lib/hqmf-parser.rb

@@ -0,0 +1,54 @@
+# require
+require 'nokogiri'
+require 'pry'
+require 'json'
+require 'ostruct'
+require 'health-data-standards'
+
+# require_relative
+require_relative 'hqmf-model/utilities.rb'
+
+require_relative 'hqmf-parser/1.0/utilities'
+require_relative 'hqmf-parser/1.0/range'
+require_relative 'hqmf-parser/1.0/document'
+require_relative 'hqmf-parser/1.0/data_criteria'
+require_relative 'hqmf-parser/1.0/attribute'
+require_relative 'hqmf-parser/1.0/population_criteria'
+require_relative 'hqmf-parser/1.0/precondition'
+require_relative 'hqmf-parser/1.0/restriction'
+require_relative 'hqmf-parser/1.0/comparison'
+require_relative 'hqmf-parser/1.0/expression'
+
+require_relative 'hqmf-parser/2.0/utilities'
+require_relative 'hqmf-parser/2.0/types'
+require_relative 'hqmf-parser/2.0/document'
+require_relative 'hqmf-parser/2.0/data_criteria'
+require_relative 'hqmf-parser/2.0/population_criteria'
+require_relative 'hqmf-parser/2.0/precondition'
+
+require_relative 'hqmf-model/data_criteria.rb'
+require_relative 'hqmf-model/document.rb'
+require_relative 'hqmf-model/population_criteria.rb'
+require_relative 'hqmf-model/precondition.rb'
+require_relative 'hqmf-model/types.rb'
+require_relative 'hqmf-model/attribute.rb'
+
+require_relative 'hqmf-parser/converter/pass1/document_converter'
+require_relative 'hqmf-parser/converter/pass1/data_criteria_converter'
+require_relative 'hqmf-parser/converter/pass1/population_criteria_converter'
+require_relative 'hqmf-parser/converter/pass1/precondition_converter'
+require_relative 'hqmf-parser/converter/pass1/precondition_extractor'
+require_relative 'hqmf-parser/converter/pass1/simple_restriction'
+require_relative 'hqmf-parser/converter/pass1/simple_operator'
+require_relative 'hqmf-parser/converter/pass1/simple_precondition'
+require_relative 'hqmf-parser/converter/pass1/simple_data_criteria'
+require_relative 'hqmf-parser/converter/pass1/simple_population_criteria'
+
+require_relative 'hqmf-parser/converter/pass2/comparison_converter'
+require_relative 'hqmf-parser/converter/pass2/operator_converter'
+
+require_relative 'hqmf-parser/value_sets/value_set_parser'
+
+require_relative 'hqmf-parser/parser'
+
+require_relative 'hqmf-generator/hqmf-generator'

data/lib/hqmf-parser/1.0/attribute.rb

@@ -0,0 +1,68 @@
+module HQMF1
+  # Represents a HQMF measure attribute
+  class Attribute
+  
+    include HQMF1::Utilities
+    
+    # Create a new instance based on the supplied HQMF
+    # @param [Nokogiri::XML::Element] entry the measure attribute element
+    def initialize(entry)
+      @entry = entry
+    end
+
+    # Get the attribute code
+    # @return [String] the code
+    def code
+      if (@entry.at_xpath('./cda:code/@code'))
+        @entry.at_xpath('./cda:code/@code').value
+      elsif @entry.at_xpath('./cda:code/@nullFlavor')
+        @entry.at_xpath('./cda:code/@nullFlavor').value
+      end
+    end
+
+    # Get the attribute name
+    # @return [String] the name
+    def name
+      if (@entry.at_xpath('./cda:code/@displayName'))
+        @entry.at_xpath('./cda:code/@displayName').value
+      elsif @entry.at_xpath('cda:code/cda:originalText')
+        @entry.at_xpath('cda:code/cda:originalText').text
+      end
+    end
+    
+    # Get the attribute id, used elsewhere in the document to refer to the attribute
+    # @return [String] the id
+    def id
+      attr_val('./cda:id/@root')
+    end
+    
+    # Get the attribute value
+    # @return [String] the value
+    def value
+      val = attr_val('./cda:value/@value')
+      val ||= attr_val('./cda:value/@extension')
+      if val
+        val
+      else
+        @entry.at_xpath('./cda:value').inner_text
+      end
+    end
+    
+    # Get the unit of the attribute value or nil if none is defined
+    # @return [String] the unit
+    def unit
+      attr_val('./cda:value/@unit')
+    end
+    
+    # Get a JS friendly constant name for this measure attribute
+    def const_name
+      components = name.gsub(/\W/,' ').split.collect {|word| word.strip.upcase }
+      components.join '_'
+    end
+    
+    def to_json
+      {self.const_name => build_hash(self, [:code,:value,:unit,:name,:id])}
+    end
+    
+  end
+end

data/lib/hqmf-parser/1.0/comparison.rb

@@ -0,0 +1,34 @@
+module HQMF1
+  class Comparison
+  
+    include HQMF1::Utilities
+    
+    attr_reader :restrictions, :data_criteria_id, :title, :subset
+    
+    def initialize(data_criteria_id, entry, parent, doc)
+      @doc = doc
+      @data_criteria_id = data_criteria_id
+      @entry = entry
+      title_def = @entry.at_xpath('./*/cda:title')
+      if title_def
+        @title = title_def.inner_text
+      end
+      @restrictions = []
+      restriction_def = @entry.at_xpath('./*/cda:sourceOf')
+      if restriction_def
+        @entry.xpath('./*/cda:sourceOf').each do |restriction|
+          @restrictions << Restriction.new(restriction, self, @doc)
+        end
+      end
+    end
+    
+    def to_json
+      
+      json = build_hash(self, [:data_criteria_id,:title,:subset])
+      json[:restrictions] = json_array(@restrictions)
+      json
+      
+    end
+    
+  end
+end

data/lib/hqmf-parser/1.0/data_criteria.rb

@@ -0,0 +1,105 @@
+module HQMF1
+  # Represents a data criteria specification
+  class DataCriteria
+  
+    include HQMF1::Utilities
+    
+    attr_accessor :code_list_id, :derived_from, :definition, :status, :negation, :specific_occurrence, :specific_occurrence_const
+  
+    # Create a new instance based on the supplied HQMF entry
+    # @param [Nokogiri::XML::Element] entry the parsed HQMF entry
+    def initialize(entry)
+      @entry = entry
+      
+      template_map = HQMF::DataCriteria.get_template_id_map()
+      oid_xpath_file = File.expand_path('../data_criteria_oid_xpath.json', __FILE__)
+      oid_xpath_map = JSON.parse(File.read(oid_xpath_file))
+      template_id = attr_val('cda:act/cda:templateId/@root') || attr_val('cda:observation/cda:templateId/@root')
+      
+      # check to see if this is a derived data criteria.  These are used for multiple occurrences.
+      derived_entry = @entry.at_xpath('./*/cda:sourceOf[@typeCode="DRIV"]')
+      if derived_entry
+        derived = derived_entry.at_xpath('cda:act/cda:id/@root') || derived_entry.at_xpath('cda:observation/cda:id/@root')
+        @derived_from = derived.value
+        @@occurrences[@derived_from] ||= Counter.new
+        @occurrence_key = @@occurrences[@derived_from].next
+        @specific_occurrence = "#{('A'..'ZZ').to_a[@occurrence_key]}"
+      end
+      
+      template = template_map[template_id]
+      if template
+        @negation=template["negation"]
+        @definition=template["definition"]
+        @status=template["status"]
+        @key=@definition+(@status.empty? ? '' : "_#{@status}")
+      else
+        raise "Unknown data criteria template identifier [#{template_id}]"
+      end
+      
+      # Get the code list OID of the criteria, used as an index to the code list database
+      @code_list_id = attr_val(oid_xpath_map[@key]['oid_xpath'])
+      unless @code_list_id
+        puts "\tcode list id not found, getting default" if !@derived_from
+        @code_list_id = attr_val('cda:act/cda:sourceOf//cda:code/@code')
+      end
+      
+      puts "\tno oid defined for data criteria: #{@key}" if !@code_list_id and !@derived_from
+      
+    end
+    
+    # Get the identifier of the criteria, used elsewhere within the document for referencing
+    # @return [String] the identifier of this data criteria
+    def id
+      attr_val('cda:act/cda:id/@root') || attr_val('cda:observation/cda:id/@root')
+    end
+    
+    # Get the title of the criteria, provides a human readable description
+    # @return [String] the title of this data criteria
+    def title
+      title = description
+      title = "Occurrence #{@specific_occurrence}: #{title}" if @derived_from
+      title
+    end
+    
+    def description
+      if (@entry.at_xpath('.//cda:title'))
+        description = @entry.at_xpath('.//cda:title').inner_text
+      else
+        description = @entry.at_xpath('.//cda:localVariableName').inner_text
+      end
+      description
+    end
+    
+    # Get a JS friendly constant name for this measure attribute
+    def const_name
+      components = title.gsub(/\W/,' ').split.collect {|word| word.strip.upcase }
+      if @derived_from
+        components << @@id.next
+        @specific_occurrence_const = (description.gsub(/\W/,' ').split.collect {|word| word.strip.upcase }).join '_'
+      end
+      components.join '_'
+    end
+    
+    def to_json
+      json = build_hash(self, [:id,:title,:code_list_id,:derived_from,:description, :definition, :status, :negation, :specific_occurrence,:specific_occurrence_const])
+      {
+        self.const_name => json
+      }
+    end
+    
+    # Simple class to issue monotonically increasing integer identifiers
+    class Counter
+      def initialize
+        @count = -1
+      end
+
+      def next
+        @count+=1
+      end
+    end
+    @@id = Counter.new
+    @@occurrences = {}
+
+  end
+  
+end

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

@@ -0,0 +1,209 @@
+module HQMF1
+  # Class representing an HQMF document
+  class Document
+    
+    include HQMF1::Utilities
+    
+    attr_reader :hqmf_id, :hqmf_set_id, :hqmf_version_number
+    
+    # Create a new HQMF1::Document instance by parsing the supplied contents
+    # @param [String] hqmf_contents the contents of an HQMF v1.0 document
+    def initialize(hqmf_contents)
+      @doc = Document.parse(hqmf_contents)
+      @data_criteria = @doc.xpath('//cda:section[cda:code/@code="57025-9"]/cda:entry').collect do |entry|
+        DataCriteria.new(entry)
+      end
+      
+      backfill_derived_code_lists
+      
+      @attributes = @doc.xpath('//cda:subjectOf/cda:measureAttribute').collect do |attr|
+        Attribute.new(attr)
+      end
+      @population_criteria = @doc.xpath('//cda:section[cda:code/@code="57026-7"]/cda:entry').collect do |attr|
+        PopulationCriteria.new(attr, self)
+      end
+
+      @stratification = @doc.xpath('//cda:section[cda:code/@code="69669-0"]/cda:entry').collect do |attr|
+        PopulationCriteria.new(attr, self)
+      end
+      
+      if (@stratification and !@stratification.empty?)
+        initial_populations = @population_criteria.select {|pc| pc.code.starts_with? 'IPP'}
+        initial_populations.each do |population|
+          
+          @stratification.each do |stratification|
+            new_population = HQMF1::PopulationCriteria.new(population.entry, population.doc)
+            new_population.hqmf_id = new_population.id
+            new_population.stratification_id = stratification.id
+            new_population.id = "#{new_population.id}_#{stratification.id}"
+            ids = stratification.preconditions.map(&:id)
+            new_population.preconditions.delete_if {|precondition| ids.include? precondition.id}
+            new_population.preconditions.concat(stratification.preconditions)
+            new_population.preconditions.rotate!(-1*stratification.preconditions.size)
+            @population_criteria << new_population
+          end
+          
+        end
+        
+      end
+      
+      @hqmf_set_id = @doc.at_xpath('//cda:setId/@root').value.upcase
+      @hqmf_id = @doc.at_xpath('//cda:id/@root').value.upcase
+      @hqmf_version_number = @doc.at_xpath('//cda:versionNumber/@value').value.to_i
+      
+    end
+    
+    # Get the title of the measure
+    # @return [String] the title
+    def title
+      @doc.at_xpath('cda:QualityMeasureDocument/cda:title').inner_text
+    end
+    
+    # Get the description of the measure
+    # @return [String] the description
+    def description
+      @doc.at_xpath('cda:QualityMeasureDocument/cda:text').inner_text
+    end
+  
+    # Get all the attributes defined by the measure
+    # @return [Array] an array of HQMF1::Attribute
+    def all_attributes
+      @attributes
+    end
+    
+    # Get a specific attribute by id.
+    # @param [String] id the attribute identifier
+    # @return [HQMF1::Attribute] the matching attribute, raises an Exception if not found
+    def attribute(id)
+      find(@attributes, :id, id)
+    end
+    
+    # Get a specific attribute by code.
+    # @param [String] code the attribute code
+    # @return [HQMF1::Attribute] the matching attribute, raises an Exception if not found
+    def attribute_for_code(code)
+      find(@attributes, :code, code)
+    end
+
+    # Get all the population criteria defined by the measure
+    # @return [Array] an array of HQMF1::PopulationCriteria
+    def all_population_criteria
+      @population_criteria
+    end
+    
+    def stratification
+      @stratification
+    end
+    
+    # Get a specific population criteria by id.
+    # @param [String] id the population identifier
+    # @return [HQMF1::PopulationCriteria] the matching criteria, raises an Exception if not found
+    def population_criteria(id)
+      find(@population_criteria, :id, id)
+    end
+    
+    # Get a specific population criteria by code.
+    # @param [String] code the population criteria code
+    # @return [HQMF1::PopulationCriteria] the matching criteria, raises an Exception if not found
+    def population_criteria_for_code(code)
+      find(@population_criteria, :code, code)
+    end
+
+    # Get all the data criteria defined by the measure
+    # @return [Array] an array of HQMF1::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 [HQMF1::DataCriteria] the matching data criteria, raises an Exception if not found
+    def data_criteria(id)
+      val = find(@data_criteria, :id, id) || raise("unknown data criteria #{id}")
+    end
+    
+    # Parse an XML document from the supplied contents
+    # @return [Nokogiri::XML::Document]
+    def self.parse(hqmf_contents)
+      doc = Nokogiri::XML(hqmf_contents)
+      doc.root.add_namespace_definition('cda', 'urn:hl7-org:v3')
+      doc
+    end
+    
+    # if the data criteria is derived from another criteria, then we want to grab the properties from the derived criteria
+    # this is typically the case with Occurrence A, Occurrence B type data criteria
+    def backfill_derived_code_lists
+      data_criteria_by_id = {}
+      @data_criteria.each {|criteria| data_criteria_by_id[criteria.id] = criteria}
+      @data_criteria.each do |criteria|
+        if (criteria.derived_from)
+          derived_from = data_criteria_by_id[criteria.derived_from]
+          criteria.definition = derived_from.definition
+          criteria.status = derived_from.status
+          criteria.code_list_id = derived_from.code_list_id
+        end
+      end
+    end
+
+    def to_json
+      json = build_hash(self, [:title, :description, :hqmf_id, :hqmf_set_id, :hqmf_version_number])
+      
+      json[:data_criteria] = {}
+      @data_criteria.each do |criteria|
+        criteria_json = criteria.to_json
+        # check if the key already exists... if it does redefine the key
+        if (json[:data_criteria][criteria_json.keys.first])
+          criteria_json = {"#{criteria_json.keys.first}_#{@@ids.next}" => criteria_json.values.first}
+        end
+        json[:data_criteria].merge! criteria_json
+      end
+      
+      json[:metadata] = {}
+      json[:attributes] = {}
+      @attributes.each do |attribute|
+        if (attribute.id)
+          json[:attributes].merge! attribute.to_json
+        else
+          json[:metadata].merge! attribute.to_json
+        end
+          
+      end
+
+      json[:logic] = {}
+      counters = {}
+      @population_criteria.each do |population|
+        population_json = population.to_json
+        key = population_json.keys.first
+        if json[:logic][key]
+          counters[key] ||= 0
+          counters[key] += 1
+          population_json["#{key}_#{counters[key]}"] = population_json[key]
+          population_json.delete(key)
+        end
+        json[:logic].merge! population_json
+      end
+      
+      clean_json_recursive(json)
+      json
+    end
+    
+    private
+    
+    def find(collection, attribute, value)
+      collection.find {|e| e.send(attribute)==value}
+    end
+    
+    # Simple class to issue monotonically increasing integer identifiers
+    class Counter
+      def initialize
+        @count = 0
+      end
+
+      def next
+        @count+=1
+      end
+    end
+    @@ids = Counter.new
+    
+  end
+end