quality-measure-engine 1.1.5 → 2.0.0

data/lib/qme/measure/database_loader.rb

@@ -1,83 +0,0 @@
-require File.join(File.dirname(__FILE__),'measure_loader')
-
-module QME
-  module Database
-  
-    # Utility class for working with JSON files and the database
-    class Loader
-      include DatabaseAccess
-      # Create a new Loader.
-      # @param [String] db_name the name of the database to use
-      def initialize(db_name = nil)
-        determine_connection_information(db_name)
-      end
-      
-      # Load a measure from the filesystem and save it in the database.
-      # @param [String] measure_dir path to the directory containing a measure or measure collection document
-      # @param [String] collection_name name of the database collection to save the measure into.
-      # @return [Array] the stroed measures as an array of JSON measure hashes
-      def save_measure(measure_dir, collection_name)
-        measures = QME::Measure::Loader.load_measure(measure_dir)
-        measures.each do |measure|
-          save(collection_name, measure)
-        end
-        measures
-      end
-      
-      # Save a JSON hash to the specified collection, creates the
-      # collection if it doesn't already exist.
-      # @param [String] collection_name name of the database collection
-      # @param [Hash] json the JSON hash to save in the database 
-      def save(collection_name, json)
-        get_db[collection_name].save(json)
-      end
-      
-      # Drop a database collection
-      # @param [String] collection_name name of the database collection
-      def drop_collection(collection_name)
-        get_db.drop_collection(collection_name)
-      end
-      
-      def save_system_js_fn(name, fn)
-        get_db['system.js'].save(
-          {
-            "_id" => name,
-            "value" => BSON::Code.new(fn)
-          }
-        )
-      end
-      
-      # Save a bundle to the db,  this will save the bundle meta data, javascript extension functions and measures to 
-      # the db in their respective locations
-      # @param [String] bundle_dir the bundle directory
-      # @param [String] bundle_collection the collection to save the bundle meta_data and extension functions to
-      # @param [String] measure_collection the collection to save the measures to, defaults to measures
-      def save_bundle(bundle_dir, measure_dir, bundle_collection='bundles', measure_collection = 'measures')
-        bundle = QME::Measure::Loader.load_bundle(bundle_dir, measure_dir)
-        bundle[:bundle_data][:measures] = []
-        b_id = save(bundle_collection,bundle[:bundle_data])
-        measures = bundle[:measures]
-        measures.each do |measure|
-           measure[:bundle] = b_id
-           m_id = save(measure_collection,measure)
-           bundle[:bundle_data][:measures] << m_id
-        end
-        save(bundle_collection,bundle[:bundle_data])
-        bundle[:extensions].each do |name, fn|
-          save_system_js_fn(name, fn)
-        end
-        bundle
-      end
-      
-      
-      def remove_bundle(bundle_id, bundle_collection = 'bundles', measure_collection = 'measures')
-        bundle = get_db[bundle_collection].find_one(bundle_id)
-        bundle['measures'].each do |measure|
-          mes = get_db[measure_collection].find_one(measure)
-          get_db[measure_collection].remove(mes)
-        end
-        get_db[bundle_collection].remove(bundle)
-      end
-    end
-  end
-end

data/lib/qme/measure/measure_loader.rb

@@ -1,174 +0,0 @@
-gem 'rubyzip'
-require 'json'
-require 'zip/zip'
-require 'zip/zipfilesystem'
-require File.join(File.dirname(__FILE__),'properties_builder')
-
-module QME
-  module Measure
-  
-    # Utility class for working with JSON measure definition files
-    class Loader
-
-      # Load a measure from the filesystem
-      # @param [String] measure_dir path to the directory containing a measure or measure collection document
-      # @return [Array] the measures as an array of JSON measure hashes
-      def self.load_measure(measure_dir)
-        measures = []
-        Dir.glob(File.join(measure_dir, '*.col')).each do |collection_file|
-          component_dir = File.join(measure_dir, 'components')
-          load_collection(collection_file, component_dir).each do |measure|
-            measures << measure
-          end
-        end
-        Dir.glob(File.join(measure_dir, '*.json')).each do |measure_file|
-          files = Dir.glob(File.join(measure_dir,'*.js'))
-          if files.length!=1
-            raise "Unexpected number of map functions in #{measure_dir}, expected 1"
-          end
-          map_file = files[0]
-          measure = load_measure_file(measure_file, map_file)
-          measures << measure
-        end
-        measures
-      end
-      
-      # Load a collection of measures definitions by processing a collection
-      # definition file.
-      # @param [String] collection_file path of the collection definition file
-      # @param [String] component_dir path to the directory that contains the measure components
-      # @return [Array] an array of measure definition JSON hashes
-      def self.load_collection(collection_file, component_dir)
-        collection_def = JSON.parse(File.read(collection_file))
-        measure_file = File.join(component_dir, collection_def['root'])
-        measures = []
-        collection_def['combinations'].each do |combination|
-          combination['metadata'] ||= {}
-          if !combination['map_fn']
-            raise "Missing map function in #{collection_file} (sub_id #{combination['metadata']['sub_id']})"
-          end
-          map_file = File.join(component_dir, combination['map_fn'])
-          measure = load_measure_file(measure_file, map_file)
-          
-          # add inline metadata to top level of definition
-          combination['metadata'].each do |key, value|
-            measure[key] = value
-          end
-          if measure['properties'] && !measure['measure']
-            # load the measure properties if they weren't already added
-            measure['measure'] = get_measure_properties(measure)
-          end
-
-          # add inline measure-specific properties to definition
-          combination['measure'] ||= {}
-          measure['measure'] ||= {}
-          combination['measure'].each do |key, value|
-            measure['measure'][key] = value
-          end
-          ['population', 'denominator', 'numerator', 'exclusions'].each do |component|
-            if combination[component]
-              measure[component] = load_json(component_dir, combination[component])
-            end
-          end
-          measures << measure
-        end
-        measures
-      end
-      
-      # For ease of development and change mananegment, measure definition JSON
-      # files, property lists and JavaScript map functions are stored separately
-      # in the file system, this function combines the three components and 
-      # returns the result.
-      # @param [String] measure_file path to the measure file
-      # @param [String] map_fn_file path to the map function file
-      # @return [Hash] a JSON hash of the measure with embedded map function.
-      def self.load_measure_file(measure_file, map_fn_file)
-        map_fn = File.read(map_fn_file)
-        measure = JSON.parse(File.read(measure_file))
-        measure['map_fn'] = map_fn
-        if measure['properties']
-          measure['measure'] = get_measure_properties(measure)
-        end
-        measure
-      end
-      
-      # Load the measure properties from an external file, converting from JSONified XLS if
-      # necessary
-      def self.get_measure_properties(measure)
-        merged_props = {}
-        # normalize field value to be an array of file names
-        if !(measure['properties'].respond_to?(:each))
-          measure['properties'] = [measure['properties']]
-        end
-        measure['properties'].each do |file|
-          measure_props_file = File.join(ENV['MEASURE_PROPS'], file)
-          measure_props = JSON.parse(File.read(measure_props_file))
-          if measure_props['measure']
-            # copy measure properties over
-            merged_props.merge!(measure_props['measure'])
-          else
-            # convert JSONified XLS to properties format and add to measure
-            converted_props = QME::Measure::PropertiesBuilder.build_properties(measure_props, measure_props_file)['measure']
-            merged_props.merge!(converted_props)
-          end
-        end
-        merged_props
-      end
-      
-      # Load a JSON file from the specified directory
-      # @param [String] dir_path path to the directory containing the JSON file
-      # @param [String] filename the JSON file
-      # @return [Hash] the parsed JSON hash
-      def self.load_json(dir_path, filename)
-        file_path = File.join(dir_path, filename)
-        JSON.parse(File.read(file_path))
-      end
-      
-      
-      #Load a bundle from a directory
-      # @param [String] bundle_path path to directory containing the bundle information
-      def self.load_bundle(bundle_path, measure_dir)
-        begin
-          bundle = {};
-          bundle_file = File.join(bundle_path,'bundle.json')
-          license_file = File.join(bundle_path, 'license.html')
-          
-          bundle[:bundle_data] =  File.exists?(bundle_file) ? JSON.parse(File.read(bundle_file)) : JSON.parse("{}")
-          bundle[:bundle_data][:license] = File.exists?(license_file) ? File.read(license_file) : ""
-          bundle[:extensions] = load_bundle_extensions(bundle_path)
-          bundle[:bundle_data][:extensions] = bundle[:extensions].keys
-          bundle[:measures] = []
-          Dir.glob(File.join(bundle_path, measure_dir, '*')).each do |measure_dir|
-            load_measure(measure_dir).each do |measure|
-              bundle[:measures] << measure
-            end
-          end
-          bundle
-        rescue Exception => e
-          print e.backtrace.join("\n")
-          throw e
-        end
-      end
-      
-      
-      # Load all of the extenson functions that will be available to map reduce functions from the bundle dir
-      # This will load from bundle_path/js and from ext directories in the individule measures directories 
-      # like bundle_path/measures/0001/ext/ 
-      # @param [String] bundle_path the path to the bundle directory
-      # @return [Hash] name, function
-      def self.load_bundle_extensions(bundle_path)
-        extensions = {}
-        process_extension = lambda do |js_file|
-          fn_name = File.basename(js_file, ".js")
-          raw_js = File.read(js_file)
-          extensions[fn_name] = raw_js
-        end
-        Dir.glob(File.join(File.dirname(__FILE__), '../../..', 'js', '*.js')).each &process_extension
-        Dir.glob(File.join(bundle_path, 'js', '*.js')).each &process_extension
-        Dir.glob(File.join(bundle_path, 'measures', '*','ext', '*.js')).each &process_extension
-        extensions
-      end
-      
-    end
-  end
-end

data/lib/qme/measure/properties_builder.rb

@@ -1,184 +0,0 @@
-module QME
-  module Measure
-  
-    # Utility class for converting JSONified XLS file to measure properties
-    class PropertiesBuilder
-    
-      GROUPING = 'GROUPING'
-      STANDARD_TAXONOMY = 'standard_taxonomy'
-      STANDARD_CODE_LIST = 'standard_code_list'
-      STANDARD_CONCEPT = 'standard_concept'
-      STANDARD_CONCEPT_ID = 'standard_concept_id'
-      STANDARD_CATEGORY = 'standard_category'
-      QDS_DATA_TYPE = 'QDS_data_type'
-      PROPERTIES_TO_IGNORE = %w(birthdate measurement_enddate measurement_period)
-      
-      # Convert JSONified measure XLS to measure properties format
-      def self.build_properties(xls_json, xls_file)
-        xls_json = patch_properties(xls_json, xls_file)
-        
-        # build groupings
-        grouped_json = build_groups(xls_json)
-        
-        properties = {}
-        grouped_json.each do |value|
-          property_value = build_property(value)
-          if !PROPERTIES_TO_IGNORE.include?(property_value[STANDARD_CONCEPT])
-            properties[property_name(value)] = property_value
-          end
-        end
-        
-        {'measure' => properties}
-      end
-      
-      # Build the top-level JSON hash for a measure property
-      def self.build_property(parent)
-        property = {}
-        property[STANDARD_CONCEPT] = build_underscore_separated_name(parent[STANDARD_CONCEPT])
-        property[STANDARD_CATEGORY] = build_underscore_separated_name(parent[STANDARD_CATEGORY])
-        property[STANDARD_CONCEPT_ID] = parent[STANDARD_CONCEPT_ID]
-        property['qds_data_type'] = build_underscore_separated_name(parent[QDS_DATA_TYPE])
-        property['qds_id'] = parent['QDS_id']
-        property['type'] = 'array'
-        property['items'] = build_item_def(parent)
-        property['codes'] = build_code_list(parent)
-        property
-      end
-      
-      # Build the definition of a property item
-      def self.build_item_def(property)
-        if property['value']
-          {
-            'type' => 'object',
-            'properties' => {
-              'value' => {
-                'description' => property['value']['description'],
-                'type' => property['value']['type']
-              },
-              'date' => {
-                'description' => property['value']['date_description'],
-                'type' => 'number',
-                'format' => 'utc-sec'
-              }
-            }
-          }
-        elsif property['range']
-          {
-            'type' => 'object',
-            'properties' => {
-              'start' => {
-                'description' => property['range']['start_description'],
-                'type' => 'number',
-                'format' => 'utc-sec'
-              },
-              'end' => {
-                'description' => property['range']['end_description'],
-                'type' => 'number',
-                'format' => 'utc-sec'
-              }
-            }
-          }
-        else
-          {
-            'type' => 'number',
-            'format' => 'utc-sec'
-          }
-        end
-      end
-      
-      # Build the set of code lists for a property
-      def self.build_code_list(property)
-        if property['child_nodes']
-          property['child_nodes'].collect { |item| build_code_def(item) }
-        else
-          [build_code_def(property)]
-        end
-      end
-      
-      # Build a single code list JSON hash for a property
-      def self.build_code_def(property)
-        {
-          'set' => property['standard_taxonomy'],
-          'version' => property['standard_taxonomy_version'],
-          STANDARD_CONCEPT => build_underscore_separated_name(property[STANDARD_CONCEPT]),
-          STANDARD_CONCEPT_ID => property[STANDARD_CONCEPT_ID],
-          'qds_id' => property['QDS_id'],
-          'values' => extract_code_values(property['standard_code_list'], property['standard_taxonomy'])
-        }
-      end
-      
-      # Extract the code values from their string form into an array of strings, one per code
-      def self.extract_code_values(string_list, set)
-        return [] if string_list==nil || string_list.length==0
-        string_list.split(',').collect do |entry|
-          if set=='CPT' && entry.include?('-')
-            # special handling for ranges in CPT code sets, e.g. 10010-10015
-            eval(entry.strip.gsub('-','..')).to_a.collect { |i| i.to_s }
-          else
-            entry.strip
-          end
-        end.flatten
-      end
-      
-      # Generate a property name from the standard concept and qds data type
-      def self.property_name(property)
-        build_underscore_separated_name(property[STANDARD_CONCEPT], property[QDS_DATA_TYPE])
-      end
-      
-      # Break all the supplied strings into separate words and return the resulting list as a
-      # new string with each word separated with '_'
-      def self.build_underscore_separated_name(*components)
-        name = []
-        components.each do |component|
-          name.concat component.gsub(/\W/,' ').split.collect { |word| word.strip.downcase }
-        end
-        name.join '_'
-      end
-      
-      # build an array of grouped properties
-      def self.build_groups(xls_json)
-        grouped_json = []
-        exclude_child_ids = []
-        
-        # add grouped members
-        groups = xls_json.values.select { |value| value[STANDARD_TAXONOMY]!=nil && value[STANDARD_TAXONOMY].upcase==GROUPING }
-        groups.each do |group|
-          group_child_ids = group[STANDARD_CODE_LIST].split(',').collect { |id| id.strip }
-          children = xls_json.values.select do |child| 
-            group_child_ids.include?(child[STANDARD_CONCEPT_ID].strip)
-          end
-          group['child_nodes'] = children
-          grouped_json << group
-          if group['group_type']==nil || group['group_type']!='abstract'
-            exclude_child_ids.concat group_child_ids
-          end
-        end
-
-        # add remaining non-grouped members
-        xls_json.values.each do |value|
-          if value[STANDARD_TAXONOMY]!=GROUPING && !exclude_child_ids.include?(value[STANDARD_CONCEPT_ID].strip)
-            grouped_json<<value
-          end
-        end
-        grouped_json
-      end
-      
-      # Patch the supplied property_json hash with the contents of a patch file named
-      # "#{property_file}.patch" and return the result
-      def self.patch_properties(property_json, property_file)
-        patch_file = "#{property_file}.patch"
-        
-        if File.exists? patch_file
-          patch_json = JSON.parse(File.read(patch_file))
-        
-          property_json = property_json.merge(patch_json) do |key, old, new|
-            old.merge(new)
-          end
-        end
-        property_json
-      end
-      
-    end
-      
-  end
-end

data/lib/qme/measure/properties_converter.rb

@@ -1,27 +0,0 @@
-require 'roo'
-
-module QME
-  module Measure
-  
-    # Utility class for converting NQF XLS files to JSON
-    class Converter
-    
-      #Convert an NQF XLS file to a hash
-      def self.from_xls(file)
-        xls =Excelx.new(file)
-        xls.default_sheet='Measure_QDS'
-        result = {}
-        (xls.header_line+1..xls.last_row).each do |row|
-          entry = {}
-          (xls.first_column..xls.last_column).each do |column|
-            entry[xls.cell(xls.header_line, column)] = xls.cell(row, column)
-          end
-          result[entry['QDS_id']] = entry
-        end
-        result
-      end
-      
-    end
-    
-  end
-end