cqm-parsers 0.1.0

data/lib/hqmf-parser/converter/pass1/population_criteria_converter.rb

@@ -0,0 +1,185 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class PopulationCriteriaConverter
+
+    attr_reader :sub_measures
+
+    def initialize(doc, data_criteria_converter)
+      @doc = doc
+      @data_criteria_converter = data_criteria_converter
+      @population_criteria_by_id = {}
+      @population_criteria_by_key = {}
+      @population_reference = {}
+      parse()
+      build_sub_measures()
+    end
+
+    def population_criteria
+      @population_criteria_by_key.values
+    end
+
+    private
+
+    def build_sub_measures()
+      @sub_measures = []
+      ipps = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::IPP}
+      denoms = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::DENOM}
+      nums = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::NUMER}
+      numexs = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::NUMEX}
+      msrpopls = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::MSRPOPL}
+      observs = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::OBSERV}
+      excls = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::DENEX}
+      denexcs = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::DENEXCEP}
+      msrpoplexs = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::MSRPOPLEX}
+
+      stratifications = @population_criteria_by_id.values.select {|value| value.type == HQMF::PopulationCriteria::STRAT}
+
+      if (ipps.size<=1 and denoms.size<=1 and nums.size<=1 and numexs.size<=1 and excls.size<=1 and denexcs.size<=1 and msrpopls.size<=1 and msrpoplexs.size<=1 and observs.size<=1)
+        sub_measure = {}
+
+        sub_measure[HQMF::PopulationCriteria::IPP] = HQMF::PopulationCriteria::IPP if ipps.size > 0
+        sub_measure[HQMF::PopulationCriteria::DENOM] = HQMF::PopulationCriteria::DENOM if denoms.size > 0
+        sub_measure[HQMF::PopulationCriteria::NUMER] = HQMF::PopulationCriteria::NUMER if nums.size > 0
+        sub_measure[HQMF::PopulationCriteria::NUMEX] = HQMF::PopulationCriteria::NUMEX if numexs.size > 0
+        sub_measure[HQMF::PopulationCriteria::DENEXCEP] = HQMF::PopulationCriteria::DENEXCEP if denexcs.size > 0
+        sub_measure[HQMF::PopulationCriteria::DENEX] = HQMF::PopulationCriteria::DENEX if excls.size > 0
+        sub_measure[HQMF::PopulationCriteria::MSRPOPL] = HQMF::PopulationCriteria::MSRPOPL if msrpopls.size > 0
+        sub_measure[HQMF::PopulationCriteria::OBSERV] = HQMF::PopulationCriteria::OBSERV if observs.size > 0
+        sub_measure[HQMF::PopulationCriteria::MSRPOPLEX] = HQMF::PopulationCriteria::MSRPOPLEX if msrpoplexs.size > 0
+
+        @sub_measures << sub_measure
+      else
+
+        nums.each do |num_id, num|
+          @sub_measures << {HQMF::PopulationCriteria::NUMER => num.id}
+        end
+        msrpopls.each do |popl_id, popl|
+          @sub_measures << {HQMF::PopulationCriteria::MSRPOPL => popl.id}
+        end
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::DENOM, denoms.values)
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::IPP, ipps.values)
+
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::DENEX, excls.values, HQMF::PopulationCriteria::IPP,  get_unmatched_population_keys(ipps, excls))
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::DENEXCEP, denexcs.values, HQMF::PopulationCriteria::DENOM,  get_unmatched_population_keys(denoms, denexcs))
+
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::OBSERV, observs.values)
+
+        keep = []
+
+        @sub_measures.each do |sub|
+
+          value = sub
+          HQMF::PopulationCriteria::ALL_POPULATION_CODES.each do |type|
+            key = sub[type]
+            if (key)
+              reference_id = @population_reference[key]
+              reference = @population_criteria_by_id[reference_id] if reference_id
+              if (reference)
+                criteria = @population_criteria_by_key[sub[reference.type]]
+                value = nil if (sub[reference.type] != reference.id)
+              end
+            end
+          end
+          keep << value if (value)
+        end
+
+        @sub_measures = keep
+
+      end
+
+      # add stratifications if we have them
+      if (stratifications.size > 0)
+        strat_subs = []
+        @sub_measures.each do |sub|
+          stratifications.each do |stratification|
+            new_sub = sub.dup
+            new_sub[HQMF::PopulationCriteria::STRAT] = stratification.id
+            new_sub['stratification'] = stratification.hqmf_id
+            strat_subs << new_sub
+          end
+        end
+        @sub_measures.concat strat_subs
+      end
+
+      if (@sub_measures.length > 1)
+        @sub_measures.each_with_index do |sub, i|
+          sub['title'] = "Population #{i+1}"
+          sub['id'] = "Population#{i+1}"
+        end
+      end
+
+    end
+
+    # source are things like exceptions or exclusions, target are IPP, or denom
+    # we want to find any denoms or IPPs that do not have exceptions or exclusions
+    def get_unmatched_population_keys(target, source)
+      return [] if target.length == source.length
+      all_target_keys = target.values.map(&:id)
+      with_ref_keys = source.values.map(&:id).map {|key| @population_criteria_by_id[@population_reference[key]].id if @population_criteria_by_id[@population_reference[key]]}
+      # if we have a population without a reference, we cannot trust the results.
+      return [] if with_ref_keys.include? nil
+      all_target_keys - with_ref_keys
+    end
+
+    # create a copy of each submeasre adding on the new values of the given type
+    # skip the unpaired values.  Unpaired values are denominators without exclusions or populations without exceptions
+    def apply_to_submeasures(subs, type, values, unpaired_type=nil, unpaired_keys=[])
+      new_subs = []
+      subs.each do |sub|
+        # this unless prevents us from forcing an exclusion or excepion onto a measure that has a submeasure without
+        # an exclusion or exception, but other populations with an exclusion or excepion.
+        unless unpaired_keys.include? sub[unpaired_type]
+          # duplicate each new value if it is set, otherwise set this key on each submeasure.
+          values.each do |value|
+            if (sub[type] and sub[type] != value.id)
+              tmp = {}
+              HQMF::PopulationCriteria::ALL_POPULATION_CODES.each do |key|
+                tmp[key] = sub[key] if sub[key]
+              end
+              sub = tmp
+              new_subs << sub
+            end
+            sub[type] = value.id
+          end
+        end
+      end
+      subs.concat(new_subs)
+    end
+
+    def find_sub_measures(type, value)
+      found = []
+      @sub_measures.each do |sub_measure|
+        found << sub_measure if sub_measure[type] and sub_measure[type] == value.id
+      end
+      found
+    end
+
+    def parse
+      @doc[:logic].each do |key,criteria|
+        @population_criteria_by_key[key] = convert(key.to_s, criteria)
+      end
+    end
+
+    def convert(key, population_criteria)
+
+      # @param [String] id
+      # @param [Array#Precondition] preconditions
+
+      preconditions = HQMF::PreconditionConverter.parse_preconditions(population_criteria[:preconditions],@data_criteria_converter)
+      hqmf_id = population_criteria[:hqmf_id] || population_criteria[:id]
+      id = population_criteria[:id]
+      type = population_criteria[:code]
+      reference = population_criteria[:reference]
+      title = population_criteria[:title]
+
+      criteria = HQMF::Converter::SimplePopulationCriteria.new(key, hqmf_id, type, preconditions, title)
+
+      @population_criteria_by_id[id] = criteria
+      @population_reference[key] = reference
+
+      criteria
+
+    end
+
+  end
+end

data/lib/hqmf-parser/converter/pass1/precondition_converter.rb

@@ -0,0 +1,173 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class PreconditionConverter
+    
+    def self.parse_preconditions(source,data_criteria_converter)
+
+      # preconditions = []
+      # source.each do |precondition|
+      #   preconditions << HQMF::PreconditionConverter.parse_precondition(precondition,data_criteria_converter)
+      # end
+      # 
+      # preconditions
+      
+      parse_and_merge_preconditions(source,data_criteria_converter)
+    end
+   
+    # converts a precondtion to a hqmf model
+    def self.parse_precondition(precondition,data_criteria_converter)
+      
+      # grab child preconditions, and parse recursively
+      preconditions = parse_and_merge_preconditions(precondition[:preconditions],data_criteria_converter) if precondition[:preconditions] || []
+      
+      preconditions_from_restrictions = HQMF::PreconditionExtractor.extract_preconditions_from_restrictions(precondition[:restrictions], data_criteria_converter)
+      
+      # driv preconditions are preconditions that are the children of an expression
+      driv_preconditions = []
+      preconditions_from_restrictions.delete_if {|element| driv_preconditions << element if element.is_a? HQMF::Converter::SimpleRestriction and element.operator.type == 'DRIV'}
+      
+      apply_restrictions_to_comparisons(preconditions, preconditions_from_restrictions) unless preconditions_from_restrictions.empty?
+
+      conjunction_code = convert_logical_conjunction(precondition[:conjunction])
+
+      if (precondition[:expression])
+        # this is for things like COUNT
+        type = precondition[:expression][:type]
+        operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, HQMF::Converter::SimpleOperator.parse_value(precondition[:expression][:value]))
+        children = []
+        if driv_preconditions and !driv_preconditions.empty?
+          children = driv_preconditions.map(&:preconditions).flatten
+        end
+        
+        reference = nil
+        # take the conjunction code from the parent precondition
+        
+        restriction = HQMF::Converter::SimpleRestriction.new(operator, nil, children)
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[restriction],reference,conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+        comparison_precondition.subset_comparison = true
+        preconditions << comparison_precondition
+      end
+      
+      reference = nil
+      
+      negation = precondition[:negation]
+      
+      
+      if (precondition[:comparison])
+        preconditions ||= []
+        comparison_precondition = HQMF::PreconditionExtractor.convert_comparison_to_precondition(precondition[:comparison],data_criteria_converter)
+        preconditions << comparison_precondition
+      end
+
+
+      if (precondition[:subset])
+        # this is for things like FIRST on preconditions
+        type = precondition[:subset]
+        operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, nil)
+        children = preconditions
+        
+        reference = nil
+        # take the conjunction code from the parent precondition
+        
+        restriction = HQMF::Converter::SimpleRestriction.new(operator, nil, children)
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[restriction],reference,conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+        preconditions = [comparison_precondition]
+      end
+
+      
+      HQMF::Converter::SimplePrecondition.new(nil,preconditions,reference,conjunction_code, negation)
+      
+    end
+
+    def self.get_comparison_preconditions(preconditions)
+      comparisons = []
+      preconditions.each do |precondition|
+        if (precondition.comparison? and !precondition.subset_comparison)
+          comparisons << precondition
+        elsif(precondition.has_preconditions?)
+          comparisons.concat(get_comparison_preconditions(precondition.preconditions))
+        else
+          raise "precondition with no comparison or children... not valid"
+        end
+      end
+      comparisons
+    end
+
+    def self.apply_restrictions_to_comparisons(preconditions, restrictions)
+      comparisons = get_comparison_preconditions(preconditions)
+      raise "no comparisons to apply restriction to" if comparisons.empty?
+      comparisons.each do |comparison|
+        comparison.preconditions.concat(restrictions)
+      end
+    end
+    
+    private 
+    
+    
+    def self.parse_and_merge_preconditions(source,data_criteria_converter)
+      return [] unless source and source.size > 0
+      preconditions_by_conjunction = {}
+      source.each do |precondition|
+        parsed = HQMF::PreconditionConverter.parse_precondition(precondition,data_criteria_converter)
+        preconditions_by_conjunction[parsed.conjunction_code] ||= []
+        preconditions_by_conjunction[parsed.conjunction_code]  << parsed
+      end
+      
+      merge_precondtion_conjunction_groups(preconditions_by_conjunction)
+    end
+    
+    def self.merge_precondtion_conjunction_groups(preconditions_by_conjunction)
+      joined = []
+      preconditions_by_conjunction.each do |conjunction_code, preconditions|
+        sub_conditions = []
+        negated_conditions = []
+        preconditions.each do |precondition|
+          unless (precondition.negation)
+            sub_conditions.concat precondition.preconditions if precondition.preconditions
+          else
+            negated_conditions.concat precondition.preconditions if precondition.preconditions
+          end
+        end
+        
+        if (!sub_conditions.empty?)
+          # if we have negated conditions, add them to a new precondition with an inverted conjunction on a negated precondition
+          # the reason we invert the conjunction is because we are turning 
+          # AND: NOT X
+          # AND: NOT Y
+          # into 
+          # NOT: X OR Y
+          # (i.e, demorgan's law)
+          if (!negated_conditions.empty?)
+            inverted_conjunction_code = HQMF::Precondition::INVERSIONS[conjunction_code]
+            sub_conditions << HQMF::Converter::SimplePrecondition.new(nil,negated_conditions,nil,inverted_conjunction_code, true)
+          end
+          joined << HQMF::Converter::SimplePrecondition.new(nil,sub_conditions,nil,conjunction_code, false)
+        elsif (!negated_conditions.empty?)
+          # invert conjunction based on demorgan's law
+          inverted_conjunction_code = HQMF::Precondition::INVERSIONS[conjunction_code]
+          joined << HQMF::Converter::SimplePrecondition.new(nil,negated_conditions,nil,inverted_conjunction_code, true)
+        end
+        
+      end
+      joined
+    end
+    
+    def self.convert_logical_conjunction(code)
+      case code
+        when 'OR'
+          HQMF::Precondition::AT_LEAST_ONE_TRUE
+        when 'AND'
+          HQMF::Precondition::ALL_TRUE
+        else
+          raise "unsupported logical conjunction code conversion: #{code}"
+      end
+      
+    end
+    
+   
+  end  
+end

data/lib/hqmf-parser/converter/pass1/precondition_extractor.rb

@@ -0,0 +1,201 @@
+module HQMF
+  
+  # preconditions can be in several places.
+  #
+  # precondition -> preconditions
+  # restriction -> preconditions
+  #
+  # also, restrictions can be on the following, which can then have preconditions
+  #   restrictions
+  #   comparisons
+  #   preconditions
+  #
+  class PreconditionExtractor
+   
+   
+    def self.extract_preconditions_from_restrictions(restrictions,data_criteria_converter)
+      return [] unless restrictions
+      preconditions = []
+      restrictions.each do |restriction|
+        preconditions.concat(extract_preconditions_from_restriction(restriction,data_criteria_converter))
+      end
+      preconditions      
+    end
+    
+    # get all the preconditions for a restriction
+    # we need to iterate down 
+    #   restriction.preconditions
+    #   restriction.comparison
+    #   restriction.restriction
+    def self.extract_preconditions_from_restriction(restriction,data_criteria_converter)
+      target_id=nil
+      if restriction[:target_id] and data_criteria_converter.v1_data_criteria_by_id[restriction[:target_id]]
+        target_id = data_criteria_converter.v1_data_criteria_by_id[restriction[:target_id]].id
+      elsif restriction[:target_id]
+        puts "\tPrecondition Data Criteria MISSING: #{restriction[:target_id]}"
+      end
+      type = restriction[:type]
+      if (restriction[:negation]) 
+        inverted = HQMF::TemporalReference::INVERSION[type] 
+        if (inverted)
+          type = inverted
+        else
+          puts "\tdon't know how to invert #{type}"
+        end
+      end
+      
+      # if we reference the measurement period, then we want to check if the reference is to the start or end of the measurement period
+      # if we SBS of the END of the measurement period, we want to convert that to SBE of the measurement period
+      if target_id == HQMF::Document::MEASURE_PERIOD_ID
+        references_start = {'SBS'=>'SBE','SAS'=>'SAE','EBS'=>'EBE','EAS'=>'EAE','SCW'=>'SCWE'}
+        references_end = {'EBE'=>'EBS','EAE'=>'EAS','SBE'=>'SBS','SAE'=>'SAS','ECW'=>'ECWS'}
+        if data_criteria_converter.measure_period_v1_keys[:measure_start] == restriction[:target_id] and references_end[type]
+          # before or after the END of the measurement period START.  Convert to before or after the START of the measurement period.
+          # SAE of MPS => SAS of MP
+          # ends concurrent with measurement period START. Convert to concurrent with START of measurement period.
+          # ECW of MPS => ECWS
+          type = references_end[type]
+        elsif data_criteria_converter.measure_period_v1_keys[:measure_end] == restriction[:target_id] and references_start[type]
+          # before or after the START of the measurement period END.  Convert to before or after the END of the measurement period.
+          # SBS of MPE => SBE of MP
+          # starts concurrent with measurement period END. Convert to concurrent with END of measurement period.
+          # SCW of MPE => SCWE
+          type = references_start[type]
+        end
+      end
+      
+      value = nil
+      if (restriction[:range])
+        value = HQMF::Range.from_json(JSON.parse(restriction[:range].to_json)) if (restriction[:range])
+      elsif(restriction[:value])
+        value = HQMF::Converter::SimpleOperator.parse_value(restriction[:value])
+      end
+      field = restriction[:field]
+      field_code = restriction[:field_code]
+      field_time = restriction[:field_time]
+      operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, value, field, field_code, field_time)
+      
+      # get the precondtions off of the restriction
+      children = HQMF::PreconditionConverter.parse_and_merge_preconditions(restriction[:preconditions],data_criteria_converter) if restriction[:preconditions]
+      
+      if restriction[:comparison]
+        children ||= []
+        # check comparison and convert it to a precondition
+        comparison = convert_comparison_to_precondition(restriction[:comparison], data_criteria_converter)
+        children << comparison
+      end
+      
+      # check restrictions
+      restrictions = extract_preconditions_from_restrictions(restriction[:restrictions], data_criteria_converter) if restriction[:restrictions]
+      if (children)
+        HQMF::PreconditionConverter.apply_restrictions_to_comparisons(children, restrictions) unless restrictions.nil? or restrictions.empty?
+      end
+      
+      
+      container = nil
+      # check if there is an expression on the restriction
+      if (restriction[:expression])
+        # this is for things like TIMEDIFF
+        type = restriction[:expression][:type]
+        exp_operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, HQMF::Converter::SimpleOperator.parse_value(restriction[:expression][:value]))
+        preconditions = []
+        
+        driv_preconditions = []
+        restrictions.each {|element| driv_preconditions << element if element.is_a? HQMF::Converter::SimpleRestriction and element.operator.type == 'DRIV'}
+        
+        if driv_preconditions and !driv_preconditions.empty?
+          preconditions = driv_preconditions.map(&:preconditions).flatten
+        end
+      
+        reference = nil
+        conjunction_code = nil
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[HQMF::Converter::SimpleRestriction.new(exp_operator, nil, preconditions)],reference,conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+
+        comparison_precondition.subset_comparison = true
+        container = HQMF::Converter::SimpleRestriction.new(operator, nil, [comparison_precondition])
+      
+      # check if there is a subset on the restriction
+      elsif restriction[:subset]
+        # if we have a subset, we want to create a Comparison Precondition for the subset and have it be the child of the operator on the restriction.
+        # the reason for this is that we want the order of operations to be SBS the FIRST of a data criteria, rather than FIRST of SBS of a data criteria
+        
+        subset_type = restriction[:subset]
+        subset_operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(subset_type), subset_type, nil)
+        
+        reference = nil
+        conjunction_code = nil
+        
+        restriction = HQMF::Converter::SimpleRestriction.new(subset_operator, target_id)
+        restriction.preconditions = children
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil, [restriction], reference, conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+        
+        container = HQMF::Converter::SimpleRestriction.new(operator, nil, [comparison_precondition])
+      else
+        container = HQMF::Converter::SimpleRestriction.new(operator, target_id)
+        # handle transitive restrictions... this is where we are adding a field to a target of a timing restriction
+        if (restrictions && !restrictions.empty? && children.nil?)
+          children = []
+          restrictions.each do |child|
+            comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[child],HQMF::Reference.new(target_id),nil, false)
+            comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+            children << comparison_precondition
+          end
+        end
+        container.preconditions = children
+      end
+      
+      [container]
+    end
+
+
+    # we want the comparisons to be converted to the leaf preconditions
+    def self.convert_comparison_to_precondition(comparison, data_criteria_converter)
+
+      data_criteria = data_criteria_converter.v1_data_criteria_by_id[comparison[:data_criteria_id]]
+      reference = HQMF::Reference.new(data_criteria.id)
+#      conjunction_code = "#{data_criteria.type.to_s.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }}Reference"
+      conjunction_code = nil
+
+      preconditions = []
+      if comparison[:restrictions]
+         # check for preconditions on restrictions
+         preconditions = extract_preconditions_from_restrictions(comparison[:restrictions], data_criteria_converter) 
+      end
+      
+      precondition = HQMF::Converter::SimplePrecondition.new(nil,preconditions,reference,conjunction_code, false)
+      precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+      
+      if (comparison[:subset])
+        # create a restriction for a comparison subset... this is for things like first, second, etc.
+        type = comparison[:subset]
+        operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, nil)
+        restriction = HQMF::Converter::SimpleRestriction.new(operator, reference.id, nil)
+        precondition.preconditions ||= []
+        precondition.preconditions << restriction
+      end
+
+      precondition
+    end
+    
+    # flatten a tree of preconditions into an array... if we are doing something like a count, we just want the flat list
+    def self.flatten_v2_preconditions(preconditions)
+      flattened = []
+      preconditions.each do |precondition|
+        if (precondition.reference and precondition.has_preconditions?)
+          raise "don't know how to handle a condition with a reference that has preconditions" if (precondition.reference and precondition.has_preconditions?)
+        end
+        if (precondition.reference) 
+          flattened << precondition
+        else
+          flattened.concat(flatten_v2_preconditions(precondition.preconditions))
+        end
+      end
+      flattened
+    end
+    
+  end  
+end