hqmf2js 1.2.1 → 1.3.0

data/app/assets/javascripts/patient_api_extension.js.coffee

@@ -7,6 +7,38 @@ hQuery.Patient::allDevices = -> this.conditions().concat(this.procedures()).conc
 hQuery.Patient::activeDiagnoses = -> this.conditions().concat(this.socialHistories()).withStatuses(['active'])
 hQuery.Patient::inactiveDiagnoses = -> this.conditions().concat(this.socialHistories()).withStatuses(['inactive'])
 hQuery.Patient::resolvedDiagnoses = -> this.conditions().concat(this.socialHistories()).withStatuses(['resolved'])
+
+hQuery.Patient::getAndCacheEvents = (key, that, fn, args...) ->
+  this.cache ||= {}
+  if !this.cache[key]
+    this.cache[key] = fn.apply(that, args)
+  this.cache[key]
+hQuery.Patient::getEvents = (eventCriteria) ->
+  cacheKey = eventCriteria.type
+  events = this.getAndCacheEvents(cacheKey, this, this[eventCriteria.type])
+  if eventCriteria.statuses && eventCriteria.statuses.length > 0
+    cacheKey = cacheKey + "_" + String(eventCriteria.statuses)
+    events = this.getAndCacheEvents(cacheKey, events, events.withStatuses, eventCriteria.statuses, eventCriteria.includeEventsWithoutStatus)
+  cacheKey = cacheKey + "_" + String(eventCriteria.negated) + String(eventCriteria.negationValueSetId)
+  if eventCriteria.negated
+    codes = getCodes(eventCriteria.negationValueSetId)
+    events = this.getAndCacheEvents(cacheKey, events, events.withNegation, codes)
+  else
+    events = this.getAndCacheEvents(cacheKey, events, events.withoutNegation)
+  if eventCriteria.valueSetId
+    cacheKey = cacheKey + "_" + String(eventCriteria.valueSetId) + "_" + String(eventCriteria.start) + "_" + String(eventCriteria.stop)
+    codes = getCodes(eventCriteria.valueSetId)
+    events = this.getAndCacheEvents(cacheKey, events, events.match, codes, eventCriteria.start, eventCriteria.stop, true)
+  else if eventCriteria.valueSet
+    events = events.match(eventCriteria.valueSet, eventCriteria.start, eventCriteria.stop, true)
+  events = events.slice(0) # clone cached array before we add on specific occurrence
+  if eventCriteria.specificOccurrence
+    events.specific_occurrence = eventCriteria.specificOccurrence
+  events
+  
+hQuery.Patient::deathdate = ->
+    hQuery.dateFromUtcSeconds this.json["deathdate"]
+
 hQuery.CodedEntry::asIVL_TS = ->
   tsLow = new TS()
   tsLow.date = this.startDate() || this.date() || null
@@ -22,6 +54,59 @@ hQuery.Encounter::lengthOfStay = (unit) ->
   ivl_ts = this.asIVL_TS()
   ivl_ts.low.difference(ivl_ts.high, unit)
 
+hQuery.AdministrationTiming::dosesPerDay = () ->
+  #figure out the units and value and calculate
+  p = this.period()
+  switch(p.unit())
+    when "h" 
+      24/p.value()
+    when "d" 
+      1/p.value()
+
+
+hQuery.Fulfillment::daysInRange = (dateRange,doesPerDay) ->
+  # this will give us the number of days this fullfilment was for
+  totalDays = this.quantityDispensed().value()/doesPerDay
+  totalDays = 0 if isNaN(totalDays)
+  endDate = new Date(this.dispenseDate().getTime() + (totalDays*60*60*24*1000)) 
+  high = if dateRange && dateRange.high then dateRange.high.asDate() else endDate
+  low =  if dateRange && dateRange.low then dateRange.low.asDate() else this.dispenseDate()
+  # from the date it was deispensed add the total number of days to 
+  # get the end date of the fullfillment.  Note that this may not 
+  # be the actual number of days the person took the meds but the 
+  # measure developers and the guidance given around CMD have not been
+  # thought out very well at all.  For reporting this should really just
+  # be done based off of start and end dates and not any sort of tallying of 
+  # doses.  
+  startDiff = TS.daysDifference(low,this.dispenseDate())
+  endDiff =   TS.daysDifference(endDate,high)
+  # startDiff will be - if the start date was before the date range 
+  # so we can trim those first days off the total
+  totalDays += startDiff if startDiff < 0
+  #endDiff will be negative if the end date was after the rage hi value
+  # so we can trim those days off
+  totalDays += endDiff if endDiff < 0
+  #if we have a negative value set it to zero
+  totalDays = 0 if isNaN(totalDays) || totalDays < 0 
+  totalDays
+  
+# Determin sum the cmd for each fullFillment history based on the 
+# date range
+hQuery.Medication::fulfillmentTotals = (dateRange)->
+  dpd = this.administrationTiming().dosesPerDay()
+  this.fulfillmentHistory().reduce (t, s) -> 
+    t + s.daysInRange(dateRange,dpd)
+  , 0  
+  
+hQuery.Medication::cumulativeMedicationDuration = (dateRange) ->
+  #assuming that the dose is the same across fills and that fills is  stated in individual 
+  #doses not total amount. Will need to flush this out more at a later point in time. 
+  #Considering that liquid meds are probaly dispensed as total volume ex 325ml with a dose of 
+  #say 25ml per dose.  Will definatley need to revisit this.  
+  this.fulfillmentTotals(dateRange) if this.administrationTiming()
+
+
+
 hQuery.CodedEntry::respondTo = (functionName) ->
   typeof(@[functionName]) == "function"
 

data/app/assets/javascripts/specifics.js.coffee

@@ -41,7 +41,11 @@ class hqmf.SpecificsManagerSingleton
   
   identity: ->
     new hqmf.SpecificOccurrence([new Row(undefined)])
-    
+
+  setIfNull: (events,subsets) ->
+    if (!events.specificContext? || events.length == 0)
+      events.specificContext=hqmf.SpecificsManager.identity()
+      
   getColumnIndex: (occurrenceID) ->
     columnIndex = @indexLookup[occurrenceID]
     if typeof columnIndex == "undefined"
@@ -54,7 +58,7 @@ class hqmf.SpecificsManagerSingleton
   extractEventsForLeftMost: (rows) ->
     events = []
     for row in rows
-      events.push(@extractEvent(row.leftMost, row))
+      events.push(@extractEvent(row.leftMost, row)) if row.leftMost? || row.tempValue?
     events
   
   extractEvents: (key, rows) ->
@@ -143,7 +147,8 @@ class hqmf.SpecificsManagerSingleton
     
     if negate and (!result.hasRows() or result.hasSpecifics())
       result = result.negate() 
-      # this is a little odd, but it appears when we have a negation with specifics we can ignore the logical result of the negation.  See comment in intersectAll.
+      # this is a little odd, but it appears when we have a negation with specifics we can 
+      # ignore the logical result of the negation.  See comment in intersectAll.
       # we need to verify that we actually have some occurrences
       boolVal = new Boolean(true) if @occurrences.length > 0
     boolVal.specificContext = result
@@ -154,6 +159,13 @@ class hqmf.SpecificsManagerSingleton
     newElement.specificContext = existingElement.specificContext
     newElement.specific_occurrence = existingElement.specific_occurrence
     newElement
+
+  flattenToIds: (specificContext) ->
+    specificContext?.flattenToIds() || []
+
+  storeFinal: (key, result, target) ->
+    target[key] = hqmf.SpecificsManager.flattenToIds(result.specificContext)
+
     
 @hqmf.SpecificsManager = new hqmf.SpecificsManagerSingleton
 
@@ -194,7 +206,17 @@ class hqmf.SpecificOccurrence
     for columnIndex in columnIndices
       for row in @rows
         event = row.values[columnIndex]
-        eventIds.push(event.id) if event != hqmf.SpecificsManager.any and not (event.id in eventIds)
+        if event != hqmf.SpecificsManager.any and not (event.id in eventIds)
+          onlyOneMatch = true
+          # we want to check that we do not have multiple episodes of care matching on this row.  If we do, then that means
+          # that we have a reliance on multiple episodes of care for this row when we can only rely on one.  If we have multiple
+          # then we want to disregard this row.
+          if (columnIndices.length > 1)
+            for columnIndexInside in columnIndices
+              onlyOneMatch = false if (columnIndexInside != columnIndex and row.values[columnIndexInside] != hqmf.SpecificsManager.any)
+
+          if onlyOneMatch
+            eventIds.push(event.id)
     eventIds.length
   
   hasExactRow: (other) ->
@@ -324,20 +346,31 @@ class hqmf.SpecificOccurrence
 
   RECENT: ->
     @applySubset(RECENT)
+
+  hasLeftMost: ->
+    for row in @rows
+      if row.leftMost? || row.tempValue?
+        return true
+    return false
     
   applySubset: (func) ->
-    return this if !@hasSpecifics()
+    return this if !@hasSpecifics() || !@hasLeftMost()
     resultRows = []
     groupedRows = @group()
     for groupKey, group of groupedRows
       entries = func(hqmf.SpecificsManager.extractEventsForLeftMost(group))
-      if entries.length > 0
-        resultRows.push(entries[0].specificRow)
+      resultRows.push(entry.specificRow) for entry in entries
     new hqmf.SpecificOccurrence(resultRows)
   
   addIdentityRow: ->
     @addRows(hqmf.SpecificsManager.identity().rows)
 
+  flattenToIds: ->
+    result = []
+    for row in @rows
+      result.push(row.flattenToIds())
+    result
+
 class Row
   # {'OccurrenceAEncounter':1, 'OccurrenceBEncounter'2}
   constructor: (leftMost, occurrences={}) ->
@@ -438,15 +471,18 @@ class Row
   @buildRowsForMatching: (entryKey, entry, matchesKey, matches) ->
     rows = []
     for match in matches
-      occurrences={}
-      occurrences[entryKey] = entry
+
       # from unions and crossproducts we may have a matches key that is a hash of object ids mapped to the specific occurrence key.
       # this is because we may have multiple different specific occurrences on the right hand side if it came from a group
-      if (_.isObject(matchesKey))
-        occurrences[matchesKey[match.id]] = match
-      else
-        occurrences[matchesKey] = match
-      rows.push(new Row(entryKey, occurrences))
+      # we may also have the same event mapping to multiple occurrences, so if we have a hash the value will be an array.
+      # we make both the UNION and CROSS casses look the same as the standard case by turning the standard into an array
+      matchKeys = (if _.isObject(matchesKey) then matchesKey[match.id] else [matchesKey])
+      if (matchKeys)
+        for matchKey in matchKeys
+          occurrences = {}
+          occurrences[entryKey] = entry
+          occurrences[matchKey] = match
+          rows.push(new Row(entryKey, occurrences))
     rows
     
   # build specific for a given entry (there are no temporal references)
@@ -457,6 +493,16 @@ class Row
       occurrences[entryKey] = entry
       rows.push(new Row(entryKey, occurrences))
     rows
+
+  flattenToIds: ->
+    result = []
+    for value in @values
+      if (value == hqmf.SpecificsManager.any)
+        result.push(value)
+      else
+        result.push(value.id)
+    result
+
   
 @Row = Row
   

data/hqmf2js.gemspec

@@ -7,15 +7,15 @@ Gem::Specification.new do |s|
   s.email = "hquery-talk@googlegroups.com"
   s.homepage = "http://github.com/hquery/hqmf2js"
   s.authors = ["Marc Hadley", "Andre Quina", "Andy Gregorowicz"]
-  s.version = '1.2.1'
+  s.version = '1.3.0'
   
-  s.add_dependency 'nokogiri', '~> 1.5.5'
-  s.add_dependency 'tilt', '~> 1.3.3'
-  s.add_dependency 'coffee-script', '~> 2.2.0'
-  s.add_dependency 'sprockets', '~> 2.2.2'
-  s.add_development_dependency "awesome_print", "~> 1.1.0"
-  s.add_dependency 'health-data-standards', '~> 3.1.1'
-  s.add_dependency 'hquery-patient-api', '~> 1.0.2'
+#  s.add_dependency 'nokogiri', '~> 1.5.5'
+#  s.add_dependency 'tilt', '~> 1.3.3'
+#  s.add_dependency 'coffee-script', '~> 2.2.0'
+#  s.add_dependency 'sprockets', '~> 2.2.2'
+#  s.add_development_dependency "awesome_print", "~> 1.1.0"
+#  s.add_dependency 'health-data-standards', '~> 3.1.1'
+#  s.add_dependency 'hquery-patient-api', '~> 1.0.2'
 
   s.files = s.files = `git ls-files`.split("\n")
 end

data/lib/assets/javascripts/libraries/map_reduce_utils.js

@@ -0,0 +1,130 @@
+// Adds common utility functions to the root JS object. These are then
+// available for use by the map-reduce functions for each measure.
+// lib/qme/mongo_helpers.rb executes this function on a database
+// connection.
+
+var root = this;
+
+root.map = function(record, population, denominator, numerator, exclusion, denexcep, msrpopl, observ, occurrenceId, isContinuousVariable) {
+  var value = {IPP: 0, patient_id: record._id,
+               medical_record_id: record.medical_record_number,
+               first: record.first, last: record.last, gender: record.gender,
+               birthdate: record.birthdate, test_id: record.test_id,
+               provider_performances: record.provider_performances,
+               race: record.race, ethnicity: record.ethnicity, languages: record.languages,
+               payer: extract_payer(record)};
+
+  if (isContinuousVariable) {
+    value = calculateCV(record, population, msrpopl, observ, occurrenceId, value)
+  } else {
+    value = calculate(record, population, denominator, numerator, exclusion, denexcep, occurrenceId, value)
+  }
+
+  if (typeof Logger != 'undefined') {
+    value['logger'] = Logger.logger
+    value['rationale'] = Logger.rationale
+  }
+  
+  value.measure_id = hqmfjs.hqmf_id
+  value.sub_id = hqmfjs.sub_id
+  value.nqf_id = hqmfjs.nqf_id
+  value.effective_date = hqmfjs.effective_date;
+  value.test_id = hqmfjs.test_id;
+
+  if (value.provider_performances) {
+    var tmp = [];
+    for(var i=0; i<value.provider_performances.length; i++) {
+      var performance = value.provider_performances[i];
+      if ((performance['start_date'] <= hqmfjs.effective_date || performance['start_date'] == null) && (performance['end_date'] >= hqmfjs.effective_date || performance['end_date'] == null))
+        tmp.push(performance);
+    }
+    if (tmp.length == 0) tmp = null;
+    value.provider_performances = tmp;
+  } else {
+    value.provider_performances = null;
+  }
+
+  //if (value['IPP'] > 0) emit(ObjectId(), value);
+  emit(ObjectId(), value);
+};
+
+root.extract_payer = function(record) {
+  var payer = {};
+  if(record.insurance_providers && record.insurance_providers.length > 0){
+    var ip = record.insurance_providers[0];
+    if(ip.codes.SOP && ip.codes.SOP.length >0){
+      payer["code"] = ip.codes.SOP[0];
+      payer["codeSystem"] = "SOP";
+    }
+  }
+  return payer;
+};
+
+root.calculate = function(record, population, denominator, numerator, exclusion, denexcep, occurrenceId, value) {
+  
+  finalSpecifics = {};
+  value = _.extend(value, {DENOM: 0, NUMER: 0, DENEXCEP: 0, DENEX: 0, antinumerator: 0, finalSpecifics: finalSpecifics});
+  
+  var ipp = population();
+  hqmf.SpecificsManager.storeFinal('IPP', ipp, finalSpecifics);
+  if (hqmf.SpecificsManager.validate(ipp)) {
+    value.IPP = hqmf.SpecificsManager.countUnique(occurrenceId, ipp);
+    var denom = hqmf.SpecificsManager.intersectSpecifics(denominator(), ipp, occurrenceId);
+    hqmf.SpecificsManager.storeFinal('DENOM', denom, finalSpecifics);
+    if (hqmf.SpecificsManager.validate(denom)) {
+      
+      value.DENOM = hqmf.SpecificsManager.countUnique(occurrenceId, denom);
+      var exclusions = hqmf.SpecificsManager.intersectSpecifics(exclusion(), denom, occurrenceId);
+      hqmf.SpecificsManager.storeFinal('DENEX', exclusions, finalSpecifics);
+      if (hqmf.SpecificsManager.validate(exclusions)) {
+        value.DENEX = hqmf.SpecificsManager.countUnique(occurrenceId, exclusions);
+        denom = hqmf.SpecificsManager.exclude(occurrenceId, denom, exclusions);
+      }
+
+    }
+    // DENEX is a subset of the denominator, so we should set the specifics before the exclusion
+    // hqmf.SpecificsManager.storeFinal('DENOM', denom, finalSpecifics);
+
+    // we need to check the denominator again to make sure we still have viable candidates after 
+    // exclusions have been removed
+    if (hqmf.SpecificsManager.validate(denom)) {
+      var numer = hqmf.SpecificsManager.intersectSpecifics(numerator(), denom, occurrenceId);
+      hqmf.SpecificsManager.storeFinal('NUMER', numer, finalSpecifics);
+      if (hqmf.SpecificsManager.validate(numer)) {
+        value.NUMER = hqmf.SpecificsManager.countUnique(occurrenceId, numer);
+      }
+      
+      var excep = hqmf.SpecificsManager.intersectSpecifics(denexcep(), denom, occurrenceId);
+      hqmf.SpecificsManager.storeFinal('DENEXCEP', excep, finalSpecifics);
+      if (hqmf.SpecificsManager.validate(excep)) {
+        excep = hqmf.SpecificsManager.exclude(occurrenceId, excep, numer);
+        value.DENEXCEP = hqmf.SpecificsManager.countUnique(occurrenceId, excep);
+        denom = hqmf.SpecificsManager.exclude(occurrenceId, denom, excep);
+      }
+      value.antinumerator = value.DENOM-value.NUMER;
+    }
+      
+  }
+  return value;
+};
+
+root.calculateCV = function(record, population, msrpopl, observ, occurrenceId, value) {
+  finalSpecifics = {};
+  value = _.extend(value, {MSRPOPL: 0, values: [], finalSpecifics: finalSpecifics});
+  
+  var ipp = population()
+  hqmf.SpecificsManager.storeFinal('IPP', ipp, finalSpecifics);
+  if (hqmf.SpecificsManager.validate(ipp)) {
+    value.IPP = hqmf.SpecificsManager.countUnique(occurrenceId, ipp);
+    var measurePopulation = hqmf.SpecificsManager.intersectSpecifics(msrpopl(), ipp, occurrenceId);
+    hqmf.SpecificsManager.storeFinal('MSRPOPL', measurePopulation, finalSpecifics);
+    if (hqmf.SpecificsManager.validate(measurePopulation)) {
+      var observations = observ(measurePopulation.specificContext);
+      value.MSRPOPL = hqmf.SpecificsManager.countUnique(occurrenceId, measurePopulation);
+      value.values = observations;
+    }
+  }
+  return value;
+};
+
+ 

data/lib/generator/characteristic.js.erb

@@ -1,19 +1,30 @@
-var value = patient.<%= criteria.property %>(<%= js_for_date_bound(criteria) if criteria.property == :age %>) || null;
-  <%- if criteria.property == :birthtime -%>
-var events = [value];
-    <%- if criteria.temporal_references -%>
-      <%- criteria.temporal_references.each do |temporal_reference| -%>
-events = <%= temporal_reference.type %>(events, hqmfjs.<%= temporal_reference.reference.id %>(patient)<%= ", #{js_for_bounds(temporal_reference.range)}" if temporal_reference.range %>);
-      <%- end -%>
+  var value = patient.<%= criteria.property %>(<%= js_for_date_bound(criteria) if criteria.property == :age %>) || null;
+<%- if criteria.property == :birthtime -%>
+  var events = [value];
+  <%- if criteria.temporal_references -%>
+    <%- criteria.temporal_references.each do |temporal_reference| -%>
+  events = <%= temporal_reference.type %>(events, hqmfjs.<%= temporal_reference.reference.id %>(patient)<%= ", #{js_for_bounds(temporal_reference.range)}" if temporal_reference.range %>);
     <%- end -%>
-events.specificContext=hqmf.SpecificsManager.identity();
-return events;
-  <%- elsif criteria.property == :expired or criteria.property == :clinicalTrialParticipant -%>
-matching = matchingValue(value, 'true');
-matching.specificContext=hqmf.SpecificsManager.identity();
-return matching
-  <%- else -%>
-matching = matchingValue(value, <%= js_for_bounds(criteria.value) %>);
-matching.specificContext=hqmf.SpecificsManager.identity();
-return matching;
   <%- end -%>
+  events.specificContext=hqmf.SpecificsManager.identity();
+  return events;
+ <%- elsif criteria.property == :expired %>
+  var return_value = matchingValue(value, 'true');
+
+    <%- if criteria.temporal_references -%>
+  var events = [patient.deathdate()]; 
+        <%- criteria.temporal_references.each do |temporal_reference| -%>
+  return_value = <%= temporal_reference.type %>(events, hqmfjs.<%= temporal_reference.reference.id %>(patient)<%= ", #{js_for_bounds(temporal_reference.range)}" if temporal_reference.range %>);
+        <%- end -%>
+      <%- end -%>
+return_value.specificContext=hqmf.SpecificsManager.identity();
+return return_value  
+<%- elsif criteria.property == :clinicalTrialParticipant -%>
+  matching = matchingValue(value, 'true');
+  matching.specificContext=hqmf.SpecificsManager.identity();
+  return matching;
+<%- else -%>
+  matching = matchingValue(value, <%= js_for_bounds(criteria.value) %>);
+  matching.specificContext=hqmf.SpecificsManager.identity();
+  return matching;
+<%- end -%>

data/lib/generator/codes_to_json.rb

@@ -1,6 +1,7 @@
 module HQMF2JS
   module Generator
     class CodesToJson      
+
       
       def self.hash_to_js(hash)
         hash.to_json.gsub(/\"/, "'")
@@ -8,16 +9,15 @@ module HQMF2JS
       
       def self.from_value_sets(value_sets)
         # make sure we have a string keyed hash
-        value_sets = JSON.parse(value_sets.to_json)
         translation = {}
         value_sets.each do |value_set|
           code_sets = {}
-          value_set["concepts"].each do |code_set|
-            code_sets[code_set["code_system_name"]] ||= []
-            code_sets[code_set["code_system_name"]].concat(code_set["code"].to_a)
+          value_set.concepts.each do |code_set|
+            code_sets[code_set.code_system_name] ||= []
+            code_sets[code_set.code_system_name].concat(code_set.code.to_a)
           end
           
-          translation[value_set["oid"]] = code_sets
+          translation[value_set.oid] = code_sets
         end
         
         translation

data/lib/generator/data_criteria.js.erb

@@ -8,10 +8,10 @@ var <%=  js_name(criteria) %> = <%= js_for_value(criteria.value) %>;
 <%- all_criteria.select {|c| c.type != :variable}.each do |criteria| -%>
 hqmfjs.<%= js_name(criteria) %> = function(patient, initialSpecificContext) {
   <%- if criteria.type == :characteristic and !criteria.property.nil? -%>
-<%= js_for_characteristic(criteria) %>
+<%= js_for_characteristic(criteria) -%>
   <%- else -%>
     <%- if criteria.type != :derived -%>
-<%= js_for_patient_data(criteria) %>
+<%= js_for_patient_data(criteria) -%>
     <%- else # derived criteria -%>
 <%= js_for_derived_data(criteria) %>
     <%- end -%>
@@ -26,13 +26,13 @@ hqmfjs.<%= js_name(criteria) %> = function(patient, initialSpecificContext) {
     <%- if criteria.temporal_references and criteria.temporal_references.length > 0 -%>
       <%- criteria.temporal_references.each do |temporal_reference| -%>
   if (events.length > 0) events = <%= temporal_reference.type %>(events, hqmfjs.<%= temporal_reference.reference.id %>(patient)<%= ", #{js_for_bounds(temporal_reference.range)}" if temporal_reference.range %>);
-  else events.specificContext=hqmf.SpecificsManager.empty();
       <%- end -%>
-    <%- else -%>
+  if (events.length == 0) events.specificContext=hqmf.SpecificsManager.empty();
+    <%- else # no temporal refs -%>
         <%- if criteria.specific_occurrence -%>
   events.specificContext=new hqmf.SpecificOccurrence(Row.buildForDataCriteria(events.specific_occurrence, events))
         <%- else -%>
-  events.specificContext=hqmf.SpecificsManager.identity()
+  hqmf.SpecificsManager.setIfNull(events);
         <%- end -%>
     <%- end -%>
     <%- if criteria.subset_operators -%>

data/lib/generator/execution.rb

@@ -0,0 +1,144 @@
+module HQMF2JS
+  module Generator
+    class Execution
+
+    
+      def self.quoted_string_array_or_null(arr)
+        if arr
+          quoted = arr.map {|e| "\"#{e}\""}
+          "[#{quoted.join(',')}]"
+        else
+          "null"
+        end
+      end
+
+      # Note that the JS returned by this function is not included when using the in-browser
+      # debugger. See app/views/measures/debug.js.erb for the in-browser equivalent.
+      def self.measure_js(hqmf_document, population_index, options)
+        "function() {
+          var patient = this;
+          var effective_date = <%= effective_date %>;
+          var enable_logging = <%= enable_logging %>;
+          var enable_rationale = <%= enable_rationale %>;
+
+        <% if (!test_id.nil? && test_id.class==Moped::BSON::ObjectId) %>
+          var test_id = new ObjectId(\"<%= test_id %>\");
+        <% else %>
+          var test_id = null;
+        <% end %>
+
+          hqmfjs = {}
+          <%= init_js_frameworks %>
+
+          hqmfjs.effective_date = effective_date;
+          hqmfjs.test_id = test_id;
+      
+          #{logic(hqmf_document, population_index, options)}
+        };
+        "
+      end
+
+
+      def self.logic(hqmf_document, population_index=0, options)
+
+        value_sets=options[:value_sets]
+        episode_ids=options[:episode_ids]
+        continuous_variable=options[:continuous_variable]
+        force_sources=options[:force_sources]
+        custom_functions=options[:custom_functions]
+        check_crosswalk=options[:check_crosswalk]
+
+        gen = HQMF2JS::Generator::JS.new(hqmf_document)
+        codes = HQMF2JS::Generator::CodesToJson.from_value_sets(value_sets) if value_sets
+        force_sources = force_sources
+
+        if check_crosswalk
+          crosswalk_check = "result = hqmf.SpecificsManager.maintainSpecifics(new Boolean(result.isTrue() && patient_api.validateCodeSystems()), result);"
+          crosswalk_instrument = "instrumentTrueCrosswalk(hqmfjs);"
+        end
+
+        
+        "
+        var patient_api = new hQuery.Patient(patient);
+
+        #{gen.to_js(population_index, codes, force_sources)}
+        
+        var occurrenceId = #{quoted_string_array_or_null(episode_ids)};
+
+        hqmfjs.initializeSpecifics(patient_api, hqmfjs)
+        
+        var population = function() {
+          return executeIfAvailable(hqmfjs.#{HQMF::PopulationCriteria::IPP}, patient_api);
+        }
+        var denominator = function() {
+          return executeIfAvailable(hqmfjs.#{HQMF::PopulationCriteria::DENOM}, patient_api);
+        }
+        var numerator = function() {
+          return executeIfAvailable(hqmfjs.#{HQMF::PopulationCriteria::NUMER}, patient_api);
+        }
+        var exclusion = function() {
+          return executeIfAvailable(hqmfjs.#{HQMF::PopulationCriteria::DENEX}, patient_api);
+        }
+        var denexcep = function() {
+          return executeIfAvailable(hqmfjs.#{HQMF::PopulationCriteria::DENEXCEP}, patient_api);
+        }
+        var msrpopl = function() {
+          return executeIfAvailable(hqmfjs.#{HQMF::PopulationCriteria::MSRPOPL}, patient_api);
+        }
+        var observ = function(specific_context) {
+          #{observation_function(custom_functions, population_index)}
+        }
+        
+        var executeIfAvailable = function(optionalFunction, patient_api) {
+          if (typeof(optionalFunction)==='function') {
+            result = optionalFunction(patient_api);
+            #{crosswalk_check}
+            return result;
+          } else {
+            return false;
+          }
+        }
+
+        #{crosswalk_instrument}
+        if (typeof Logger != 'undefined') {
+          // clear out logger
+          Logger.logger = [];
+          Logger.rationale={};
+          if (typeof short_circuit == 'undefined') short_circuit = true;
+        
+          // turn on logging if it is enabled
+          if (enable_logging || enable_rationale) {
+            injectLogger(hqmfjs, enable_logging, enable_rationale, short_circuit);
+          } 
+        }
+
+        try {
+          map(patient, population, denominator, numerator, exclusion, denexcep, msrpopl, observ, occurrenceId,#{continuous_variable});
+        } catch(err) {
+          print(err.stack);
+          throw err;
+        }
+
+        "
+      end
+
+      def self.observation_function(custom_functions, population_index)
+
+        result = "
+          var observFunc = hqmfjs.#{HQMF::PopulationCriteria::OBSERV}
+          if (typeof(observFunc)==='function')
+            return observFunc(patient_api, specific_context);
+          else
+            return [];"
+
+        if (custom_functions && custom_functions[HQMF::PopulationCriteria::OBSERV])
+          result = "return #{custom_functions[HQMF::PopulationCriteria::OBSERV]}(patient_api, hqmfjs)"
+        end
+
+        result
+
+      end
+
+    end
+  end
+end