quality-measure-engine 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle
+*.DS_Store
+vendor
+nbproject
+pkg
+.redcar

data/Gemfile

@@ -0,0 +1,18 @@
+source :gemcutter
+
+gem 'mongo'
+gem 'mongomatic'
+gem 'bson_ext'
+gem 'rake'
+gem 'therubyracer', :require => 'v8'
+
+group :test do
+  gem 'rspec'
+  gem 'jsonschema'
+  gem 'awesome_print', :require => 'ap'
+end
+
+group :build do
+  gem 'jeweler'
+end
+

data/Gemfile.lock

@@ -0,0 +1,50 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.1)
+    awesome_print (0.2.1)
+    bson (1.1)
+    bson_ext (1.1.1)
+    diff-lcs (1.1.2)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.6)
+    jsonschema (2.0.0)
+    mongo (1.1)
+      bson (>= 1.0.5)
+    mongomatic (0.5.8)
+      activesupport (>= 2.3.5)
+      bson (= 1.1)
+      mongo (= 1.1)
+    rake (0.8.7)
+    rspec (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+      rspec-mocks (= 2.0.0)
+    rspec-core (2.0.0)
+    rspec-expectations (2.0.0)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    therubyracer (0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  bson_ext
+  jeweler
+  jsonschema
+  mongo
+  mongomatic
+  rake
+  rspec
+  therubyracer

data/README.md

@@ -0,0 +1,24 @@
+This project will provide a library that can ingest HITSP C32's and ASTM CCR's and extract values needed to compute heath quality measures for a population. It will then be able to query over a population to compute how many people within a population conform to the measure.
+
+Environment
+-----------
+
+This project currently uses Ruby 1.9.2 and is built using [Bundler](http://gembundler.com/). To get all of the dependencies for the project, first install bundler:
+
+    gem install bundler
+
+Then run bundler to grab all of the necessay gems:
+
+    bundle install
+
+Testing
+-------
+
+This project uses [RSpec](http://github.com/rspec/rspec-core) for testing. To run the suite, just enter the following:
+
+    rake spec
+
+Project Practices
+------------------
+
+Please try to follow our [Coding Style Guides](http://github.com/eedrummer/styleguide). Additionally, we will be using git in a pattern similar to [Vincent Driessen's workflow](http://nvie.com/posts/a-successful-git-branching-model/). While feature branches are encouraged, they are not required to work on the project.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rspec/core/rake_task'
+require 'jeweler'
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+Jeweler::Tasks.new do |gem|
+  gem.name = "quality-measure-engine"
+  gem.summary = "A library for extracting quality measure information from HITSP C32's and ASTM CCR's"
+  gem.description = "A library for extracting quality measure information from HITSP C32's and ASTM CCR's"
+  gem.email = "talk@projectpophealth.org"
+  gem.homepage = "http://github.com/pophealth/quality-measure-engine"
+  gem.authors = ["Marc Hadley", "Andy Gregorowicz"]
+  
+  gem.add_dependency 'mongo', '~> 1.1'
+  gem.add_dependency 'mongomatic', '~> 0.5.8'
+  gem.add_dependency 'therubyracer', '~> 0.7.5'
+  gem.add_dependency 'bson_ext', '~> 1.1.1'
+  
+  gem.add_development_dependency "jsonschema", "~> 2.0.0"
+  gem.add_development_dependency "rspec", "~> 2.0.0"
+  gem.add_development_dependency "awesome_print", "~> 0.2.1"
+  gem.add_development_dependency "jeweler", "~> 1.4.0"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/fixtures/complex_measure.json

@@ -0,0 +1,36 @@
+{
+  "id": "0043",
+  "name": "Pneumonia Vaccination Status for Older Adults",
+  "steward": "NCQA",
+  "population": {
+    "and": [
+      {
+        "category": "Patient Characteristic",
+        "title": "Age > 17 before measure period",
+        "query": {"age": {"_gt": 17}}
+      },
+      {
+        "category": "Patient Characteristic",
+        "title": "Age < 75 before measure period",
+        "query": {"age": {"_lt": 75}}
+      },
+      {
+        "or": [
+          {
+            "category": "Patient Characteristic",
+            "title": "Male",
+            "query": {"sex": "male"}
+          },
+          {
+            "category": "Patient Characteristic",
+            "title": "Female",
+            "query": {"sex": "female"}
+          }
+        ]
+      }
+    ]
+  },
+  "denominator": {},
+  "numerator": {},
+  "exception": {}
+}

data/fixtures/result_example.json

@@ -0,0 +1,6 @@
+{
+  "initialPopulation": 50,
+  "denominator": 45,
+  "numerator": [35],
+  "exclusions": [5]
+}

data/lib/patches/v8.rb

@@ -0,0 +1,20 @@
+# Patching V8::Object because it is the entry point for conversions
+# between Ruby and JavaScript types. We are using seconds since the
+# epoch to represent dates. On 32 bit architectures, for recent dates
+# this will be too large for Fixnum and become a Bignum. Ruby Racer
+# worn't properly convert a Bignum to JavaScript, but it will work
+# just fine for a Float. Because of this, we will convert all Bignums
+# passed into a JavaScript context to a Float
+module V8
+  class Object
+    alias :old_index_setter :'[]='
+    
+    def []=(key, value)
+      if value.kind_of?(Bignum)
+        old_index_setter(key, value.to_f)
+      else
+        old_index_setter(key, value)
+      end
+    end
+  end
+end

data/lib/qme/map/map_reduce_builder.rb

@@ -0,0 +1,169 @@
+module QME
+  module MapReduce
+    class Builder
+      attr_reader :id, :parameters
+
+      YEAR_IN_SECONDS = 365*24*60*60
+
+      def initialize(measure_def, params)
+        @measure_def = measure_def
+        @id = measure_def['id']
+        @parameters = {}
+        measure_def['parameters'] ||= {}
+        measure_def['parameters'].each do |parameter, value|
+          if !params.has_key?(parameter.intern)
+            raise "No value supplied for measure parameter: #{parameter}"
+          end
+          @parameters[parameter.intern] = params[parameter.intern]
+        end
+        ctx = V8::Context.new
+        ctx['year']=YEAR_IN_SECONDS
+        @parameters.each do |key, param|
+          ctx[key]=param
+        end
+        measure_def['calculated_dates'] ||= {}
+        measure_def['calculated_dates'].each do |parameter, value|
+          @parameters[parameter.intern]=ctx.eval(value)
+        end
+        @property_prefix = 'this.measures["'+@id+'"].'
+      end
+
+      def map_function
+        "function () {\n" +
+        "  var value = {i: 0, d: 0, n: 0, e: 0};\n" +
+        "  if #{population} {\n" +
+        "    value.i++;\n" +
+        "    if #{denominator} {\n" +
+        "      value.d++;\n" +
+        "      if #{numerator} {\n" +
+        "        value.n++;\n" +
+        "      } else if #{exception} {\n" +
+        "        value.e++;\n" +
+        "        value.d--;\n" +
+        "      }\n" +
+        "    }\n" +
+        "  }\n" +
+        "  emit(null, value);\n" +
+        "};\n"
+      end
+
+      REDUCE_FUNCTION = <<END_OF_REDUCE_FN
+function (key, values) {
+  var total = {i: 0, d: 0, n: 0, e: 0};
+  for (var i = 0; i < values.length; i++) {
+    total.i += values[i].i;
+    total.d += values[i].d;
+    total.n += values[i].n;
+    total.e += values[i].e;
+  }
+  return total;
+};
+END_OF_REDUCE_FN
+
+      def reduce_function
+        REDUCE_FUNCTION
+      end
+
+      def population
+        javascript(@measure_def['population'])
+      end
+
+      def denominator
+        javascript(@measure_def['denominator'])
+      end
+
+      def numerator
+        javascript(@measure_def['numerator'])
+      end
+
+      def exception
+        javascript(@measure_def['exception'])
+      end
+
+      def javascript(expr)
+        if expr.has_key?('query')
+          # leaf node
+          query = expr['query']
+          triple = leaf_expr(query)
+          property_name = munge_property_name(triple[0])
+          '('+property_name+triple[1]+triple[2]+')'
+        elsif expr.size==1
+          operator = expr.keys[0]
+          result = logical_expr(operator, expr[operator])
+          operator = result.shift
+          js = '('
+          result.each_with_index do |operand,index|
+            if index>0
+              js+=operator
+            end
+            js+=operand
+          end
+          js+=')'
+          js
+        elsif expr.size==0
+          '(false)'
+        else
+          throw "Unexpected number of keys in: #{expr}"
+        end
+      end
+
+      def munge_property_name(name)
+        if name=='birthdate'
+          'this.'+name
+        else
+          @property_prefix+name
+        end
+      end
+
+      def logical_expr(operator, args)
+        operands = args.collect { |arg| javascript(arg) }
+        [get_operator(operator)].concat(operands)
+      end
+
+      def leaf_expr(query)
+        property_name = query.keys[0]
+        property_value_expression = query[property_name]
+        if property_value_expression.kind_of?(Hash)
+          operator = property_value_expression.keys[0]
+          value = property_value_expression[operator]
+          [property_name, get_operator(operator), get_value(value)]
+        else
+          [property_name, '==', get_value(property_value_expression)]
+        end
+      end
+
+      def get_operator(operator)
+        case operator
+        when '_eql'
+          '=='
+        when '_gt'
+          '>'
+        when '_gte'
+          '>='
+        when '_lt'
+          '<'
+        when '_lte'
+          '<='
+        when 'and'
+          '&&'
+        when 'or'
+          '||'
+        else
+          throw "Unknown operator: #{operator}"
+        end
+      end
+
+      def get_value(value)
+        if value.kind_of?(String) && value[0]=='@'
+          @parameters[value[1..-1].intern].to_s
+        elsif value.kind_of?(String)
+          '"'+value+'"'
+        elsif value==nil
+          'null'
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/qme/map/map_reduce_executor.rb

@@ -0,0 +1,31 @@
+module QME
+  module MapReduce
+    class Executor
+      def initialize(db)
+        @db = db
+      end
+
+      def measure_def(measure_id)
+        measures = @db.collection('measures')
+        measures.find({'id'=> "#{measure_id}"}).to_a[0]
+      end
+
+      def measure_result(measure_id, parameter_values)
+        
+        measure = Builder.new(measure_def(measure_id), parameter_values)
+
+        records = @db.collection('records')
+        results = records.map_reduce(measure.map_function, measure.reduce_function)
+        result = results.find.to_a[0]
+        value = result['value']
+
+        {
+          :population=>value['i'].to_i,
+          :denominator=> value['d'].to_i,
+          :numerator=> value['n'].to_i,
+          :exceptions=> value['e'].to_i
+        }
+      end
+    end
+  end
+end

data/lib/qme/query/json_document_builder.rb

@@ -0,0 +1,124 @@
+module QME
+  module Query
+    class JSONDocumentBuilder
+      attr_accessor :parameters, :calculated_dates
+
+      # Creates the JSONDocumentBuilder. Will calculate dates if parameters
+      # are passed in.
+      def initialize(measure_json, parameters={})
+        @measure_json = measure_json
+        @parameters = parameters
+        @measure_id = measure_json['id']
+
+        if ! parameters.empty?
+          calculate_dates
+        end
+      end
+
+      # Calculates all dates necessary to create a query for this measure
+      # This will be run by the constructor if params were passed in
+      def calculate_dates
+        ctx = V8::Context.new
+        @parameters.each_pair do |key, value|
+          ctx[key] = value
+        end
+
+        ctx['year'] = 365 * 24 * 60 * 60 # TODO: Replace this with a js file that has all constants
+
+        @calculated_dates = {}
+        @measure_json["calculated_dates"].each_pair do |key, value|
+          @calculated_dates[key] = ctx.eval(value)
+        end
+      end
+
+      def numerator_query
+        create_query(@measure_json['numerator']).merge(denominator_query)
+      end
+      
+      def denominator_query
+        create_query(@measure_json['denominator']).merge(initial_population_query)
+      end
+      
+      def initial_population_query
+        create_query(@measure_json['population'])
+      end
+      
+      def exclusions_query
+        create_query(@measure_json['exception'])
+      end
+
+      # Creates the appropriate JSON document to query MongoDB based on
+      # a measure definition passed in. This method calls itself recursively
+      # to walk the tree and get all possible logical operators available
+      # in a measure definition
+      def create_query(definition_json, args={})
+        if definition_json.has_key?('and')
+          definition_json['and'].each do |operand|
+            create_query(operand, args)
+          end
+        elsif definition_json.has_key?('or')
+          operands = []
+          definition_json['or'].each do |operand|
+            operands << create_query(operand)
+          end
+          args['$or'] = operands
+        elsif definition_json.has_key?('query')
+          process_query(definition_json['query'], args)
+        end
+
+        args
+      end
+
+      # Called by create_query to process leaf nodes in a measure
+      # definition
+      def process_query(definition_json, args)
+        if definition_json.size > 1
+          raise 'A query should have only one property'
+        end
+
+        query_property = definition_json.keys.first
+        document_key = transform_query_property(query_property)
+        document_value = nil
+        query_value = definition_json[query_property]
+        if query_value.kind_of?(Hash)
+          if query_value.size > 1
+            raise 'A query value should only have one property'
+          end
+
+          document_value = {query_value.keys.first.gsub('_', '$') =>
+                            substitute_variables(query_value.values.first)}
+          if args[document_key]
+            args[document_key].merge!(document_value)
+          else
+            args[document_key] = document_value
+          end
+        else
+          document_value = substitute_variables(query_value)
+          args[document_key] = document_value
+        end
+      end
+      
+      # Takes a query property name and transforms it into
+      # a name of a key in a MongoDB document
+      def transform_query_property(property_name)
+        #TODO What do we do with special case fields - the stuff we are keeping at the patient level?
+        if ['birthdate'].include?(property_name)
+          property_name
+        else
+          "measures.#{@measure_id}.#{property_name}"
+        end
+      end
+
+      # Finds strings that start with "@" and replaces them
+      # with the calculated date
+      def substitute_variables(value)
+        if value.kind_of?(String) && value[0] == '@'
+          variable_name = value[1..-1]
+          @calculated_dates[variable_name]
+        else
+          value
+        end
+      end
+    end
+  end
+end