bonnie_bundler 2.0.0

data/config/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  clients:
+    default:
+      database: bonnie_bundler_test
+      hosts:
+        - localhost:27017

data/lib/bonnie_bundler.rb

@@ -0,0 +1,39 @@
+# Top level include file that brings in all the necessary code
+require 'bundler/setup'
+require 'rubygems'
+require 'yaml'
+require 'roo'
+
+require 'quality-measure-engine'
+require 'hqmf-parser'
+require 'hqmf2js'
+require 'simplexml_parser'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require_relative 'models/measure.rb'
+require_relative 'models/cql_measure.rb'
+require_relative 'measures/loading/exceptions.rb'
+require_relative 'measures/loading/loader.rb'
+require_relative 'measures/loading/base_loader_definition.rb'
+require_relative 'measures/loading/cql_loader.rb'
+require_relative 'measures/loading/value_set_loader.rb'
+require_relative 'measures/logic_extractor.rb'
+require_relative 'measures/mongo_hash_key_wrapper.rb'
+require_relative 'ext/hash.rb'
+require_relative 'ext/valueset.rb'
+require_relative 'measures/elm_parser.rb'
+require_relative 'measures/cql_to_elm_helper.rb'
+require_relative '../config/initializers/mongo.rb'
+
+module BonnieBundler
+  class << self
+    attr_accessor :logger
+  end
+end
+
+if defined?(Rails)
+  require_relative 'ext/railtie'
+else
+  BonnieBundler.logger = Log4r::Logger.new("Bonnie Bundler")
+  BonnieBundler.logger.outputters = Log4r::Outputter.stdout
+end

data/lib/ext/hash.rb

@@ -0,0 +1,28 @@
+class Hash
+
+  def remove_nils
+    clear_nils = Proc.new { |k, v| v.kind_of?(Hash) ? (v.delete_if(&clear_nils); nil) : v.nil? }; 
+    self.delete_if(&clear_nils)
+  end
+
+  def convert_keys_to_strings
+     Hash.convert_keys_to_strings(self)
+     self
+  end
+
+  def self.convert_keys_to_strings(hash)
+     if hash.kind_of? Hash 
+         hash.keys.each do |k|
+          v = hash[k]
+          if k.kind_of? Symbol
+            hash[k.to_s] = hash[k]
+            hash.delete(k)
+          end
+          Hash.convert_keys_to_strings(v)
+       end
+     elsif hash.kind_of? Array 
+       hash.each{|val| Hash.convert_keys_to_strings(val)}
+     end 
+  end
+
+end

data/lib/ext/railtie.rb

@@ -0,0 +1,11 @@
+module BonnieBundler
+  class Railtie < Rails::Railtie
+    initializer 'Rails logger' do
+      BonnieBundler.logger = Rails.logger
+    end
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__),'tasks/*.rake')].each { |f| load f }
+    end
+
+  end
+end

data/lib/ext/valueset.rb

@@ -0,0 +1,11 @@
+module HealthDataStandards
+  module SVS
+    class ValueSet
+      # include Mongoid::Document
+      belongs_to :user
+      belongs_to :bundle, class_name: "HealthDataStandards::CQM::Bundle"
+      scope :by_user, ->(user) { where({'user_id'=>(user ? user.id : nil)}) }
+      index "user_id" => 1
+    end
+  end
+end

data/lib/measures/cql_to_elm_helper.rb

@@ -0,0 +1,90 @@
+module CqlElm
+  class CqlToElmHelper
+      # Translates the cql to elm json using a post request to CQLTranslation Jar.
+      # Returns an array of JSON ELM and an Array of XML ELM
+      def self.translate_cql_to_elm(cql)
+        begin
+          request = RestClient::Request.new(
+            :method => :post,
+            :accept => :json,
+            :content_type => :json,
+            :url => 'http://localhost:8080/cql/translator',
+            :payload => {
+              :multipart => true,
+              :file => cql
+            }
+          )
+   
+          elm_json = request.execute
+
+          # now get the XML ELM
+          request = RestClient::Request.new(
+            :method => :post,
+            :headers => {
+              :accept => 'multipart/form-data',
+              'X-TargetFormat' => 'application/elm+xml'
+            },
+            :content_type => 'multipart/form-data',
+            :url => 'http://localhost:8080/cql/translator',
+            :payload => {
+              :multipart => true,
+              :file => cql
+            }
+          )
+          elm_xmls = request.execute
+    
+          return parse_elm_response(elm_json), parse_multipart_response(elm_xmls)
+        rescue RestClient::BadRequest => e
+          begin
+            # If there is a response, include it in the error else just include the error message
+            cqlError = JSON.parse(e.response)
+            errorMsg = JSON.pretty_generate(cqlError).to_s
+          rescue
+            errorMsg = e.message
+          end
+          # The error text will be written to a load_error file and will not be displayed in the error dialog displayed to the user since
+          # measures_controller.rb does not handle this type of exception
+          raise MeasureLoadingException.new "Error Translating CQL to ELM: " + errorMsg
+        end
+      end
+
+      private
+      # Parse the JSON response into an array of json objects (one for each library)
+      def self.parse_elm_response(response)
+        parts = pre_process_response(response)
+        # Grabs everything from the first '{' to the last '}'
+        results = parts.map{ |part| part.match(/{.+}/m).to_s }
+        results
+      end
+  
+      def self.parse_multipart_response(response)
+        parts = pre_process_response(response)
+        parsed_parts = []
+        parts.each do |part|
+          lines = part.split("\r\n")
+          # The first line will always be empty string
+          lines.shift
+  
+          # find the end of the http headers
+          headerEndIndex = lines.find_index { |line| line == '' }
+  
+          # Remove the headers and reassemble
+          lines.shift(headerEndIndex+1)
+          parsed_parts << lines.join("\r\n")
+        end
+        parsed_parts
+      end
+
+      def self.pre_process_response(response)
+        # Not the same delimiter in the response as we specify ourselves in the request,
+        # so we have to extract it.
+        delimiter = response.split("\r\n")[0].strip
+        parts = response.split(delimiter)
+        # The first part will always be an empty string. Just remove it.
+        parts.shift
+        # The last part will be the "--". Just remove it.
+        parts.pop
+        parts
+      end
+  end
+end

data/lib/measures/elm_parser.rb

@@ -0,0 +1,74 @@
+module CqlElm
+  class Parser
+    #Fields are combined with the refId to find elm node that corrosponds to the current annotation node.
+    @fields = ['expression', 'operand', 'suchThat']
+    @previousNoTrailingSpaceNotPeriod = false
+    
+    def self.parse(elm_xml)
+      ret = {
+        statements: [],
+        identifier: {}
+      }
+      @doc = Nokogiri::XML(elm_xml) {|d| d.noblanks}
+      #extract library identifier data
+      ret[:identifier][:id] = @doc.css("identifier").attr("id").value()
+      ret[:identifier][:version] = @doc.css("identifier").attr("version").value()
+      
+      #extracts the fields of type "annotation" and their children.
+      annotations = @doc.css("annotation")
+      annotations.each do |node|
+          node, define_name = parse_node(node)
+          if !define_name.nil?
+            node[:define_name] = define_name
+            ret[:statements] << node
+          end
+      end
+      ret
+    end
+    
+    #Recursive function that traverses the annotation tree and constructs a representation
+    #that will be compatible with the front end.
+    def self.parse_node(node)
+      ret = {
+        children: []
+      }
+      define_name = nil
+      node.children.each do |child|
+        #Nodes with the 'a' prefix are not leaf nodes
+        if child.namespace.respond_to?(:prefix) && child.namespace.prefix == 'a'
+          node_type = extract_node_type(child)
+          #Parses the current child recursively. child_define_name will bubble up to indicate which
+          #statement is currently being traversed.
+          node, child_define_name = parse_node(child)
+          node[:node_type] = node_type  unless node_type.nil?
+          node[:ref_id] = child['r'] unless child['r'].nil?
+          define_name = child_define_name unless child_define_name.nil? 
+          ret[:children] << node
+        else
+          if (/^define/ =~ child.to_html)
+            define_name = child.to_html.split("\"")[1]
+          end
+          clause = {
+            text: child.to_html.gsub(/\t/, "  ")
+          }
+          clause[:ref_id] = child['r'] unless child['r'].nil?
+          ret[:children] << clause
+        end
+      end
+      return ret, define_name
+    end
+    
+    def self.extract_node_type(child)
+      ref_node = nil
+      node_type = nil
+      #Tries to pair the current annotation node with an elm node.
+      @fields.each do |field|
+        ref_node ||= @doc.at_css(field + '[localId="'+child['r']+'"]') unless child['r'].nil?
+      end
+      #Tries to extract the current node's type.
+      node_type = ref_node['xsi:type'] unless ref_node.nil?
+      node_type
+    end
+
+  end
+end

data/lib/measures/loading/base_loader_definition.rb

@@ -0,0 +1,61 @@
+module Measures
+  # Base Class for the different types of loader formats Bonnie Bundler supports.
+  class BaseLoaderDefinition
+
+    def self.extract(zip_file, entry, out_dir)
+      out_file = File.join(out_dir,Pathname.new(entry.name).basename.to_s)
+      zip_file.extract(entry, out_file)
+      out_file
+    end
+    
+    # Wrapper function that performs checks before extracting all xml files in the given zip 
+    # Returns a hash with the type of xml files present and their paths.
+    # Ex: {:HQMF_XML => '/var/149825825jf/Test111_eMeasure.xml'}
+    def self.extract_xml_files(zip_file, files, output_directory=nil)
+      file_paths_hash = {}
+      if files.count > 0
+        # If no directory is given, create a new temporary directory.
+        if output_directory.nil?
+          # Create a temporary directory to extract all xml files contained in the zip.
+          Dir.mktmpdir do |dir|         
+            file_paths_hash = extract_to_temporary_location(zip_file, files, dir)
+          end
+        # Use the provided directory to extract the files to.
+        else
+          file_paths_hash = extract_to_temporary_location(zip_file, files, output_directory)
+        end
+      end
+      file_paths_hash
+    end      
+ 
+    private 
+    
+    # Extracts the xml files from the zip and provides a key value pair for HQMF and ELM xml files.
+    # Currently only checks for HQMF xml, ELM xml and SIMPLE xml. Uses the root node in each of the files.
+    # {file_type => file_path}
+    def self.extract_to_temporary_location(zip_file, files, output_directory)
+      file_paths_hash = {}
+      file_paths_hash[:ELM_XML] = []
+      begin
+        # Iterate over all files passed in, extract file to temporary directory.
+        files.each do |xml_file|
+          if xml_file && xml_file.size > 0
+            xml_file_path = extract(zip_file, xml_file, output_directory)
+            # Open up xml file and read contents.
+            doc = Nokogiri::XML.parse(File.read(xml_file_path))
+            # Check if root node in xml file matches either the HQMF file or ELM file.
+            if doc.root.name == 'QualityMeasureDocument' # Root node for HQMF XML
+              file_paths_hash[:HQMF_XML] = xml_file_path
+            elsif doc.root.name == 'library' # Root node for ELM XML
+              file_paths_hash[:ELM_XML] << xml_file_path
+            end
+          end
+        end     
+      rescue Exception => e
+        raise MeasureLoadingException.new "Error Checking MAT Export: #{e.message}"
+      end
+      file_paths_hash
+    end
+
+  end
+end

data/lib/measures/loading/cql_loader.rb

@@ -0,0 +1,420 @@
+module Measures
+  # Utility class for loading CQL measure definitions into the database from the MAT export zip
+  class CqlLoader < BaseLoaderDefinition
+
+    def self.mat_cql_export?(zip_file)
+      # Open the zip file and iterate over each of the files.
+      Zip::ZipFile.open(zip_file.path) do |zip_file|
+        # Check for CQL, HQMF, ELM and Human Readable
+        cql_entry = zip_file.glob(File.join('**','**.cql')).select {|x| !x.name.starts_with?('__MACOSX') }.first
+        elm_json = zip_file.glob(File.join('**','**.json')).select {|x| !x.name.starts_with?('__MACOSX') }.first
+        human_readable_entry = zip_file.glob(File.join('**','**.html')).select { |x| !x.name.starts_with?('__MACOSX') }.first
+
+        # Grab all xml files in the zip.
+        zip_xml_files = zip_file.glob(File.join('**','**.xml')).select {|x| !x.name.starts_with?('__MACOSX') }
+
+        if zip_xml_files.count > 0
+          xml_files_hash = extract_xml_files(zip_file, zip_xml_files)
+          !cql_entry.nil? && !elm_json.nil? && !human_readable_entry.nil? && !xml_files_hash[:HQMF_XML].nil? && !xml_files_hash[:ELM_XML].nil?
+        else
+          false
+        end
+      end
+    end
+
+    def self.load_mat_cql_exports(user, zip_file, out_dir, measure_details, vsac_user, vsac_password, overwrite_valuesets=false, cache=false, includeDraft=false, ticket_granting_ticket=nil)
+      measure = nil
+      cql = nil
+      hqmf_path = nil
+      # Grabs the cql file contents, the elm_xml contents, elm_json contents and the hqmf file path
+      files = get_files_from_zip(zip_file, out_dir)
+
+      # Load hqmf into HQMF Parser
+      hqmf_model = Measures::Loader.parse_hqmf_model(files[:HQMF_XML_PATH])
+
+      # Get main measure from hqmf parser
+      main_cql_library = hqmf_model.cql_measure_library
+
+      cql_artifacts = process_cql(files, main_cql_library, user, vsac_user, vsac_password, overwrite_valuesets, cache, includeDraft, ticket_granting_ticket, hqmf_model.hqmf_set_id)
+
+      # Create CQL Measure
+      hqmf_model.backfill_patient_characteristics_with_codes(cql_artifacts[:all_codes_and_code_names])
+      json = hqmf_model.to_json
+      json.convert_keys_to_strings
+
+      # Loop over data criteria to search for data criteria that is using a single reference code.
+      # Once found set the Data Criteria's 'code_list_id' to our fake oid. Do the same for source data criteria.
+      json['data_criteria'].each do |data_criteria_name, data_criteria|
+        # We do not want to replace an existing code_list_id. Skip.
+        unless data_criteria['code_list_id']
+          if data_criteria['inline_code_list']
+            # Check to see if inline_code_list contains the correct code_system and code for a direct reference code.
+            data_criteria['inline_code_list'].each do |code_system, code_list|
+              # Loop over all single code reference objects.
+              cql_artifacts[:single_code_references].each do |single_code_object|
+                # If Data Criteria contains a matching code system, check if the correct code exists in the data critera values.
+                # If both values match, set the Data Criteria's 'code_list_id' to the single_code_object_guid.
+                if code_system == single_code_object[:code_system_name] && code_list.include?(single_code_object[:code])
+                  data_criteria['code_list_id'] = single_code_object[:guid]
+                  # Modify the matching source data criteria
+                  json['source_data_criteria'][data_criteria_name + "_source"]['code_list_id'] = single_code_object[:guid]
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # Create CQL Measure
+      measure = Measures::Loader.load_hqmf_cql_model_json(json, user, cql_artifacts[:all_value_set_oids], main_cql_library, cql_artifacts[:cql_definition_dependency_structure], 
+                                                          cql_artifacts[:elms], cql_artifacts[:elm_annotations], files[:CQL], nil, cql_artifacts[:value_set_oid_version_objects])
+      measure['episode_of_care'] = measure_details['episode_of_care']
+      measure['type'] = measure_details['type']
+
+      # Create, associate and save the measure package.
+      measure.package = CqlMeasurePackage.new(file: BSON::Binary.new(zip_file.read()))
+      measure.package.save
+
+      measure
+    end
+
+    def self.load(file, user, measure_details, vsac_user=nil, vsac_password=nil, overwrite_valuesets=false, cache=false, includeDraft=false, ticket_granting_ticket=nil)
+      measure = nil
+      Dir.mktmpdir do |dir|
+        measure = load_mat_cql_exports(user, file, dir, measure_details, vsac_user, vsac_password, overwrite_valuesets, cache, includeDraft, ticket_granting_ticket)
+      end
+      measure
+    end
+
+    # Manages all of the CQL processing that is not related to the HQMF.
+    def self.process_cql(files, main_cql_library, user, vsac_user=nil, vsac_password=nil, overwrite_valuesets=nil, cache=nil, includeDraft=nil, ticket_granting_ticket=nil, measure_id=nil)
+      elm_strings = files[:ELM_JSON]
+      # Removes 'urn:oid:' from ELM for Bonnie and Parse the JSON
+      elm_strings.each { |elm_string| elm_string.gsub! 'urn:oid:', '' }
+      elms = elm_strings.map{ |elm| JSON.parse(elm, :max_nesting=>1000)}
+      elm_annotations = parse_elm_annotations(files[:ELM_XML])
+
+      # Hash of define statements to which define statements they use.
+      cql_definition_dependency_structure = populate_cql_definition_dependency_structure(main_cql_library, elms)
+      # Go back for the library statements
+      cql_definition_dependency_structure = populate_used_library_dependencies(cql_definition_dependency_structure, main_cql_library, elms)
+
+      # fix up statement names in cql_statement_dependencies to not use periods
+      Measures::MongoHashKeyWrapper::wrapKeys cql_definition_dependency_structure
+
+      # Depening on the value of the value set version, change it to null, strip out a substring or leave it alone.
+      modify_value_set_versions(elms)
+
+      # Grab the value sets from the elm
+      elm_value_sets = []
+      elms.each do | elm |
+        # Confirm the library has value sets
+        if elm['library'] && elm['library']['valueSets'] && elm['library']['valueSets']['def']
+          elm['library']['valueSets']['def'].each do |value_set|
+            elm_value_sets << {oid: value_set['id'], version: value_set['version'], profile: value_set['profile']}
+          end
+        end
+      end
+      # Get Value Sets
+      value_set_models = []
+      if (vsac_user && vsac_password) || ticket_granting_ticket
+        begin
+          value_set_models =  Measures::ValueSetLoader.load_value_sets_from_vsac(elm_value_sets, vsac_user, vsac_password, user, overwrite_valuesets, includeDraft, ticket_granting_ticket, cache, measure_id)
+        rescue Exception => e
+          raise VSACException.new "Error Loading Value Sets from VSAC: #{e.message}"
+        end
+      else
+        # if VSAC credentials aren't provided, find the value sets in the database
+        elm_value_sets.each do |elm_value_set|
+          version = elm_value_set[:version] || "N/A" # 'N/A' is what is stored in the DB for value sets without versions
+          query_params = {user_id: user.id, oid: elm_value_set[:oid]}
+
+          if (elm_value_set[:profile])
+            query_params[:profile] = elm_value_set[:profile]
+          else
+            query_params[:version] = version
+          end
+
+          value_set = HealthDataStandards::SVS::ValueSet.where(query_params).first()
+          if value_set
+            value_set_models << value_set
+          elsif version == "N/A"
+            # if the version is "N/A" and a value set doesn't exist with that version, just grab the existing value set
+            value_set = HealthDataStandards::SVS::ValueSet.where({user_id: user.id, oid: elm_value_set[:oid]}).first()
+            if value_set
+              value_set_models << value_set
+            end
+          end
+        end
+      end
+
+
+      # Get code systems and codes for all value sets in the elm.
+      all_codes_and_code_names = HQMF2JS::Generator::CodesToJson.from_value_sets(value_set_models)
+      # Replace code system oids with friendly names
+      # TODO: preferred solution would be to continue using OIDs in the ELM and enable Bonnie to supply those OIDs
+      #   to the calculation engine in patient data and value sets.
+      replace_codesystem_oids_with_names(elms)
+
+      # Generate single reference code objects and a complete list of code systems and codes for the measure.
+      single_code_references, all_codes_and_code_names = generate_single_code_references(elms, all_codes_and_code_names, user)
+
+      # Add our new fake oids to measure value sets.
+      all_value_set_oids = value_set_models.collect{|vs| vs.oid}
+      single_code_references.each do |single_code|
+        all_value_set_oids << single_code[:guid]
+      end
+
+      # Add a list of value set oids and their versions
+      value_set_oid_version_objects = get_value_set_oid_version_objects(value_set_models, single_code_references)
+
+      cql_artifacts = {:elms => elms,
+                       :elm_annotations => elm_annotations,
+                       :cql_definition_dependency_structure => cql_definition_dependency_structure,
+                       :all_value_set_oids => all_value_set_oids,
+                       :value_set_oid_version_objects => value_set_oid_version_objects,
+                       :single_code_references => single_code_references,
+                       :all_codes_and_code_names => all_codes_and_code_names}
+    end
+
+    # returns a list of objects that include the valueset oids and their versions
+    def self.get_value_set_oid_version_objects(value_sets, single_code_references)
+      # [LDC] need to make this an array of objects instead of a hash because Mongo is
+      # dumb and *let's you* have dots in keys on object creation but *doesn't let you*
+      # have dots in keys on object update or retrieve....
+      value_set_oid_version_objects = []
+      value_sets.each do |vs|
+        value_set_oid_version_objects << {:oid => vs.oid, :version => vs.version}
+      end
+      single_code_references.each do |single_code|
+        value_set_oid_version_objects << {:oid => single_code[:guid], :version => ""}
+      end
+      value_set_oid_version_objects
+    end
+
+    # Replace all the code system ids that are oids with the friendly name of the code system
+    # TODO: preferred solution would be to continue using OIDs in the ELM and enable Bonnie to supply those OIDs
+    #   to the calculation engine in patient data and value sets.
+    def self.replace_codesystem_oids_with_names(elms)
+      elms.each do |elm|
+        # Only do replacement if there are any code systems in this library.
+        if elm['library'].has_key?('codeSystems')
+          elm['library']['codeSystems']['def'].each do |code_system|
+            code_name = HealthDataStandards::Util::CodeSystemHelper.code_system_for(code_system['id'])
+            # if the helper returns "Unknown" then keep what was there
+            code_system['id'] = code_name unless code_name == "Unknown"
+          end
+        end
+      end
+    end
+
+    # Adjusting value set version data. If version is profile, set the version to nil
+    def self.modify_value_set_versions(elms)
+      elms.each do |elm|
+        if elm['library']['valueSets'] && elm['library']['valueSets']['def']
+          elm['library']['valueSets']['def'].each do |value_set|
+            # If value set has a version and it starts with 'urn:hl7:profile:' then set to nil
+            if value_set['version'] && value_set['version'].include?('urn:hl7:profile:')
+              value_set['profile'] = URI.decode(value_set['version'].split('urn:hl7:profile:').last)
+              value_set['version'] = nil
+            # If value has a version and it starts with 'urn:hl7:version:' then strip that and keep the actual version value.
+            elsif value_set['version'] && value_set['version'].include?('urn:hl7:version:')
+              value_set['version'] = URI.decode(value_set['version'].split('urn:hl7:version:').last)
+            end
+          end
+        end
+      end
+    end
+    # Add single code references by finding the codes from the elm and creating new ValueSet objects
+    # With a generated GUID as a fake oid.
+    def self.generate_single_code_references(elms, all_codes_and_code_names, user)
+      single_code_references = []
+      # Add all single code references from each elm file
+      elms.each do | elm |
+        # Check if elm has single reference code.
+        if elm['library'] && elm['library']['codes'] && elm['library']['codes']['def']
+          # Loops over all single codes and saves them as fake valuesets.
+          elm['library']['codes']['def'].each do |code_reference|
+            code_sets = {}
+
+            # look up the referenced code system
+            code_system_def = elm['library']['codeSystems']['def'].find { |code_sys| code_sys['name'] == code_reference['codeSystem']['name'] }
+
+            code_system_name = code_system_def['id']
+            code_system_version = code_system_def['version']
+
+            code_sets[code_system_name] ||= []
+            code_sets[code_system_name] << code_reference['id']
+            # Generate a unique number as our fake "oid"
+            code_guid = SecureRandom.uuid
+            # Keep a list of generated_guids and a hash of guids with code system names and codes.
+            single_code_references << { guid: code_guid, code_system_name: code_system_name, code: code_reference['id'] }
+
+            all_codes_and_code_names[code_guid] = code_sets
+            # Create a new "ValueSet" and "Concept" object and save.
+            valueSet = HealthDataStandards::SVS::ValueSet.new({oid: code_guid, display_name: code_reference['name'], version: '' ,concepts: [], user_id: user.id})
+            concept = HealthDataStandards::SVS::Concept.new({code: code_reference['id'], code_system_name: code_system_name, code_system_version: code_system_version, display_name: code_reference['name']})
+            valueSet.concepts << concept
+            valueSet.save!
+          end
+        end
+      end
+      # Returns a list of single code objects and a complete list of code systems and codes for all valuesets on the measure.
+      return single_code_references, all_codes_and_code_names
+    end
+
+    # Opens the zip and grabs the cql file contents, the ELM contents (XML and JSON) and hqmf_path.
+    def self.get_files_from_zip(zip_file, out_dir)
+      Zip::ZipFile.open(zip_file.path) do |file|
+        cql_entries = file.glob(File.join('**','**.cql')).select {|x| !x.name.starts_with?('__MACOSX') }
+        zip_xml_files = file.glob(File.join('**','**.xml')).select {|x| !x.name.starts_with?('__MACOSX') }
+        elm_json_entries = file.glob(File.join('**','**.json')).select {|x| !x.name.starts_with?('__MACOSX') }
+        
+        begin
+          cql_paths = []
+          cql_entries.each do |cql_file|
+            cql_paths << extract(file, cql_file, out_dir) if cql_file.size > 0
+          end
+          cql_contents = []
+          cql_paths.each do |cql_path|
+            cql_contents << open(cql_path).read
+          end
+
+          elm_json_paths = []
+          elm_json_entries.each do |json_file|
+            elm_json_paths << extract(file, json_file, out_dir) if json_file.size > 0
+          end
+          elm_json = []
+          elm_json_paths.each do |elm_json_path|
+            elm_json << open(elm_json_path).read
+          end
+          
+          xml_file_paths = extract_xml_files(file, zip_xml_files, out_dir)
+          elm_xml_paths = xml_file_paths[:ELM_XML]
+          elm_xml = []
+          elm_xml_paths.each do |elm_xml_path|
+            elm_xml << open(elm_xml_path).read
+          end
+
+          files = { :HQMF_XML_PATH => xml_file_paths[:HQMF_XML],
+                    :ELM_JSON => elm_json,
+                    :CQL => cql_contents,
+                    :ELM_XML => elm_xml }
+          return files
+        rescue Exception => e
+          raise MeasureLoadingException.new "Error Parsing Measure Logic: #{e.message}"
+        end
+      end
+    end
+
+    private
+    def self.parse_elm_annotations(xmls)
+      elm_annotations = {}
+      xmls.each do |xml_lib|
+        lib_annotations = CqlElm::Parser.parse(xml_lib)
+        elm_annotations[lib_annotations[:identifier][:id]] = lib_annotations
+      end
+      elm_annotations
+    end
+
+    # Loops over the populations and retrieves the define statements that are nested within it.
+    def self.populate_cql_definition_dependency_structure(main_cql_library, elms)
+      cql_statement_depencency_map = {}
+      main_library_elm = elms.find { |elm| elm['library']['identifier']['id'] == main_cql_library }
+
+      cql_statement_depencency_map[main_cql_library] = {}
+      main_library_elm['library']['statements']['def'].each { |statement|
+        cql_statement_depencency_map[main_cql_library][statement['name']] = retrieve_all_statements_in_population(statement, elms)
+      }
+      cql_statement_depencency_map
+    end
+
+    # Given a starting define statement, a starting library and all of the libraries,
+    # this will return an array of all nested define statements.
+    def self.retrieve_all_statements_in_population(statement, elms)
+      all_results = []
+      if statement.is_a? String
+        statement = retrieve_sub_statement_for_expression_name(statement, elms)
+      end
+      sub_statement_names = retrieve_expressions_from_statement(statement)
+      # Currently if sub_statement_name is another Population we do not remove it.
+      if sub_statement_names.length > 0
+        sub_statement_names.each do |sub_statement_name|
+          # Check if the statement is not a built in expression
+          sub_library_name, sub_statement = retrieve_sub_statement_for_expression_name(sub_statement_name, elms)
+          if sub_statement
+            all_results << { library_name: sub_library_name, statement_name: sub_statement_name }
+          end
+        end
+      end
+      all_results
+    end
+
+    # Finds which library the given define statement exists in.
+    # Returns the JSON statement that contains the given name.
+    # If given statement name is a built in expression, return nil.
+    def self.retrieve_sub_statement_for_expression_name(name, elms)
+      elms.each do | parsed_elm |
+        parsed_elm['library']['statements']['def'].each do |statement|
+          return [parsed_elm['library']['identifier']['id'], statement] if statement['name'] == name
+        end
+      end
+      nil
+    end
+
+    # Traverses the given statement and returns all of the potential additional statements.
+    def self.retrieve_expressions_from_statement(statement)
+      expressions = []
+      statement.each do |k, v|
+        # If v is nil, an array is being iterated and the value is k.
+        # If v is not nil, a hash is being iterated and the value is v.
+        value = v || k
+        if value.is_a?(Hash) || value.is_a?(Array)
+          expressions.concat(retrieve_expressions_from_statement(value))
+        else
+          if k == 'type' && (v == 'ExpressionRef' || v == 'FunctionRef')
+            # We ignore the Patient expression because it isn't an actual define statment in the cql
+            expressions << statement['name'] unless statement['name'] == 'Patient'
+          end
+        end
+      end
+      expressions
+    end
+
+    # Loops over keys of the given hash and loops over the list of statements
+    # Original structure of hash is {IPP => ["In Demographics", Measurement Period Encounters"], NUMER => ["Tonsillitis"]}
+    def self.populate_used_library_dependencies(starting_hash, main_cql_library, elms)
+      # Starting_hash gets updated with the create_hash_for_all call.
+      starting_hash[main_cql_library].keys.each do |key|
+        starting_hash[main_cql_library][key].each do |statement|
+          create_hash_for_all(starting_hash, statement, elms)
+        end
+      end
+      starting_hash
+    end
+
+    # Traverse list, create keys and drill down for each key.
+    # If key is already in place, skip.
+    def self.create_hash_for_all(starting_hash, key_statement, elms)
+      # If key already exists, return hash
+      if (starting_hash.has_key?(key_statement[:library_name]) &&
+        starting_hash[key_statement[:library_name]].has_key?(key_statement[:statement_name]))
+        return starting_hash
+      # Create new hash key and retrieve all sub statements
+      else
+        # create library hash key if needed
+        if !starting_hash.has_key?(key_statement[:library_name])
+          starting_hash[key_statement[:library_name]] = {}
+        end
+        starting_hash[key_statement[:library_name]][key_statement[:statement_name]] = retrieve_all_statements_in_population(key_statement[:statement_name], elms).uniq
+        # If there are no statements return hash
+        return starting_hash if starting_hash[key_statement[:library_name]][key_statement[:statement_name]].empty?
+        # Loop over array of sub statements and build out hash keys for each.
+        starting_hash[key_statement[:library_name]][key_statement[:statement_name]].each do |statement|
+          starting_hash.merge!(create_hash_for_all(starting_hash, statement, elms))
+        end
+      end
+      starting_hash
+    end
+  end
+end