bonnie_bundler 2.0.0

data/lib/measures/loading/exceptions.rb

@@ -0,0 +1,10 @@
+module Measures
+  class ValueSetException < Exception
+  end
+  class VSACException < Exception
+  end
+  class HQMFException < Exception
+  end
+  class MeasureLoadingException < Exception
+  end
+end 

data/lib/measures/loading/loader.rb

@@ -0,0 +1,178 @@
+module Measures
+  # Utility class for loading measure definitions into the database
+  class Loader
+
+    SOURCE_PATH = File.join(".", "db", "measures")
+    VALUE_SET_PATH = File.join(".", "db", "value_sets")
+    HQMF_VS_OID_CACHE = File.join(".", "db", "hqmf_vs_oid_cache")
+    PARSERS = [HQMF::Parser::V2CQLParser, HQMF::Parser::V2Parser,HQMF::Parser::V1Parser,SimpleXml::Parser::V1Parser]
+
+    def self.parse_hqmf_model(xml_path)
+      xml_contents = Nokogiri::XML(File.new xml_path)
+      parser = get_parser(xml_contents)
+      parser.parse(xml_contents)
+    end
+
+    def self.load_hqmf_model_json(json, user, measure_oids, measure_details=nil)
+
+      measure = Measure.new
+      measure.user = user if user
+      measure.bundle = user.bundle if (user && user.respond_to?(:bundle) )
+      # measure.id = json["hqmf_id"]
+      measure.measure_id = json["id"]
+      measure.hqmf_id = json["hqmf_id"]
+      measure.hqmf_set_id = json["hqmf_set_id"]
+      measure.hqmf_version_number = json["hqmf_version_number"]
+      measure.cms_id = json["cms_id"]
+      measure.title = json["title"]
+      measure.description = json["description"]
+      measure.measure_attributes = json["attributes"]
+      measure.populations = json['populations']
+      measure.value_set_oids = measure_oids
+
+      metadata = measure_details
+      if metadata
+        measure.measure_id = metadata["nqf_id"]
+        measure.type = metadata["type"]
+        measure.category = metadata["category"]
+        measure.episode_of_care = metadata["episode_of_care"]
+        measure.continuous_variable = metadata["continuous_variable"]
+        measure.episode_ids = metadata["episode_ids"]
+        puts "\tWARNING: Episode of care does not align with episode ids existance" if ((!measure.episode_ids.nil? && measure.episode_ids.length > 0) ^ measure.episode_of_care)
+        if (measure.populations.count > 1)
+          sub_ids = ('a'..'az').to_a
+          measure.populations.each_with_index do |population, population_index|
+            sub_id = sub_ids[population_index]
+            population_title = metadata['subtitles'][sub_id] if metadata['subtitles']
+            measure.populations[population_index]['title'] = population_title if population_title
+          end
+        end
+        measure.custom_functions = metadata["custom_functions"]
+        measure.force_sources = metadata["force_sources"]
+      else
+        measure.type = "unknown"
+        measure.category = "Miscellaneous"
+        measure.episode_of_care = false
+        measure.continuous_variable = false
+        puts "\tWARNING: Could not find metadata for measure: #{measure.hqmf_set_id}"
+      end
+
+      measure.population_criteria = json["population_criteria"]
+      measure.data_criteria = json["data_criteria"]
+      measure.source_data_criteria = json["source_data_criteria"]
+      puts "\tCould not find episode ids #{measure.episode_ids} in measure #{measure.cms_id || measure.measure_id}" if (measure.episode_ids && measure.episode_of_care && (measure.episode_ids - measure.source_data_criteria.keys).length > 0)
+      measure.measure_period = json["measure_period"]
+      measure
+    end
+
+    def self.load_hqmf_cql_model_json(json, user, measure_oids, main_cql_library, cql_definition_dependency_structure, elm, elm_annotations, cql, measure_details=nil, value_set_oid_version_objects)
+      measure = CqlMeasure.new
+      measure.user = user if user
+      measure.bundle = user.bundle if (user && user.respond_to?(:bundle))
+      measure.measure_id = json["id"]
+      measure.cql = cql
+      measure.elm = elm
+      measure.elm_annotations = elm_annotations
+      # Add metadata
+      measure.hqmf_id = json["hqmf_id"]
+      measure.hqmf_set_id = json["hqmf_set_id"]
+      measure.hqmf_version_number = json["hqmf_version_number"]
+      measure.cms_id = json["cms_id"]
+      measure.title = json["title"]
+      measure.description = json["description"]
+      measure.measure_attributes = json["attributes"]
+      measure.populations = json['populations']
+      measure.value_set_oids = measure_oids
+      measure.value_set_oid_version_objects = value_set_oid_version_objects
+
+      # Set CQL specific information
+      measure.cql = cql
+      measure.elm = elm
+      measure.main_cql_library = main_cql_library
+      measure.cql_statement_dependencies = cql_definition_dependency_structure
+
+      # Add metadata
+      metadata = measure_details
+      if metadata
+        measure.measure_id = metadata["nqf_id"]
+        measure.type = metadata["type"]
+        measure.category = metadata["category"]
+        measure.episode_of_care = metadata["episode_of_care"]
+        measure.continuous_variable = metadata["continuous_variable"]
+        measure.episode_ids = metadata["episode_ids"]
+        puts "\tWARNING: Episode of care does not align with episode ids existance" if ((!measure.episode_ids.nil? && measure.episode_ids.length > 0) ^ measure.episode_of_care)
+        if (measure.populations.count > 1)
+          sub_ids = ('a'..'az').to_a
+          measure.populations.each_with_index do |population, population_index|
+            sub_id = sub_ids[population_index]
+            population_title = metadata['subtitles'][sub_id] if metadata['subtitles']
+            measure.populations[population_index]['title'] = population_title if population_title
+          end
+        end
+      else
+        measure.type = "unknown"
+        measure.category = "Miscellaneous"
+        measure.episode_of_care = false
+        measure.continuous_variable = false
+        puts "\tWARNING: Could not find metadata for measure: #{measure.hqmf_set_id}"
+      end
+
+      # Set measure population information
+      measure.population_criteria = json["population_criteria"]
+      measure.data_criteria = json["data_criteria"]
+      measure.source_data_criteria = json["source_data_criteria"]
+      puts "\tCould not find episode ids #{measure.episode_ids} in measure #{measure.cms_id || measure.measure_id}" if (measure.episode_ids && measure.episode_of_care && (measure.episode_ids - measure.source_data_criteria.keys).length > 0)
+      measure.measure_period = json["measure_period"]
+      measure.population_criteria = json["population_criteria"]
+      measure.populations_cql_map = json["populations_cql_map"]
+      measure.observations = json["observations"]
+
+      measure
+    end
+
+    def self.save_sources(measure, hqmf_path, html_path, xls_path=nil)
+      # Save original files
+      if (html_path)
+        html_out_path = File.join(SOURCE_PATH, "html")
+        FileUtils.mkdir_p html_out_path
+        FileUtils.cp(html_path, File.join(html_out_path,"#{measure.hqmf_id}.html"))
+      end
+
+      if (xls_path)
+        value_set_out_path = File.join(SOURCE_PATH, "value_sets")
+        FileUtils.mkdir_p value_set_out_path
+        FileUtils.cp(xls_path, File.join(value_set_out_path,"#{measure.hqmf_id}.xls"))
+      end
+
+      hqmf_out_path = File.join(SOURCE_PATH, "hqmf")
+      FileUtils.mkdir_p hqmf_out_path
+      FileUtils.cp(hqmf_path, File.join(hqmf_out_path, "#{measure.hqmf_id}.xml"))
+    end
+
+    def self.parse(xml_contents)
+      doc = xml_contents.kind_of?(Nokogiri::XML::Document) ? xml_contents : Nokogiri::XML(xml_contents)
+      doc
+    end
+
+    def self.clear_sources
+      FileUtils.rm_r File.join(SOURCE_PATH, "html") if File.exist?(File.join(SOURCE_PATH, "html"))
+      FileUtils.rm_r File.join(SOURCE_PATH, "value_sets") if File.exist?(File.join(SOURCE_PATH, "value_sets"))
+      FileUtils.rm_r File.join(SOURCE_PATH, "hqmf") if File.exist?(File.join(SOURCE_PATH, "hqmf"))
+    end
+
+    def self.parse_measures_yml(measures_yml)
+      YAML.load_file(measures_yml)['measures']
+    end
+
+    def self.get_parser(xml_contents)
+      doc = self.parse(xml_contents)
+      PARSERS.each do |p|
+        if p.valid? doc
+          return p.new
+        end
+      end
+      raise "unknown document type"
+    end
+
+  end
+end

data/lib/measures/loading/value_set_loader.rb

@@ -0,0 +1,137 @@
+module Measures
+
+  # Utility class for loading value sets
+  class ValueSetLoader
+
+    def self.save_value_sets(value_set_models, user = nil)
+      #loaded_value_sets = HealthDataStandards::SVS::ValueSet.all.map(&:oid)
+      value_set_models.each do |vsm|
+        HealthDataStandards::SVS::ValueSet.by_user(user).where(oid: vsm.oid).delete_all()
+        vsm.user = user
+        #bundle id for user should always be the same 1 user to 1 bundle
+        #using this to allow cat I generation without extensive modification to HDS
+        vsm.bundle = user.bundle if (user && user.respond_to?(:bundle))
+        vsm.save!
+      end
+    end
+
+    def self.get_value_set_models(value_set_oids, user=nil)
+      HealthDataStandards::SVS::ValueSet.by_user(user).in(oid: value_set_oids)
+    end
+
+    def self.load_value_sets_from_vsac(value_sets, username, password, user=nil, overwrite=false, includeDraft=false, ticket_granting_ticket=nil, use_cache=false, measure_id=nil)
+      # Get a list of just the oids
+      value_set_oids = value_sets.map {|value_set| value_set[:oid]}
+      value_set_models = []
+      from_vsac = 0
+      existing_value_set_map = {}
+      begin
+        backup_vs = []
+        if overwrite
+          backup_vs = get_existing_vs(user, value_set_oids).to_a
+          delete_existing_vs(user, value_set_oids)
+        end
+        nlm_config = APP_CONFIG["nlm"]
+
+        errors = {}
+        api = HealthDataStandards::Util::VSApiV2.new(nlm_config["ticket_url"],nlm_config["api_url"],username, password, ticket_granting_ticket)
+
+        if use_cache
+          codeset_base_dir = Measures::Loader::VALUE_SET_PATH
+          FileUtils.mkdir_p(codeset_base_dir)
+        end
+
+        RestClient.proxy = ENV["http_proxy"]
+        value_sets.each do |value_set|
+          value_set_version = value_set[:version] ? value_set[:version] : "N/A"
+          #When querying vsac via profile, the version is always set to N/A
+          #As such, we can set the version to the profile.
+          #However, a value_set can have a version and profile that are identical, as such the versions that are profiles are denoted as such.
+          value_set_profile = (value_set[:profile] && !includeDraft) ? value_set[:profile] : nlm_config["profile"]
+          value_set_profile = "Profile:#{value_set_profile}"
+
+          query_version = ""
+          if includeDraft
+            query_version = "Draft-#{measure_id}"
+          elsif value_set[:profile]
+            query_version = value_set_profile
+          else
+            query_version = value_set_version
+          end
+          # only access the database if we don't intend on using cached values
+          set = HealthDataStandards::SVS::ValueSet.where({user_id: user.id, oid: value_set[:oid], version: query_version}).first() unless use_cache
+          if (includeDraft && set)
+            set.delete
+            set = nil
+          end
+          if (set)
+            existing_value_set_map[set.oid] = set
+          else
+            vs_data = nil
+
+            # try to access the cached result for the value set if it exists.
+            cached_service_result = File.join(codeset_base_dir,"#{value_set[:oid]}.xml") if use_cache
+            if (cached_service_result && File.exists?(cached_service_result))
+              vs_data = File.read cached_service_result
+            else
+              # If includeDraft is true the latest vs are required, so the latest profile should be used.
+              if includeDraft
+                vs_data = api.get_valueset(value_set[:oid], include_draft: includeDraft, profile: nlm_config["profile"])
+              elsif value_set[:version]
+                vs_data = api.get_valueset(value_set[:oid], version: value_set[:version])
+              else
+                # If no version, call with profile.
+                # If a profile is specified, use it.  Otherwise, use default.
+                profile = value_set[:profile] ? value_set[:profile] : nlm_config["profile"]
+                vs_data = api.get_valueset(value_set[:oid], profile: profile)
+              end
+            end
+            vs_data.force_encoding("utf-8") # there are some funky unicodes coming out of the vs response that are not in ASCII as the string reports to be
+            from_vsac += 1
+            # write all valueset data retrieved if using a cache
+            File.open(cached_service_result, 'w') {|f| f.write(vs_data) } if use_cache
+
+            doc = Nokogiri::XML(vs_data)
+
+            doc.root.add_namespace_definition("vs","urn:ihe:iti:svs:2008")
+
+            vs_element = doc.at_xpath("/vs:RetrieveValueSetResponse/vs:ValueSet|/vs:RetrieveMultipleValueSetsResponse/vs:DescribedValueSet")
+
+            if vs_element && vs_element['ID'] == value_set[:oid]
+              vs_element['id'] = value_set[:oid]
+              set = HealthDataStandards::SVS::ValueSet.load_from_xml(doc)
+              set.user = user
+              #bundle id for user should always be the same 1 user to 1 bundle
+              #using this to allow cat I generation without extensive modification to HDS
+              set.bundle = user.bundle if (user && user.respond_to?(:bundle))
+              # As of t9/7/2017, when valuesets are retrieved from VSAC via profile, their version defaults to N/A
+              # As such, we set the version to the profile with an indicator.
+              set.version = query_version
+              set.save!
+              existing_value_set_map[set.oid] = set
+            else
+              raise "Value set not found: #{oid}"
+            end
+          end
+        end
+      rescue Exception => e
+        if (overwrite)
+          delete_existing_vs(user, value_set_oids)
+          backup_vs.each {|vs| HealthDataStandards::SVS::ValueSet.new(vs.attributes).save }
+        end
+        raise VSACException.new "#{e.message}"
+      end
+
+      puts "\tloaded #{from_vsac} value sets from vsac" if from_vsac > 0
+      existing_value_set_map.values
+    end
+
+    def self.get_existing_vs(user, value_set_oids)
+      HealthDataStandards::SVS::ValueSet.by_user(user).where(oid: {'$in'=>value_set_oids})
+    end
+    def self.delete_existing_vs(user, value_set_oids)
+      get_existing_vs(user, value_set_oids).delete_all()
+    end
+
+  end
+end

data/lib/measures/logic_extractor.rb

@@ -0,0 +1,552 @@
+module HQMF
+  module Measure
+    class LogicExtractor
+
+      POPULATION_MAP = {
+        'STRAT' => 'Stratification',
+        'IPP' => 'Initial Patient Population',
+        'DENOM' => 'Denominator',
+        'NUMER' => 'Numerator',
+        'DENEXCEP' => 'Denominator Exceptions',
+        'DENEX' => 'Denominator Exclusions',
+        'MSRPOPL' => 'Measure Population',
+        'OBSERV' => 'Measure Observations'
+      }
+      AGGREGATOR_MAP = {
+        'MEAN' => 'Mean of',
+        'MEDIAN' => 'Median of'
+      }
+      LOGIC_OPERATOR_MAP = { 'XPRODUCT' => 'AND' }
+      SET_OPERATOR_MAP = {
+        'INTERSECT' => 'Intersection of',
+        'UNION' => 'Union of'
+      }
+      SUBSET_MAP = {
+        'COUNT' => 'COUNT',
+        'FIRST' => 'FIRST',
+        'SECOND' => 'SECOND',
+        'THIRD' => 'THIRD',
+        'FOURTH' => 'FOURTH',
+        'FIFTH' => 'FIFTH',
+        'RECENT' => 'MOST RECENT',
+        'LAST' => 'LAST',
+        'MIN' => 'MIN',
+        'MAX' => 'MAX',
+        'MEAN' => 'MEAN',
+        'MEDIAN' => 'MEDIAN',
+        'TIMEDIFF' => 'Difference between times',
+        'DATEDIFF' => 'Difference between dates',
+        'DATETIMEDIFF' => 'Difference between date/times'
+      }
+      OPERATOR_MAP = {
+        'satisfies_all' => 'SATISFIES ALL',
+        'satisfies_any' => 'SATISFIES ANY'
+      }
+      TIMING_MAP = {
+        'DURING' => 'During',
+        'OVERLAP' => 'Overlaps',
+        'SBS' => 'Starts Before Start of',
+        'SAS' => 'Starts After Start of',
+        'SBE' => 'Starts Before End of',
+        'SAE' => 'Starts After End of',
+        'EBS' => 'Ends Before Start of',
+        'EAS' => 'Ends After Start of',
+        'EBE' => 'Ends Before End of',
+        'EAE' => 'Ends After End of',
+        'SDU' => 'Starts During',
+        'EDU' => 'Ends During',
+        'ECW' => 'Ends Concurrent with',
+        'SCW' => 'Starts Concurrent with',
+        'ECWS' => 'Ends Concurrent with Start of',
+        'SCWE' => 'Starts Concurrent with End of',
+        'SBCW' => 'Starts Before or Concurrent with',
+        'SBCWE' => 'Starts Before or Concurrent with End of',
+        'SACW' => 'Starts After or Concurrent with',
+        'SACWE' => 'Starts After or Concurrent with End of',
+        'SBDU' => 'Starts Before or During',
+        'EBCW' => 'Ends Before or Concurrent with',
+        'EBCWS' => 'Ends Before or Concurrent with Start of',
+        'EACW' => 'Ends After or Concurrent with',
+        'EACWS' => 'Ends After or Concurrent with Start of',
+        'EADU' => 'Ends After or During',
+        'CONCURRENT' => 'Concurrent with'
+      }
+      UNIT_MAP = {
+        'a' => 'year',
+        'mo' => 'month',
+        'wk' => 'week',
+        'd' => 'day',
+        'h' => 'hour',
+        'min' => 'minute',
+        's' => 'second'
+      }
+      CONJUNCTION_MAP = {
+        'allTrue' => 'AND',
+        'atLeastOneTrue' => 'OR'
+      }
+      FLIP_CONJUNCTION_MAP = {
+        'AND' => 'OR',
+        'OR' => 'AND'
+      }
+      SATISFIES_DEFINITIONS = ['satisfies_all','satisfies_any']
+      INTERVAL_DEFINITIONS = ['IVL_PQ', 'IVL_TS']
+      INTERVAL_TYPES_DEFINITIONS = ['PQ', 'TS']
+
+      def precondition_logic(precondition, parent_precondition=nil, parent_negation=false, indent=nil)
+        results = []
+        precondition_key = "precondition_#{precondition['id']}"
+        parent_preocondition_key = "precondition_#{parent_precondition['id']}"
+        conjunction = translate_conjunction(parent_precondition['conjunction_code'])
+        suppress = true if precondition['negation'] && precondition['preconditions'] && precondition['preconditions'].length == 1
+        conjunction = FLIP_CONJUNCTION_MAP[conjunction] if parent_negation
+        comments = precondition['comments'] || []
+        if precondition['reference']
+          data_criteria = @measure['data_criteria'][precondition['reference']]
+          comments.concat data_criteria['comments'] || []
+        end
+        indent ||= ""
+        indent += "\t"
+
+        line = ""
+        unless suppress
+          if comments
+            results.concat comments
+          end
+          line << "#{indent}#{conjunction}"
+          line << " NOT" if parent_negation
+          line << ":"
+          results << line
+        end
+        if precondition['preconditions']
+          results.last << "\n" unless results.blank?
+          precondition['preconditions'].each do |p|
+            results.concat precondition_logic(p, precondition, precondition['negation'], indent)
+          end
+        else
+          results.last << " "
+          results.concat data_criteria_logic(precondition['reference'])
+        end
+
+        results
+      end
+
+      def subset_operator_logic(subset_operator)
+        results = []
+        line = "#{translate_subset(subset_operator['type'])}"
+        if subset_operator['value']
+          unless subset_operator['value']['type'].to_s == 'ANYNonNull'
+            line << "#{value_logic(subset_operator['value'])[0]}"
+          end
+        end
+        line << ": "
+        results << line
+      end
+
+      def value_logic(value, range_comparison=nil)
+        results = []
+
+        is_range = INTERVAL_DEFINITIONS.include?(value['type'])
+        is_equivalent = is_range && value['high'] && value['low'] && (value['high']['value'] == value['low']['value']) && value['high']['inclusive?'] && value['low']['inclusive?']
+        is_value = INTERVAL_TYPES_DEFINITIONS.include?(value['type'])
+        is_any_non_null = value['type'].to_s == 'ANYNonNull'
+        is_ts = value['type'].to_s == 'TS'
+
+        line = ""
+        unless is_any_non_null
+          if is_value
+            line << "#{range_comparison || ''}"
+            line << "=" if value['inclusive?']
+            if is_ts
+              line << translate_date(value['value'])
+            else
+              line << " #{value['value']}"
+            end
+            line << " #{translate_unit(value['unit'], value['value'])}"
+          else
+            if is_range
+              if value['high'] && value['low']
+                if is_equivalent
+                  line = value_logic(value['low'])[0]
+                else
+                  line = "#{value_logic(value['low'], '>')[0]} and #{value_logic(value['high'], '<')[0]}"
+                end
+              else
+                if value['high']
+                  line = " #{value_logic(value['high'], '<')[0]}"
+                else
+                  if value['low']
+                    line = " #{value_logic(value['low'], '>')[0]}"
+                  end
+                end
+              end
+            else
+              line << ": #{translate_oid(value['code_list_id'])}" if value['type'].to_s == 'CD'
+            end
+          end
+        end
+        results << line
+      end
+
+      def satisfies_logic(reference, indent=nil)
+        results = []
+        indent ||= ""
+
+        data_criteria = @measure.data_criteria[reference]
+        root_criteria = @measure.data_criteria[data_criteria['children_criteria'][0]]
+
+        line = ""
+        line << "Occurrence #{root_criteria['specific_occurrence']}:" if root_criteria['specific_occurrence']
+        line << "$" if root_criteria['variable']
+
+        line << "#{root_criteria['description']} #{translate_operator(data_criteria['definition'])}\n"
+        results << line
+        data_criteria['children_criteria'].each do |cc|
+          results << "#{data_criteria_logic(cc, false, true, indent+"\t").join('')}"
+        end
+        if data_criteria['temporal_references']
+          data_criteria['temporal_references'].each do |tr|
+            results << "#{indent+"\t"}#{temporal_reference_logic(tr).join()}"
+          end
+        end
+
+        results
+      end
+
+      def temporal_reference_logic(temporal_reference)
+        results = []
+
+        line = ""
+        line << "#{value_logic(temporal_reference['range'])[0]}" if temporal_reference['range']
+        line << " #{translate_timing(temporal_reference['type'])} "
+        if temporal_reference['reference'].to_s == "MeasurePeriod"
+          line << "\"Measurement Period\""
+        else
+          line << "#{data_criteria_logic(temporal_reference['reference']).join()}"
+        end
+
+        results << line
+      end
+
+      def data_criteria_logic(reference, expand_variable=false, hide_title=nil, indent=nil)
+        results = []
+        indent ||= ""
+
+        data_criteria = @measure.data_criteria[reference]
+        unless data_criteria
+          data_criteria = @measure.source_data_criteria[reference]
+        end
+        data_criteria['key'] ||= reference
+
+
+        if !data_criteria['field_values'].blank?
+          data_criteria['field_values'].each do |key, field|
+            if field.blank?
+              field = {}
+              data_criteria['field_values'][key] = field
+            end
+            field['key'] = key
+            field['key_title'] = translate_field(key)
+          end
+        end
+        # handle field values on data_criteria
+        is_satisfies = SATISFIES_DEFINITIONS.include?(data_criteria['definition'])
+        is_derived = data_criteria['type'].to_s == 'derived'
+        has_children = is_derived && (!data_criteria['variable'] || expand_variable)
+        is_set_op = SET_OPERATOR_MAP.keys.include?(data_criteria['derivation_operator'])
+
+        if data_criteria['subset_operators']
+          data_criteria['subset_operators'].each do |so|
+            results.concat subset_operator_logic(so)
+          end
+        end
+
+        if has_children
+          if is_satisfies
+            results.concat satisfies_logic(data_criteria['key'], indent+"\t")
+          else
+            if data_criteria['children_criteria']
+              if is_set_op
+                unless expand_variable
+                  results << "\n#{indent+"\t\t"}#{translate_set_operator(data_criteria['derivation_operator'])}:"
+                end
+              end
+              line = "#{indent}"
+              data_criteria['children_criteria'].each_with_index do |cc, cc_ind|
+                unless is_set_op
+                  line << "#{translate_logic_operator(data_criteria['derivation_operator'])} : "
+                end
+                data_criteria_logic(cc, false, nil, indent+"\t").each_with_index do |dc, dc_ind|
+                  results << "#{line}\t#{dc}"
+                end
+              end
+              if data_criteria['temporal_references']
+                data_criteria['temporal_references'].each do |tr|
+                  results << "#{indent+"\t\t"}#{temporal_reference_logic(tr).first}"
+                end
+              end
+            end
+          end
+        else
+          line = "#{indent}"
+          line = "" if hide_title && !results.blank?
+          unless hide_title
+            if data_criteria['specific_occurrence']
+              line << "Occurrence #{data_criteria['specific_occurrence']}: "
+            end
+            line << "$" if data_criteria['variable']
+            line << data_criteria['description']
+          end
+          if data_criteria['value']
+            unless data_criteria['type'].to_s == 'characteristic'
+              line << "(result#{value_logic(data_criteria['value'])[0]})"
+            end
+          end
+          if data_criteria['field_values']
+            line << " ( "
+            data_criteria['field_values'].each do |field, fv|
+              line << fv['key_title'] if fv['key_title']
+              line << "#{value_logic(fv)[0]}" if fv['type'] != 'ANYNonNull'
+            end
+            line << " )"
+          end
+          if data_criteria['negation']
+            line << " ( Not Done : #{translate_oid(data_criteria['negation_code_list_id'])} )"
+          end
+
+          results << line
+          if data_criteria['temporal_references']
+            if data_criteria['temporal_references'].length > 1
+              data_criteria['temporal_references'].each do |tr|
+                results << "#{indent}#{temporal_reference_logic(tr)}"
+              end
+            else
+              data_criteria['temporal_references'].each do |tr|
+                results << temporal_reference_logic(tr).first
+              end
+            end
+          end
+        end
+        results.last << "\n" unless results.last.end_with?("\n")
+
+        results
+      end
+
+      def population_criteria_logic(population)
+        results = []
+
+        root_precondition = population['preconditions'][0] if population['preconditions']
+        aggregator = population['aggregator']
+        ( comments = root_precondition.try(:[],'comments') || [] ) | ( population['comments'] || [] )
+        results.concat comments if comments
+        unless root_precondition.blank?
+          if root_precondition['preconditions']
+            root_precondition['preconditions'].each do |precondition|
+              results.concat precondition_logic(precondition, root_precondition, root_precondition['negation'] || false)
+            end
+          else
+            unless aggregator.blank?
+              results << "\t#{translate_aggregator(aggregator)}\n"
+            end
+            results.concat data_criteria_logic(root_precondition['reference'])
+          end
+        else
+          results << "\tNone\n"
+        end
+
+        results
+      end
+
+      def population_logic(measure)
+        results = []
+        @measure = measure
+        populations = @measure.population_criteria.keys
+
+        populations.each do |population|
+          population_results = {:code => population, :lines => []}
+          population_results[:lines] << "\n#{translate_population(population)}\n"
+          population_results[:lines].concat population_criteria_logic(@measure.population_criteria[population])
+          results << population_results
+        end
+        variables_text = variables_logic
+        unless variables_text.blank?
+          variable_results = {:code => "VARIABLES", :lines => variables_text }
+          results << variable_results
+        end
+
+        results
+      end
+
+      def variables_logic
+        results = []
+
+        variables = @measure['source_data_criteria'].select{ |key, attrs| attrs['variable'] == true }
+        has_variables = variables.length > 0
+
+        if has_variables
+          results << "\nVariables\n"
+          variables.each do |title, v|
+            results << "\t$#{v['description']} = \n"
+            results.concat data_criteria_logic(v['source_data_criteria'], true, nil, "\t")
+          end
+        end
+
+        results
+      end
+
+      def translate_population(code)
+        if match = code.match(/(.*)_(\d+)/)
+          "#{POPULATION_MAP[match[1]]} #{match[2].to_i + 1}"
+        else
+          POPULATION_MAP[code]
+        end
+      end
+
+      def translate_aggregator(code)
+        AGGREGATOR_MAP[code]
+      end
+
+      def translate_logic_operator(conjunction)
+        LOGIC_OPERATOR_MAP[conjunction]
+      end
+
+      def translate_set_operator(conjunction)
+        SET_OPERATOR_MAP[conjunction]
+      end
+
+      def translate_field(field_key)
+        HQMF::DataCriteria::FIELDS[field_key][:title]
+      end
+
+      def translate_subset(subset)
+        SUBSET_MAP[subset]
+      end
+
+      def translate_operator(definition)
+        OPERATOR_MAP[definition]
+      end
+
+      def translate_timing(code)
+        TIMING_MAP[code].downcase
+      end
+
+      def translate_unit(unit, value)
+        if UNIT_MAP[unit]
+          UNIT_MAP[unit] + ( value.to_i > 1 ? 's' : '' )
+        else
+          unit
+        end
+      end
+
+      def translate_oid(oid)
+        begin
+          @measure.value_sets.where({:oid => oid}).first.display_name
+        rescue
+          oid
+        end
+      end
+
+      def translate_date(date)
+        date
+      end
+
+      def translate_conjunction(conjunction)
+        CONJUNCTION_MAP[conjunction]
+      end
+
+      ### Diff methods ###
+
+      def self.get_measure_logic_text(measure, by_population=false)
+        return '' if measure.measure_logic.blank?
+        unless by_population
+          lines = ''
+          measure.measure_logic.each do |population|
+            population[:lines].each do |line|
+              lines << "#{line}#{"\n" unless line.ends_with?("\n")}"
+            end
+          end
+          lines
+        else
+          measure_logic_text = []
+          measure.measure_logic.each do |population|
+            measure_logic = {:code => population[:code], :lines => []}
+            lines = ''
+            population[:lines].each do |line|
+              lines << "#{line}#{"\n" unless line.ends_with?("\n")}"
+            end
+            measure_logic[:lines] = lines
+            measure_logic_text << measure_logic
+          end
+          measure_logic_text
+        end
+      end
+
+      def self.get_measure_logic_diff(measure, other, by_population=false)
+        return if other.nil?
+        measure_totals = {:total => 0, :deletions => 0, :insertions => 0, :unchanged => 0}
+        unless by_population
+          compute_diff(get_measure_logic_text(measure), get_measure_logic_text(other), measure_totals)
+        else
+          measure_text = get_measure_logic_text(measure, by_population)
+          other_text = get_measure_logic_text(other, by_population)
+          verify_populations(measure_text, other_text)
+          diff = {:cms_id => measure.cms_id, :populations => [], :totals => {}}
+          measure_text.each_with_index do |population, index|
+            population_totals = {:total => 0, :deletions => 0, :insertions => 0, :unchanged => 0}
+            first = population[:lines]
+            second = other_text.at(index)[:lines]
+            diff[:populations] << compute_diff(first, second, population_totals, population[:code])
+            measure_totals[:total] += population_totals[:total]
+            measure_totals[:deletions] += population_totals[:deletions]
+            measure_totals[:insertions] += population_totals[:insertions]
+            measure_totals[:unchanged] += population_totals[:unchanged]
+          end
+          diff[:totals] = measure_totals
+          diff
+        end
+      end
+
+      private
+
+      def self.compute_diff(text1, text2, totals, code='test')
+        diffs = Diffy::Diff.new(text1, text2, :include_plus_and_minus_in_html => true, :allow_empty_diff => false)
+        # File.write("#{code}.html", "<html>\n<style>#{Diffy::CSS}</style>\n#{diffs.to_s(:html)}\n</html>")
+        results = {:code => code, :lines => []}
+        diffs.each_with_index do |line, ind|
+          case line
+          when /^\+/
+            totals[:insertions] += 1
+            results[:lines] << :ins
+          when /^-/
+            totals[:deletions] += 1
+            results[:lines] << :del
+          else
+            totals[:unchanged] += 1
+            results[:lines] << :unchanged
+          end
+          totals[:total] += 1
+        end
+        results.merge! totals
+      end
+
+      # Make sure we have the same populations in the same order for both measures
+      def self.verify_populations(measure_text, other_text)
+        measure_codes = measure_text.map { |p| p[:code] }
+        other_codes = other_text.map { |p| p[:code] }
+        # First add any missing codes to each
+        (measure_codes - other_codes).each { |code| other_text << { code: code, lines: [] } }
+        (other_codes - measure_codes).each { |code| measure_text << { code: code, lines: [] } }
+        # Then sort each canonically, allowing for NUMER, NUMER_1, etc
+        sorter = proc do |p|
+          if match = p[:code].match(/(.*)_(\d+)/)
+            [HQMF::PopulationCriteria::ALL_POPULATION_CODES.index(match[1]) || Float::INFINITY, match[2].to_i]
+          else
+            [HQMF::PopulationCriteria::ALL_POPULATION_CODES.index(p[:code]) || Float::INFINITY, 0]
+          end
+        end
+        measure_text.sort_by!(&sorter)
+        other_text.sort_by!(&sorter)
+      end
+
+    end
+  end
+end