hqmf2js 1.0.0

data/lib/generator/characteristic.js.erb

@@ -0,0 +1,19 @@
+var value = patient.<%= criteria.property %>(<%= js_for_date_bound(criteria) if criteria.property == :age %>);
+  <%- 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 -%>
+    <%- end -%>
+events.specificContext=Specifics.identity();
+return events;
+  <%- elsif criteria.property == :expired or criteria.property == :clinicalTrialParticipant -%>
+matching = matchingValue(value, 'true');
+matching.specificContext=Specifics.identity();
+return matching
+  <%- else -%>
+matching = matchingValue(value, <%= js_for_bounds(criteria.value) %>);
+matching.specificContext=Specifics.identity();
+return matching;
+  <%- end -%>

data/lib/generator/codes_to_json.rb

@@ -0,0 +1,81 @@
+module HQMF2JS
+  module Generator
+    class CodesToJson      
+      def self.from_xls(code_systems_file)
+        value_sets = HQMF::ValueSet::Parser.new().parse(code_systems_file)
+        from_value_sets(value_sets)
+      end
+      
+      def self.hash_to_js(hash)
+        hash.to_json.gsub(/\"/, "'")
+      end
+      
+      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["code_sets"].each do |code_set|
+            code_sets[code_set["code_set"]] ||= []
+            code_sets[code_set["code_set"]].concat(code_set["codes"])
+          end
+          
+          translation[value_set["oid"]] = code_sets
+        end
+        
+        translation
+      end
+      
+      # Create a new Nokogiri::XML::Document instance by parsing at file at the supplied path
+      # from an IHE SVS XML document then converts into a JSON format. The original XML is of the format:
+      #
+      # Originally formatted like this:
+      # <CodeSystems>
+      #   <ValueSet id="2.16.840.1.113883.3.464.1.14" displayName="birth date">
+      #     <ConceptList xml:lang="en-US">
+      #       <Concept code="00110" codeSystemName="HL7" displayName="Date/Time of birth (TS)"
+      #         codeSystemVersion="3"/>
+      #      </ConceptList>
+      #   </ValueSet>
+      # </CodeSystems>
+      #
+      # The translated JSON will be in this structure:
+      # {
+      #   '2.16.840.1.113883.3.464.1.14' => {
+      #                                       'HL7' => [ 00110 ]
+      #                                     }
+      # }
+      def self.from_xml(code_systems_file)
+        doc = HQMF2JS::Generator::CodesToJson.parse(code_systems_file)
+        translation = {}
+        doc.xpath('//ValueSet').each do |set|
+          set_list = {}
+          set_id = set.at_xpath('@id').value
+            
+          set.xpath('ConceptList').each do |list|
+            list.xpath('Concept').each do |concept|
+              system = concept.at_xpath('@codeSystemName').value
+              code = concept.at_xpath('@code').value
+              
+              codes = set_list[system] || []
+              codes << code
+              set_list[system] = codes
+            end
+          end
+          
+          translation[set_id] = set_list
+        end
+        
+        translation
+      end
+      
+      # Parse an XML document at the supplied path
+      # @return [Nokogiri::XML::Document]
+      def self.parse(path)
+        doc = Nokogiri::XML(File.new(path))
+      end
+      
+    end
+  end
+end

data/lib/generator/converter.rb

@@ -0,0 +1,60 @@
+module HQMF2JS
+  class Converter
+    def self.generate_map_reduce(hqmf_contents, codes=nil)
+      # First compile the CoffeeScript that enables our converted HQMF JavaScript
+      hqmf_utils = HQMF2JS::Generator::JS.library_functions
+
+      if !codes
+        # Parse the code systems that are mapped to the OIDs we support
+        codes_file_path = File.expand_path("../../../test/fixtures/codes/codes.xml", __FILE__)
+        codes = HQMF2JS::Generator::CodesToJson.from_xml(codes_file_path)
+      end
+      codes_json = HQMF2JS::Generator::CodesToJson.hash_to_js(codes)
+
+      # Convert the HQMF document included as a fixture into JavaScript
+      converter = HQMF2JS::Generator::JS.new(hqmf_contents)
+      data_criteria_code = converter.js_for_data_criteria
+      population_criteria_code = HQMF::PopulationCriteria::ALL_POPULATION_CODES.collect do |code|
+        converter.js_for(code, nil, true)
+      end
+      converted_hqmf = [
+        data_criteria_code,
+        population_criteria_code.join("\n")
+      ].join("\n")
+      
+      # Pretty stock map/reduce functions that call out to our converted HQMF code stored in the functions variable
+      map = "function map(patient) {
+  var ipp = hqmfjs.IPP(patient);
+  if (Specifics.validate(ipp)) {
+    emit('ipp', 1);
+    if (Specifics.validate(hqmfjs.DENEX(patient), ipp)) {
+      emit('denex', 1);    
+    } else {
+      var denom = hqmfjs.DENOM(patient);
+      if (Specifics.validate(denom, ipp)) {
+        if (Specifics.validate(hqmfjs.NUMER(patient), denom, ipp)) {
+          emit('denom', 1);
+          emit('numer', 1);
+        } else if (Specifics.validate(hqmfjs.EXCEP(patient), denom, ipp)) {
+          emit('excep', 1);
+        } else {
+          emit('denom', 1);
+          emit('antinum', 1);
+        }
+      }
+    }
+  }
+};"
+      reduce = "function reduce(bucket, counts) {
+  var sum = 0;
+  while(counts.hasNext()){
+    sum += counts.next();
+  }
+  return sum;
+};"
+      functions = "#{hqmf_utils}\nvar OidDictionary = #{codes_json};\n#{converted_hqmf}"
+
+      return { :map => map, :reduce => reduce, :functions => functions }
+    end
+  end
+end

data/lib/generator/data_criteria.js.erb

@@ -0,0 +1,47 @@
+// Measure variables
+<%= js_for_measure_period(measure_period) if measure_period -%>
+<%- all_criteria.select {|c| c.type == :variable}.each do |criteria| -%>
+var <%=  js_name(criteria) %> = <%= js_for_value(criteria.value) %>;
+<%- end -%>
+
+// Data critera
+<%- all_criteria.select {|c| c.type != :variable}.each do |criteria| -%>
+hqmfjs.<%= js_name(criteria) %> = function(patient) {
+  <%- if criteria.type == :characteristic and !criteria.property.nil? -%>
+<%= js_for_characteristic(criteria) %>
+  <%- else -%>
+    <%- if criteria.type != :derived -%>
+<%= js_for_patient_data(criteria) %>
+    <%- else # derived criteria -%>
+<%= js_for_derived_data(criteria) %>
+    <%- end -%>
+    <%- if criteria.value -%>
+  events = filterEventsByValue(events, <%= js_for_bounds(criteria.value) %>);
+    <%- end -%>
+    <%- if criteria.field_values.present?
+          criteria.field_values.keys.each do |field|
+      -%>
+  events = filterEventsByField(events, "<%= field_method(field) %>", <%= js_for_bounds(criteria.field_values[field]) %>);
+    <%-   end
+        end -%>
+    <%- if criteria.temporal_references and criteria.temporal_references.length > 0 -%>
+      <%- 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 -%>
+    <%- else -%>
+        <%- if criteria.specific_occurrence -%>
+  events.specificContext=new Specifics(Row.buildForDataCriteria(events.specific_occurrence, events))
+        <%- else -%>
+  events.specificContext=Specifics.identity()
+        <%- end -%>
+    <%- end -%>
+    <%- if criteria.subset_operators -%>
+      <%- criteria.subset_operators.select {|subset_operator| subset_operator.type}.each do |subset_operator| -%>
+  events = <%= subset_operator.type %>(events<%= ", #{js_for_bounds(subset_operator.value)}" if subset_operator.value %>);
+      <%- end # each operator -%>
+    <%- end # subset operators -%>
+  return events;
+  <%- end # non-characteristic criteria -%>
+}
+
+<%- end -%>

data/lib/generator/derived_data.js.erb

@@ -0,0 +1,5 @@
+  var events = <%= criteria.derivation_operator %>(
+    <%- criteria.children_criteria.each_with_index do |child, index| -%>
+    <%= "hqmfjs.#{child}(patient)" %><%= "," if index<criteria.children_criteria.length-1 %>
+    <%- end -%>
+  );

data/lib/generator/js.rb

@@ -0,0 +1,263 @@
+module HQMF2JS
+  module Generator
+    
+    def self.render_template(name, params)
+      template_path = File.expand_path(File.join('..', "#{name}.js.erb"), __FILE__)
+      template_str = File.read(template_path)
+      template = ERB.new(template_str, nil, '-', "_templ#{TemplateCounter.instance.new_id}")
+      context = ErbContext.new(params)
+      template.result(context.get_binding)        
+    end
+  
+    # Utility class used to supply a binding to Erb. Contains utility functions used
+    # by the erb templates that are used to generate code.
+    class ErbContext < OpenStruct
+    
+      # Create a new context
+      # @param [Hash] vars a hash of parameter names (String) and values (Object).
+      # Each entry is added as an accessor of the new Context
+      def initialize(vars)
+        super(vars)
+      end
+    
+      # Get a binding that contains all the instance variables
+      # @return [Binding]
+      def get_binding
+        binding
+      end
+      
+      def js_for_measure_period(measure_period)
+        HQMF2JS::Generator.render_template('measure_period', {'measure_period' => measure_period})
+      end
+      
+      def js_for_characteristic(criteria)
+        HQMF2JS::Generator.render_template('characteristic', {'criteria' => criteria})
+      end
+      
+      def js_for_patient_data(criteria)
+        HQMF2JS::Generator.render_template('patient_data', {'criteria' => criteria})
+      end
+      
+      def js_for_derived_data(criteria)
+        HQMF2JS::Generator.render_template('derived_data', {'criteria' => criteria})
+      end
+      
+      def field_method(field_name)
+        HQMF::DataCriteria::FIELDS[field_name][:coded_entry_method].to_s.camelize(:lower)
+      end
+      
+      def js_for_value(value)
+        if value
+          if value.respond_to?(:derived?) && value.derived?
+            value.expression
+          else
+            if value.type=='CD'
+              if value.code_list_id
+                "new CodeList(getCodes(\"#{value.code_list_id}\"))"
+              else
+                "new CD(\"#{value.code}\", \"#{value.system}\")"
+              end
+            elsif value.type=='PQ'
+              if value.unit != nil
+                "new PQ(#{value.value}, \"#{value.unit}\", #{value.inclusive?})"
+              else
+                "new PQ(#{value.value}, null, #{value.inclusive?})"
+              end
+            elsif value.type=='ANYNonNull'
+              "new #{value.type}()"
+            elsif value.respond_to?(:unit) && value.unit != nil
+              "new #{value.type}(#{value.value}, \"#{value.unit}\", #{value.inclusive?})"
+            elsif value.respond_to?(:inclusive?) and !value.inclusive?.nil?
+              "new #{value.type}(\"#{value.value}\", null, #{value.inclusive?})"
+            else
+              "new #{value.type}(\"#{value.value}\")"
+            end
+          end
+        else
+          'null'
+        end
+      end
+
+      def js_for_bounds(bounds)
+        if (bounds.respond_to?(:low) && bounds.respond_to?(:high))
+          "new IVL_PQ(#{js_for_value(bounds.low)}, #{js_for_value(bounds.high)})"
+        else
+          "#{js_for_value(bounds)}"
+        end
+      end
+      
+      def js_for_date_bound(criteria)
+        bound = nil
+        if criteria.effective_time
+          if criteria.effective_time.high
+            bound = criteria.effective_time.high
+          elsif criteria.effective_time.low
+            bound = criteria.effective_time.low
+          end
+        elsif criteria.temporal_references
+          # this is a check for age against the measurement period
+          measure_period_reference = criteria.temporal_references.select {|reference| reference.reference and reference.reference.id == HQMF::Document::MEASURE_PERIOD_ID}.first
+          if (measure_period_reference)
+            case measure_period_reference.type
+            when 'SBS','SAS','EBS','EAS'
+              return 'MeasurePeriod.low.asDate()'
+            when 'SBE','SAE','EBE','EAE'
+              return 'MeasurePeriod.high.asDate()'
+            else
+              raise "do not know how to get a date for this type"
+            end
+          end
+        end
+        
+        if bound
+          "#{js_for_value(bound)}.asDate()"
+        else
+          'MeasurePeriod.high.asDate()'
+        end
+      end
+      
+      def js_for_code_list(criteria)
+        if criteria.inline_code_list
+          criteria.inline_code_list.to_json
+        else
+          "getCodes(\"#{criteria.code_list_id}\")"
+        end
+      end
+      
+      # Returns the JavaScript generated for a HQMF::Precondition
+      def js_for_precondition(precondition, indent)
+        HQMF2JS::Generator.render_template('precondition', {'doc' => doc, 'precondition' => precondition, 'indent' => indent})
+      end
+      
+      def patient_api_method(criteria)
+        criteria.patient_api_function
+      end
+      
+      def conjunction_code_for(precondition)
+        precondition.conjunction_code_with_negation
+      end
+      
+      # Returns a Javascript compatable name based on an entity's identifier
+      def js_name(entity)
+        if !entity.id
+          raise "No identifier for #{entity.to_json}"
+        end
+        entity.id.gsub(/\W/, '_')
+      end
+      
+    end
+
+    class JS
+  
+      # Entry point to JavaScript generator
+      def initialize(doc)
+        @doc = doc
+      end
+      
+      def to_js(population_index=0, codes=nil)
+        population_index ||= 0
+        population = @doc.populations[population_index]
+        
+        if codes
+          oid_dictionary = HQMF2JS::Generator::CodesToJson.hash_to_js(codes)
+        else
+          oid_dictionary = "<%= oid_dictionary %>"
+        end
+        
+        "
+        // #########################
+        // ##### DATA ELEMENTS #####
+        // #########################
+
+        OidDictionary = #{oid_dictionary};
+        
+        #{js_for_data_criteria()}
+
+        // #########################
+        // ##### MEASURE LOGIC #####
+        // #########################
+        
+        #{js_initialize_specifics(@doc.source_data_criteria)}
+
+        // INITIAL PATIENT POPULATION
+        #{js_for(population[HQMF::PopulationCriteria::IPP], HQMF::PopulationCriteria::IPP, true)}
+        // DENOMINATOR
+        #{js_for(population[HQMF::PopulationCriteria::DENOM], HQMF::PopulationCriteria::DENOM, true)}
+        // NUMERATOR
+        #{js_for(population[HQMF::PopulationCriteria::NUMER], HQMF::PopulationCriteria::NUMER)}
+        #{js_for(population[HQMF::PopulationCriteria::DENEX], HQMF::PopulationCriteria::DENEX)}
+        #{js_for(population[HQMF::PopulationCriteria::EXCEP], HQMF::PopulationCriteria::EXCEP)}
+        "
+      end
+      
+      def js_initialize_specifics(data_criteria)
+        specific_occurrences = []
+        data_criteria.each do |criteria|
+          if (criteria.specific_occurrence)
+            specific_occurrences << {id: "#{criteria.id}", type: "#{criteria.specific_occurrence_const}", function: "#{criteria.source_data_criteria}"}
+          end
+        end
+        json_list = specific_occurrences.map {|occurrence| occurrence.to_json}
+        specifics_list = json_list.join(',')
+        specifics_list = ",#{specifics_list}" unless specifics_list.empty?
+        "hqmfjs.initializeSpecifics = function(patient_api, hqmfjs) { Specifics.initialize(patient_api,hqmfjs#{specifics_list}) }"
+      end
+      
+      # Generate JS for a HQMF2::PopulationCriteria
+      def js_for(criteria_code, type=nil, when_not_found=false)
+        # for multiple populations, criteria code will be something like IPP_1 and type will be IPP
+        type ||= criteria_code
+        criteria = @doc.population_criteria(criteria_code)
+        if criteria && criteria.preconditions && criteria.preconditions.length > 0
+          HQMF2JS::Generator.render_template('population_criteria', {'doc' => @doc, 'criteria' => criteria, 'type'=>type})
+        else
+          "hqmfjs.#{type} = function(patient) { return new Boolean(#{when_not_found}); }"
+        end
+      end
+      
+      # Generate JS for a HQMF2::DataCriteria
+      def js_for_data_criteria
+        HQMF2JS::Generator.render_template('data_criteria', {'all_criteria' => @doc.specific_occurrence_source_data_criteria.concat(@doc.all_data_criteria), 'measure_period' => @doc.measure_period})
+      end
+      
+      def self.library_functions
+        ctx = Sprockets::Environment.new(File.expand_path("../../..", __FILE__))
+        Tilt::CoffeeScriptTemplate.default_bare = true 
+        ctx.append_path "app/assets/javascripts"
+        
+        ["// #########################\n// ###### PATIENT API #######\n// #########################\n",
+         HqueryPatientApi::Generator.patient_api_javascript.to_s,
+         "// #########################\n// ### LIBRARY FUNCTIONS ####\n// #########################\n",
+         ctx.find_asset('hqmf_util').to_s, 
+         "// #########################\n// ### PATIENT EXTENSION ####\n// #########################\n",
+         ctx.find_asset('patient_api_extension').to_s,
+         "// #########################\n// ##### LOGGING UTILS ######\n// #########################\n",
+         ctx.find_asset('logging_utils').to_s,
+         "// #########################\n// ## SPECIFIC OCCURRENCES ##\n// #########################\n",
+         ctx.find_asset('specifics').to_s].join("\n")
+      end
+  
+    end
+  
+    # Simple class to issue monotonically increasing integer identifiers
+    class Counter
+      def initialize
+        @count = 0
+      end
+      
+      def new_id
+        @count+=1
+      end
+    end
+      
+    # Singleton to keep a count of function identifiers
+    class FunctionCounter < Counter
+      include Singleton
+    end
+    
+    # Singleton to keep a count of template identifiers
+    class TemplateCounter < Counter
+      include Singleton
+    end
+  end
+end

data/lib/generator/measure_period.js.erb

@@ -0,0 +1,18 @@
+var MeasurePeriod = {
+  "low": <%= js_for_value(measure_period.low) %>,
+  "high": <%= js_for_value(measure_period.high) %>
+}
+hqmfjs.MeasurePeriod = function(patient) {
+  return [new hQuery.CodedEntry(
+    {
+      "start_time": MeasurePeriod.low.asDate().getTime()/1000,
+      "end_time": MeasurePeriod.high.asDate().getTime()/1000,
+      "codes": {}
+    }
+  )];
+}
+if (typeof effective_date === 'number') {
+  MeasurePeriod.high.date = new Date(1000*effective_date);
+  MeasurePeriod.low.date = new Date(1000*effective_date);
+  MeasurePeriod.low.date.setFullYear(MeasurePeriod.low.date.getFullYear()-1);
+}

data/lib/generator/patient_data.js.erb

@@ -0,0 +1,22 @@
+  var events = patient.<%= patient_api_method(criteria) %>();
+  <%- if criteria.specific_occurrence -%>
+  events.specific_occurrence = '<%= criteria.source_data_criteria %>'
+  <%- end -%>
+<%- if criteria.status -%>
+  events = events.withStatuses(["<%= criteria.status %>"]<%= ", false" if criteria.hard_status %>);
+<%- end -%>
+<%- if criteria.negation -%>
+  events = events.withNegation(<%= "getCodes(\"#{criteria.negation_code_list_id}\")" if criteria.negation_code_list_id %>);
+<%- else -%>
+  events = events.withoutNegation();
+<%- end -%>
+  var codes = <%= js_for_code_list(criteria) %>;
+  var start = null;
+  var end = null;
+<%- if criteria.effective_time -%>
+  <%- startExp = js_for_value(criteria.effective_time.low) -%>
+  start = <%= startExp %><%= '.asDate()' if startExp != 'null' %>;
+  <%- endExp = js_for_value(criteria.effective_time.high) -%>
+  end = <%= endExp %><%= '.asDate()' if endExp != 'null' %>;
+<%- end -%>
+  events = events.match(codes, start, end, true);

data/lib/generator/population_criteria.js.erb

@@ -0,0 +1,4 @@
+hqmfjs.<%= type %> = function(patient) {
+  return <%= js_for_precondition(criteria, 0) -%>;
+};
+

data/lib/generator/precondition.js.erb

@@ -0,0 +1,14 @@
+<%- if precondition.conjunction? -%>
+<%- if indent>0 -%>
+<%= "\n#{'  '*(indent+1)}#{conjunction_code_for(precondition)}(" -%>
+<%- else -%>
+<%= "#{conjunction_code_for(precondition)}(" -%>
+<%- end -%>
+<%- precondition.preconditions.each_with_index do |child, index| -%>
+<%= "#{'  '*(indent+1)}#{js_for_precondition(child, indent+1)}" -%>
+<%= "," if index < precondition.preconditions.length-1 -%>
+<%- end -%>
+<%= "\n#{'  '*(indent+1)})" -%>
+<%- else -%>
+<%= "\n#{'  '*(indent+1)}hqmfjs.#{js_name(precondition.reference)}(patient)" -%>
+<%- end -%>

data/lib/hqmf2js.rb

@@ -0,0 +1,20 @@
+# Top level include file that brings in all the necessary code
+require 'bundler/setup'
+require 'rubygems'
+require 'erb'
+require 'ostruct'
+require 'singleton'
+require 'json'
+require 'tilt'
+require 'coffee_script'
+require 'sprockets'
+require 'nokogiri'
+
+require 'hqmf-parser'
+
+
+require_relative 'generator/js'
+require_relative 'generator/codes_to_json'
+require_relative 'generator/converter'
+
+Tilt::CoffeeScriptTemplate.default_bare = true

data/lib/hquery/engine.rb

@@ -0,0 +1,4 @@
+module HQMF2JS
+  class Engine < Rails::Engine
+  end
+end

data/lib/tasks/codes.rake

@@ -0,0 +1,12 @@
+namespace :codes do
+  desc 'Convert code systems from XML to JSON'
+  task :convert, [:file] do |t, args|
+    f = args.file
+    codes_to_json = HQMF2JS::Generator::CodesToJson.new(f)
+    
+    Dir.mkdir('tmp') unless Dir.exists?('tmp')
+    File.open('tmp/codes.js', 'w+') do |js_file|
+      js_file.write codes_to_json.json
+    end
+  end
+end

data/lib/tasks/coffee.rake

@@ -0,0 +1,15 @@
+namespace :coffee do
+  desc 'Compile the CoffeeScript library'
+  task :compile do
+    ctx = Sprockets::Environment.new(File.expand_path("../../..", __FILE__))
+    Tilt::CoffeeScriptTemplate.default_bare=true 
+    ctx.append_path "app/assets/javascripts"
+    api = ctx.find_asset('hqmf_util')
+    
+    Dir.mkdir('tmp') unless Dir.exists?( 'tmp')
+    
+    File.open('tmp/hqmf.js', 'w+') do |js_file|
+      js_file.write api
+    end
+  end
+end

data/lib/tasks/convert.rake

@@ -0,0 +1,47 @@
+require 'pathname'
+require 'fileutils'
+
+namespace :hqmf do
+  desc 'Convert a HQMF file to JavaScript'
+  task :convert, [:hqmf,:hqmf_version] do |t, args|
+    
+    raise "The path to the the hqmf xml must be specified" unless args.hqmf
+    
+    FileUtils.mkdir_p File.join(".","tmp",'js')
+    file = File.expand_path(args.hqmf)
+    version = args.hqmf_version || HQMF::Parser::HQMF_VERSION_1
+    filename = Pathname.new(file).basename
+    doc = HQMF::Parser.parse(File.open(file).read, version)
+    
+    gen = HQMF2JS::Generator::JS.new(doc)
+
+    out_file = File.join(".","tmp",'js',"#{filename}.js")
+    
+    File.open(out_file, 'w') do |f| 
+
+      f.write("// #########################\n")
+      f.write("// ##### DATA CRITERIA #####\n")
+      f.write("// #########################\n\n")
+      f.write(gen.js_for_data_criteria())      
+      
+      f.write("// #########################\n")
+      f.write("// ##### POPULATION CRITERIA #####\n")
+      f.write("// #########################\n\n")
+           
+      f.write("// INITIAL PATIENT POPULATION\n")
+      f.write(gen.js_for('IPP'))
+      f.write("// DENOMINATOR\n")
+      f.write(gen.js_for('DENOM'))
+      f.write("// NUMERATOR\n")
+      f.write(gen.js_for('NUMER'))
+      f.write("// EXCLUSIONS\n")
+      f.write(gen.js_for('EXCL'))
+      f.write("// DENOMINATOR EXCEPTIONS\n")
+      f.write(gen.js_for('DENEXCEP'))
+    end
+    
+    puts "wrote javascript to: #{out_file}"
+    
+  end
+end
+    

data/lib/tasks/cover_me.rake

@@ -0,0 +1,8 @@
+namespace :cover_me do
+  
+  task :report do
+    require 'cover_me'
+    CoverMe.complete!
+  end
+  
+end